pymodaq_plugins_owis 5.3.0__py3-none-any.whl

pymodaq_plugins_owis/__init__.py

@@ -0,0 +1,13 @@
+from pathlib import Path
+from .utils import Config
+from pymodaq_utils.utils import get_version, PackageNotFoundError
+from pymodaq_utils.logger import set_logger, get_module_name
+
+config = Config()
+try:
+    __version__ = get_version(__package__)
+except PackageNotFoundError:
+    __version__ = '0.0.0dev'
+
+
+

pymodaq_plugins_owis/daq_move_plugins/__init__.py

@@ -0,0 +1,13 @@
+import importlib
+from pathlib import Path
+from .. import set_logger
+logger = set_logger('move_plugins', add_to_console=False)
+
+for path in Path(__file__).parent.iterdir():
+    try:
+        if '__init__' not in str(path):
+            importlib.import_module('.' + path.stem, __package__)
+    except Exception as e:
+        logger.warning("{:} plugin couldn't be loaded due to some missing packages or errors: {:}".format(path.stem, str(e)))
+        pass
+

pymodaq_plugins_owis/daq_move_plugins/daq_move_OWIS_PS10.py

@@ -0,0 +1,135 @@
+from pymodaq.control_modules.move_utility_classes import (DAQ_Move_base, comon_parameters_fun,
+                                                          main, DataActuatorType, DataActuator)
+from pymodaq_utils.config import GlobalConfig
+from pymodaq_utils.utils import ThreadCommand
+from pymodaq_gui.parameter import Parameter
+from qtpy import QtCore
+
+
+from pymodaq_plugins_owis.hardware.ps10 import MockPS10Bus, PS10Axis, PS10Bus, PS10Error, slave_id_from_config
+
+config = GlobalConfig()
+AXES = config('owis', 'ps10', 'axes')
+
+
+class DAQ_Move_OWIS_PS10(DAQ_Move_base):
+    """Actuator plugin for OWIS positioning units driven by PS 10 control units.
+
+    Each PS 10 drives one axis; several units are chained on their CANopen bus, the first one (master) being
+    connected by USB. One module per axis: the master module opens the bus, the others (same Controller ID, slave)
+    share it. The axes, their PS 10 slave ID and their mechanical data (as shown by OWISoft in
+    Control > Define positioning unit) are described in the [[ps10.axes]] blocks of the configuration file.
+
+    Tested with four PS 10-32 units (firmware PS10-V3.0-181010) driving HVM100N-30-HiSM, LTM60-25-HSM and
+    DMT65-DM6-HSM stages, on Windows 11, Python 3.12, PyMoDAQ 5.3.10. Moves, stop and the reference run (mode 4)
+    were tested on the hardware; the MOCK port simulates the bus for development and tests.
+
+    Installation: the USB driver of the PS 10 (supplied by OWIS with OWISoft) must be installed. The parameters of
+    the stages (currents, limit and reference switches, reference velocities) are those stored in the units:
+    configure each axis once with OWISoft. Close OWISoft before using the plugin, both use the same serial port.
+    """
+    
+    is_multiaxes = True
+    _axis_names = [axis['name'] for axis in AXES]
+    _controller_units = [axis['units'] for axis in AXES]
+    _epsilons = 0.001  # mm or deg, about ten microsteps of the stages of the default configuration
+
+    data_actuator_type = DataActuatorType.DataActuator
+
+    params = [
+        {'title': 'Port:', 'name': 'port', 'type': 'str', 'value': config('owis', 'ps10', 'port')},
+    ] + comon_parameters_fun(axis_names=_axis_names)
+
+    def ini_attributes(self):
+        self.controller: PS10Bus | MockPS10Bus | None = None
+        self.axis: PS10Axis | None = None
+        self._home_timer = QtCore.QTimer()
+        self._home_timer.setInterval(100)
+        self._home_timer.timeout.connect(self._check_home)
+        self._returning_home = False
+
+    def ini_stage(self, controller=None):
+        """Open the bus (master module) or reuse the one of the master, then switch the chosen axis on."""
+        if self.is_master:
+            port = self.settings['port']
+            if port == 'MOCK':
+                self.controller = MockPS10Bus(slave_ids=[slave_id_from_config(axis['slave_id']) for axis in AXES])
+            else:
+                self.controller = PS10Bus(port)
+        else:
+            self.controller = controller
+        self._set_axis()
+        state = self.axis.state()
+        return f"{self.axis_name}: {AXES[self.axis_index_key]['stage']}, {state.name}", True
+
+    def _set_axis(self):
+        """Create the PS10Axis of the axis chosen in the settings and switch it on."""
+        self.axis = PS10Axis.from_config(self.controller, AXES[self.axis_index_key])
+        self.axis.init()
+
+    def close(self):
+        """Close the bus, only from the master module that opened it."""
+        if self.is_master and self.controller is not None:
+            self.controller.close()
+
+    def get_actuator_value(self) -> DataActuator:
+        """Position of the axis, read from the counter of its PS 10."""
+        position = DataActuator(data=self.axis.get_position(), units=self.axis_unit)
+        return self.get_position_with_scaling(position)
+
+    def move_abs(self, value: DataActuator):
+        """Start a move to the absolute target value; PyMoDAQ then polls the position."""
+        value = self.check_bound(value)
+        self.target_value = value
+        value = self.set_position_with_scaling(value)
+        self.axis.move_abs(value.value(self.axis_unit))
+
+    def move_rel(self, value: DataActuator):
+        """Start a move by value, as an absolute move to the current position plus value."""
+        value = self.check_bound(self.current_value + value) - self.current_value
+        self.target_value = value + self.current_value
+        target = self.set_position_with_scaling(self.target_value)
+        self.axis.move_abs(target.value(self.axis_unit))
+
+    def move_home(self):
+        """Reference run of the axis (REF1=4), then move to the home_position of the configuration.
+
+        PyMoDAQ does not poll the position after move_home: _check_home calls move_done at the end.
+        """
+        self._returning_home = False
+        self.axis.reference()
+        self._home_timer.start()
+
+    def _check_home(self):
+        """Called every 100 ms during move_home: chain the reference run and the move to home_position."""
+        if self.axis.is_moving():
+            return
+        if not self._returning_home:
+            if not self.axis.is_referenced():
+                self._home_timer.stop()
+                self.emit_status(ThreadCommand('Update_Status',
+                                               [f'reference run of {self.axis_name} failed: {self.axis.state().name}']))
+                self.move_done()
+                return
+            home_position = AXES[self.axis_index_key].get('home_position', 0.)
+            if home_position != 0.:
+                self._returning_home = True
+                self.axis.move_abs(home_position)
+                return
+        self._home_timer.stop()
+        self.move_done()
+
+    def stop_motion(self):
+        """Stop the axis and tell PyMoDAQ that the move is over."""
+        self._home_timer.stop()
+        self.axis.stop()
+        self.move_done()
+
+    def commit_settings(self, param: Parameter):
+        """Apply a change of the settings."""
+        if param.name() == 'axis':
+            self._set_axis()
+
+
+if __name__ == '__main__':
+    main(__file__)

pymodaq_plugins_owis/daq_viewer_plugins/__init__.py

@@ -0,0 +1,3 @@
+
+
+

pymodaq_plugins_owis/daq_viewer_plugins/plugins_0D/__init__.py

@@ -0,0 +1,13 @@
+import importlib
+from pathlib import Path
+from ... import set_logger
+logger = set_logger('viewer0D_plugins', add_to_console=False)
+
+for path in Path(__file__).parent.iterdir():
+    try:
+        if '__init__' not in str(path):
+            importlib.import_module('.' + path.stem, __package__)
+    except Exception as e:
+        logger.warning("{:} plugin couldn't be loaded due to some missing packages or errors: {:}".format(path.stem, str(e)))
+        pass
+

pymodaq_plugins_owis/daq_viewer_plugins/plugins_1D/__init__.py

@@ -0,0 +1,13 @@
+import importlib
+from pathlib import Path
+from ... import set_logger
+logger = set_logger('viewer1D_plugins', add_to_console=False)
+
+for path in Path(__file__).parent.iterdir():
+    try:
+        if '__init__' not in str(path):
+            importlib.import_module('.' + path.stem, __package__)
+    except Exception as e:
+        logger.warning("{:} plugin couldn't be loaded due to some missing packages or errors: {:}".format(path.stem, str(e)))
+        pass
+

pymodaq_plugins_owis/daq_viewer_plugins/plugins_2D/__init__.py

@@ -0,0 +1,14 @@
+import importlib
+from pathlib import Path
+from ... import set_logger
+logger = set_logger('viewer2D_plugins', add_to_console=False)
+
+for path in Path(__file__).parent.iterdir():
+    try:
+        if '__init__' not in str(path):
+            importlib.import_module('.' + path.stem, __package__)
+    except Exception as e:
+        logger.warning("{:} plugin couldn't be loaded due to some missing packages or errors: {:}".format(path.stem, str(e)))
+        pass
+
+

pymodaq_plugins_owis/daq_viewer_plugins/plugins_ND/__init__.py

@@ -0,0 +1,13 @@
+import importlib
+from pathlib import Path
+from ... import set_logger
+logger = set_logger('viewerND_plugins', add_to_console=False)
+
+for path in Path(__file__).parent.iterdir():
+    try:
+        if '__init__' not in str(path):
+            importlib.import_module('.' + path.stem, __package__)
+    except Exception as e:
+        logger.warning("{:} plugin couldn't be loaded due to some missing packages or errors: {:}".format(path.stem, str(e)))
+        pass
+

pymodaq_plugins_owis/exporters/__init__.py

@@ -0,0 +1,6 @@
+# -*- coding: utf-8 -*-
+"""
+Created the 01/06/2023
+
+@author: Sebastien Weber
+"""

pymodaq_plugins_owis/extensions/__init__.py

@@ -0,0 +1,6 @@
+# -*- coding: utf-8 -*-
+"""
+Created the 01/06/2023
+
+@author: Sebastien Weber
+"""

pymodaq_plugins_owis/hardware/ps10.py

@@ -0,0 +1,257 @@
+"""Wrapper for OWIS PS 10 control units linked by a CANopen bus.
+
+The master unit is connected by USB (virtual serial port), the slaves are reached through it by prefixing
+each command with their two-digit slave ID.
+"""
+import time
+from enum import Enum
+
+import serial
+
+BAUDRATE = 9600
+TERMINATOR = b'\r'
+COMMAND_DELAY = 0.05  # s, the manual asks for 20 to 40 ms between two commands
+MASTER = 'master'  # slave_id of the unit connected by USB in the configuration
+
+class PS10Error(Exception):
+    """Raised when a PS 10 unit does not answer a query."""
+
+
+class PS10Bus:
+    """Serial link to the master PS 10 and, through it, to its slaves.
+
+    A unit is addressed by its slave ID: None for the master, 1, 2, 3... for the slaves.
+    """
+
+    def __init__(self, port: str, baudrate: int = BAUDRATE, timeout: float = 0.5):
+        self._serial = serial.Serial(port, baudrate, timeout=timeout)
+
+    @staticmethod
+    def _prefix(slave_id) -> str:
+        return '' if slave_id is None else f'{slave_id:02d}'
+
+    def write(self, slave_id, command: str):
+        """Send a command that has no reply (INIT1, PGO1...)."""
+        self._serial.reset_input_buffer()
+        self._serial.write((self._prefix(slave_id) + command).encode('ascii') + TERMINATOR)
+        time.sleep(COMMAND_DELAY)
+
+    def query(self, slave_id, command: str) -> str:
+        """Send a query (?CNT1, ?ASTAT...) and return its reply without the terminator."""
+        self.write(slave_id, command)
+        reply = self._serial.read_until(TERMINATOR)
+        if not reply.endswith(TERMINATOR):
+            unit = 'master' if slave_id is None else f'slave {slave_id}'
+            raise PS10Error(f'no reply from the {unit} to {command}')
+        return reply[:-len(TERMINATOR)].decode('ascii')
+
+    def close(self):
+        if self._serial.is_open:
+            self._serial.close()
+
+
+class AxisState(str, Enum):
+    """States returned by ?ASTAT (PS 10 manual, command set)."""
+    NOT_INITIALIZED = 'I'
+    DISABLED = 'O'
+    READY = 'R'
+    POSITIONING = 'T'
+    VELOCITY_MODE = 'V'
+    REFERENCE_RUN = 'P'
+    RELEASING_LIMIT_SWITCH = 'F'
+    STOPPED_AT_LIMIT_SWITCH = 'L'
+    STOPPED_AT_BRAKE_SWITCH = 'B'
+    LIMIT_SWITCH_ERROR = 'A'
+    MOTION_CONTROLLER_ERROR = 'M'
+    TIMEOUT = 'Z'
+    PHASE_INITIALIZATION = 'H'
+    NOT_ENABLED = 'U'
+    MOTION_ERROR = 'E'
+    UNKNOWN = '?'
+
+
+MOVING_STATES = (AxisState.POSITIONING, AxisState.VELOCITY_MODE,
+                 AxisState.REFERENCE_RUN, AxisState.RELEASING_LIMIT_SWITCH)
+
+
+def slave_id_from_config(slave_id) -> int | None:
+    """None for the master ('master' in the configuration), the slave ID otherwise."""
+    return None if slave_id == MASTER else int(slave_id)
+
+def steps_per_unit(pitch: float, gear_ratio: float, fullsteps_per_revolution: int, microsteps: int) -> float:
+    """Microsteps per mm (or per degree) of a stage driven by a stepper motor.
+
+    The values are those shown by OWISoft in Control > Define positioning unit.
+    """
+    return gear_ratio * fullsteps_per_revolution * microsteps / pitch
+
+
+class PS10Axis:
+    """The single axis of one PS 10 unit, in physical units (mm or deg).
+
+    Parameters
+    ----------
+    bus: PS10Bus
+        the serial link shared by all the units
+    slave_id: int or None
+        None for the master, the slave ID otherwise
+    steps_per_unit: float
+        microsteps per mm (linear stage) or per degree (rotation stage)
+    """
+    def __init__(self, bus: PS10Bus, slave_id, steps_per_unit: float):
+        self._bus = bus
+        self.slave_id = slave_id
+        self.steps_per_unit = steps_per_unit
+
+    @classmethod
+    def from_config(cls, bus: PS10Bus, axis: dict) -> 'PS10Axis':
+        """Build an axis from one [[ps10.axes]] block of the configuration."""
+        slave_id = slave_id_from_config(axis['slave_id'])
+        return cls(bus, slave_id, steps_per_unit(axis['pitch'], axis['gear_ratio'],
+                                                 axis['fullsteps_per_revolution'], axis['microsteps']))
+
+    def init(self):
+        """Switch the axis on if needed and use absolute targets.
+
+        INIT1 is sent only when the axis is not ready: on a PS 10 it also clears the validity of the
+        reference run (?REFST1), even on an axis that is already switched on.
+        """
+        if self.state() != AxisState.READY:
+            self._bus.write(self.slave_id, 'INIT1')
+        self._bus.write(self.slave_id, 'ABSOL1')
+
+    def state(self) -> AxisState:
+        """Current state of the axis, see AxisState."""
+        reply = self._bus.query(self.slave_id, '?ASTAT')
+        try:
+            return AxisState(reply)
+        except ValueError:
+            raise PS10Error(f'unknown axis state {reply!r}') from None
+
+    def is_moving(self) -> bool:
+        return self.state() in MOVING_STATES
+
+    def get_position(self) -> float:
+        return int(self._bus.query(self.slave_id, '?CNT1')) / self.steps_per_unit
+
+    def move_abs(self, position: float):
+        """Start a move to position; return without waiting for the end of the move."""
+        steps = round(position * self.steps_per_unit)
+        self._bus.write(self.slave_id, f'PSET1={steps}')
+        self._bus.write(self.slave_id, 'PGO1')
+
+    def stop(self):
+        self._bus.write(self.slave_id, 'STOP1')
+
+    def reference(self, mode: int = 4):
+        """Start a reference run, REF1=mode in the PS 10 manual.
+
+        Mode 4, used by OWISoft for these stages, approaches the reference switch, releases it and sets the
+        position to 0. The run ends when the axis is no longer moving.
+        """
+        self._bus.write(self.slave_id, f'REF1={mode}')
+
+    def is_referenced(self) -> bool:
+        """True after a successful reference run; reset when an open-loop stepper motor is switched off."""
+        return self._bus.query(self.slave_id, '?REFST1') == '1'
+
+
+class _SimulatedUnit:
+    """State of one simulated PS 10 unit."""
+
+    def __init__(self, velocity: int):
+        self.velocity = velocity  # microsteps per second, as returned by ?PVEL1
+        self.state = AxisState.DISABLED
+        self.absolute = False
+        self.target = 0
+        self._start = 0
+        self._end = 0
+        self._start_time = 0.
+        self._duration = 0.
+        self.referenced = False
+
+    def counter(self) -> int:
+        """Current position in microsteps; ends the move when its duration has elapsed."""
+        if self.state in (AxisState.POSITIONING, AxisState.REFERENCE_RUN):
+            elapsed = time.perf_counter() - self._start_time
+            if elapsed < self._duration:
+                return round(self._start + (self._end - self._start) * elapsed / self._duration)
+            if self.state == AxisState.REFERENCE_RUN:
+                self.referenced = True
+            self.state = AxisState.READY
+            self._start = self._end
+        return self._start
+
+    def reference(self):
+        start = self.counter()
+        self._start = start
+        self._end = 0
+        self._start_time = time.perf_counter()
+        self._duration = abs(start) / self.velocity
+        self.state = AxisState.REFERENCE_RUN
+
+    def stop(self):
+        self._start = self.counter()
+        if self.state in (AxisState.POSITIONING, AxisState.REFERENCE_RUN):
+            self.state = AxisState.READY
+
+    def go(self):
+        start = self.counter()
+        self._start = start
+        self._end = self.target if self.absolute else start + self.target
+        self._start_time = time.perf_counter()
+        self._duration = abs(self._end - start) / self.velocity
+        self.state = AxisState.POSITIONING
+
+
+class MockPS10Bus:
+    """Simulated PS 10 units with the same public methods as PS10Bus, used for tests and for port MOCK.
+
+    Only the commands used by PS10Axis are simulated; any other one raises PS10Error.
+    """
+
+    def __init__(self, slave_ids=(None,), velocity: int = 25000):
+        self._units = {slave_id: _SimulatedUnit(velocity) for slave_id in slave_ids}
+
+    def write(self, slave_id, command: str):
+        unit = self._units.get(slave_id)
+        if unit is None:
+            return  # an absent unit does not react, as on the real bus
+        unit.counter()  # update the state first
+        if command == 'INIT1':
+            unit.state = AxisState.READY
+        elif command == 'ABSOL1':
+            unit.absolute = True
+        elif command == 'RELAT1':
+            unit.absolute = False
+        elif command.startswith('PSET1='):
+            unit.target = int(command.split('=')[1])
+        elif command == 'PGO1':
+            if unit.state == AxisState.READY:
+                unit.go()
+        elif command == 'STOP1':
+            unit.stop()
+        elif command.startswith('REF1='):
+            if unit.state == AxisState.READY:
+                unit.reference()
+        else:
+            raise PS10Error(f'{command} is not simulated')
+
+    def query(self, slave_id, command: str) -> str:
+        unit = self._units.get(slave_id)
+        if unit is None:
+            unit_name = 'master' if slave_id is None else f'slave {slave_id}'
+            raise PS10Error(f'no reply from the {unit_name} to {command}')
+        position = unit.counter()
+        replies = {'?ASTAT': unit.state.value,
+                   '?CNT1': str(position),
+                   '?MODE1': 'ABSOL' if unit.absolute else 'RELAT',
+                   '?PVEL1': str(unit.velocity),
+                   '?VERSION': 'PS10-MOCK',
+                   '?REFST1': '1' if unit.referenced else '0'}
+        if command not in replies:
+            raise PS10Error(f'{command} is not simulated')
+        return replies[command]
+
+    def close(self):
+        pass

pymodaq_plugins_owis/models/__init__.py

@@ -0,0 +1,6 @@
+# -*- coding: utf-8 -*-
+"""
+Models of the extensions (PID, optimizers, DataMixer, Sequencer...) provided by this plugin package, one model per
+module. Empty on purpose: see the section "Models of the extensions" of AGENTS.md and set models = true in the
+[features] table of pyproject.toml once you add one.
+"""

pymodaq_plugins_owis/resources/config_template.toml

@@ -0,0 +1,29 @@
+title = 'Configuration file of pymodaq_plugins_owis'
+
+[ps10]
+port = 'MOCK'  # serial port of the master PS 10 (e.g. 'COM8'), MOCK for a simulated bus
+
+# One [[ps10.axes]] block per PS 10 unit, with the values shown by OWISoft in
+# Control > Define positioning unit. slave_id is 'master' for the unit connected by USB,
+# else its slave ID on the CANopen bus (Control > CANopen bus > Check hardware).
+
+[[ps10.axes]]
+name = 'Z'
+stage = 'HVM100N-30-HiSM'
+slave_id = 'master'
+units = 'mm'
+pitch = 0.5  # units per revolution of the spindle (mm, or deg for a rotation stage)
+gear_ratio = 1.0
+fullsteps_per_revolution = 200
+microsteps = 50
+home_position = 15  # position reached after the reference run, in the unit of the axis
+
+[[ps10.axes]]
+name = "Theta"
+stage = "DMT65-DM6-HSM"
+slave_id = 2
+units = "degree"
+pitch = 360.0
+gear_ratio = 180.0
+fullsteps_per_revolution = 200
+microsteps = 50

pymodaq_plugins_owis/scanners/__init__.py

@@ -0,0 +1,6 @@
+# -*- coding: utf-8 -*-
+"""
+Created the 01/06/2023
+
+@author: Sebastien Weber
+"""

pymodaq_plugins_owis/utils.py

@@ -0,0 +1,15 @@
+# -*- coding: utf-8 -*-
+"""
+Created the 31/08/2023
+
+@author: Sebastien Weber
+"""
+from pathlib import Path
+
+from pymodaq_utils.config import BaseConfig, USER
+
+
+class Config(BaseConfig):
+    """Main class to deal with configuration values for this plugin"""
+    config_template_path = Path(__file__).parent.joinpath('resources/config_template.toml')
+    config_name = f"config_{__package__.split('pymodaq_plugins_')[1]}"

pymodaq_plugins_owis-5.3.0.dist-info/METADATA

@@ -0,0 +1,131 @@
+Metadata-Version: 2.5
+Name: pymodaq_plugins_owis
+Version: 5.3.0
+Summary: PyMoDAQ plugin for OWIS positioning units driven by PS 10 control units
+Project-URL: Homepage, https://pymodaq.cnrs.fr
+Project-URL: Documentation , https://pymodaq.cnrs.fr
+Project-URL: Repository , https://github.com/PyMoDAQ/pymodaq_plugins_owis
+Author-email: Jérémie Margueritat <jeremie.margueritat@univ-lyon1.fr>
+Maintainer-email: Jérémie Margueritat <jeremie.margueritat@univ-lyon1.fr>
+License: The MIT License (MIT)
+        
+        Copyright (c) 2021 Sebastien Weber <sebastien.weber@cemes.fr>
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in
+        all copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+        THE SOFTWARE.
+License-File: LICENSE
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Human Machine Interfaces
+Classifier: Topic :: Scientific/Engineering :: Visualization
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: User Interfaces
+Requires-Python: >=3.10
+Requires-Dist: pymodaq-data>=5.3.0
+Requires-Dist: pymodaq-gui>=5.3.0
+Requires-Dist: pymodaq-utils>=5.3.1
+Requires-Dist: pymodaq>=5.3.7
+Requires-Dist: pyserial
+Description-Content-Type: text/x-rst
+
+pymodaq_plugins_owis
+####################
+
+.. image:: https://img.shields.io/pypi/v/pymodaq_plugins_owis.svg
+   :target: https://pypi.org/project/pymodaq_plugins_owis/
+   :alt: Latest Version
+
+.. image:: https://readthedocs.org/projects/pymodaq/badge/?version=latest
+   :target: https://pymodaq.readthedocs.io/en/stable/?badge=latest
+   :alt: Documentation Status
+
+.. image:: https://github.com/PyMoDAQ/pymodaq_plugins_owis/actions/workflows/Test.yml/badge.svg
+    :target: https://github.com/PyMoDAQ/pymodaq_plugins_owis/actions/workflows/Test.yml
+
+
+PyMoDAQ plugin for OWIS positioning units driven by PS 10 control units, chained on their CANopen bus.
+
+This branch targets **PyMoDAQ 5.3.x** (Python 3.10 to 3.13).
+
+Authors
+=======
+
+* Jérémie Margueritat (jeremie.margueritat@univ-lyon1.fr)
+
+Instruments
+===========
+
+Below is the list of instruments included in this plugin
+
+Actuators
++++++++++
+
+* **OWIS_PS10**: OWIS stages driven by PS 10 control units, one axis per unit, the units being chained on their
+  CANopen bus (tested with HVM100N-30-HiSM, LTM60-25-HSM and DMT65-DM6-HSM stages)
+
+
+Installation instructions
+=========================
+
+* Tested with PyMoDAQ 5.3.10, Python 3.12, Windows 11.
+* Install the USB driver of the PS 10, supplied by OWIS with OWISoft.
+* Configure each stage once with OWISoft (currents, limit and reference switches, reference velocities): the plugin
+  uses the parameters stored in the units. Close OWISoft before using the plugin, both use the same serial port.
+
+
+Configuration
+=============
+
+The serial port and the axes are read from the configuration of the plugin. Describe your setup in your local
+configuration file (``config_owis.toml`` in the ``config`` folder of your PyMoDAQ user directory), with
+PyMoDAQ closed, since PyMoDAQ rewrites this file when it closes. Each ``[[ps10.axes]]`` block describes one unit,
+with the values shown by OWISoft in *Control > Define positioning unit*::
+
+    [ps10]
+    port = 'COM8'  # MOCK to simulate the units
+
+    [[ps10.axes]]
+    name = 'X'
+    stage = 'LTM60-25-HSM'
+    slave_id = 'master'  # else the slave ID of the unit on the CANopen bus
+    units = 'mm'  # 'degree' for a rotation stage
+    pitch = 1.0
+    gear_ratio = 1.0
+    fullsteps_per_revolution = 200
+    microsteps = 50
+    home_position = 12.5  # position reached after the reference run
+
+The axes of the local file replace those of the template. *Home* runs the reference run of the PS 10 (mode 4:
+approach the reference switch, release it, set the position to 0), then moves the axis to its ``home_position``.
+
+
+Development
+===========
+
+* Install your plugin in editable mode: ``pip install -e .``
+* Check it, without any hardware: ``check_plugin`` and ``pytest tests``
+* If you use an AI coding assistant, point it to ``AGENTS.md``: it describes the patterns to follow for instrument
+  plugins, Dashboard extensions (``CustomExt``, whenever instruments are involved) and standalone apps
+  (``CustomApp``, only if no instruments are needed).

pymodaq_plugins_owis-5.3.0.dist-info/RECORD

@@ -0,0 +1,23 @@
+pymodaq_plugins_owis/__init__.py,sha256=kHISHcIGvr98_YfphdBAs1wThG_WCeoh_Vt0mftOxck,306
+pymodaq_plugins_owis/utils.py,sha256=saBKehqiq5myeh7GCW1vYf5wq4QVYhSVLTxFK6KkdP4,419
+pymodaq_plugins_owis/app/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pymodaq_plugins_owis/daq_move_plugins/__init__.py,sha256=H-DnuGG6lezGyUjuhavlXRbzoQqzMbZaT3mfMNnAhHk,454
+pymodaq_plugins_owis/daq_move_plugins/daq_move_OWIS_PS10.py,sha256=5cRc2qG7t60r3-VHWSU7PuGDplBSCzChSoWxizoUopc,6113
+pymodaq_plugins_owis/daq_viewer_plugins/__init__.py,sha256=ajz1GSNU9xYVrFEDSz6Xwg7amWQ_yvW75tQa1ZvRIWc,3
+pymodaq_plugins_owis/daq_viewer_plugins/plugins_0D/__init__.py,sha256=ooWW3pJyqQ8lk_bgXe8RXvCZLzl41Cm5gJxwSc-vaCc,459
+pymodaq_plugins_owis/daq_viewer_plugins/plugins_1D/__init__.py,sha256=R2Z_g54zfMJ16Kj3dA7MRj3TF8rjK8lWVAqwJ_yPYTA,459
+pymodaq_plugins_owis/daq_viewer_plugins/plugins_2D/__init__.py,sha256=U43pcyA6aNdltDFbW0TbxpQ2MWYJy3BW-dNucGTjoBc,460
+pymodaq_plugins_owis/daq_viewer_plugins/plugins_ND/__init__.py,sha256=AkMkmRCEIkEN8Jxnd0xFhmaTfLm-Sg95TozVstPsHLI,459
+pymodaq_plugins_owis/exporters/__init__.py,sha256=vqgY3SHF6EhPcfeS8lzb7QvAiTIXWmyObIaCYeJNb6Y,81
+pymodaq_plugins_owis/extensions/__init__.py,sha256=vqgY3SHF6EhPcfeS8lzb7QvAiTIXWmyObIaCYeJNb6Y,81
+pymodaq_plugins_owis/hardware/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pymodaq_plugins_owis/hardware/ps10.py,sha256=vF_sppouoOUt89hX50QA7zmM_KUcAme3uJKLDwqzxzE,9620
+pymodaq_plugins_owis/models/__init__.py,sha256=2rW2yi-kdYDhhu1FlnPon1lDotzVh2-IoHDR9KKYU54,311
+pymodaq_plugins_owis/resources/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pymodaq_plugins_owis/resources/config_template.toml,sha256=5T_fw3WCOl0WExf9t5KNkDVBJYDO4RGOlUu33FcfwXM,885
+pymodaq_plugins_owis/scanners/__init__.py,sha256=vqgY3SHF6EhPcfeS8lzb7QvAiTIXWmyObIaCYeJNb6Y,81
+pymodaq_plugins_owis-5.3.0.dist-info/METADATA,sha256=7LUnc0Bg9P-4duQSsvC06otD8QfovNrQRRNzMFsim5s,5702
+pymodaq_plugins_owis-5.3.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+pymodaq_plugins_owis-5.3.0.dist-info/entry_points.txt,sha256=waouxVib5DczcpNmEvWbLTZEqjluA8VMBUxaS2dkyPU,97
+pymodaq_plugins_owis-5.3.0.dist-info/licenses/LICENSE,sha256=VKOejxexXAe3XwfhAhcFGqeXQ12irxVHdeAojZwFEI8,1108
+pymodaq_plugins_owis-5.3.0.dist-info/RECORD,,

pymodaq_plugins_owis-5.3.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.33.0
+Root-Is-Purelib: true
+Tag: py3-none-any

pymodaq_plugins_owis-5.3.0.dist-info/entry_points.txt

@@ -0,0 +1,5 @@
+[pymodaq.instruments]
+owis = pymodaq_plugins_owis
+
+[pymodaq.plugins]
+owis = pymodaq_plugins_owis

pymodaq_plugins_owis-5.3.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2021 Sebastien Weber <sebastien.weber@cemes.fr>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.