UC2-REST 0.2.0.42__tar.gz → 0.2.0.43__tar.gz

{uc2_rest-0.2.0.42 → uc2_rest-0.2.0.43}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: UC2-REST
-Version: 0.2.0.42
+Version: 0.2.0.43
 Summary: This pacage will help you to drive the ESP32-driven microscopy control modules from UC2
 Home-page: https://github.com/openUC2/UC2-REST
 Author: Benedict Diederich

{uc2_rest-0.2.0.42 → uc2_rest-0.2.0.43}/UC2_REST.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: UC2-REST
-Version: 0.2.0.42
+Version: 0.2.0.43
 Summary: This pacage will help you to drive the ESP32-driven microscopy control modules from UC2
 Home-page: https://github.com/openUC2/UC2-REST
 Author: Benedict Diederich

{uc2_rest-0.2.0.42 → uc2_rest-0.2.0.43}/UC2_REST.egg-info/SOURCES.txt

@@ -8,6 +8,7 @@ UC2_REST.egg-info/not-zip-safe
 UC2_REST.egg-info/requires.txt
 UC2_REST.egg-info/top_level.txt
 tests/test_canota_reconnect.py
+tests/test_motor_axes.py
 tests/test_stage_scan.py
 uc2rest/MockSerial.py
 uc2rest/UC2Client.py

uc2_rest-0.2.0.43/tests/test_motor_axes.py

@@ -0,0 +1,114 @@
+"""Generic motor axes (stepperid 0-9, named axes), without hardware.
+
+Run: python -m unittest tests.test_motor_axes  (from the repo root)
+"""
+import unittest
+from unittest import mock
+
+from uc2rest.home import Home
+from uc2rest.motor import Motor
+
+
+class _Parent:
+    """Just enough of UC2Client: a serial with register_callback, post_json and a motor."""
+
+    def __init__(self):
+        self.serial = mock.Mock()
+        self.logger = mock.Mock()
+        self.sent = []
+        self.reply = {"qid": 1, "return": 1}
+
+    def post_json(self, path, payload, **kwargs):
+        self.sent.append((path, payload))
+        return self.reply
+
+
+class MotorAxesTest(unittest.TestCase):
+    def setUp(self):
+        self.parent = _Parent()
+        self.motor = self.parent.motor = Motor(parent=self.parent)
+
+    def steppers(self):
+        return self.parent.sent[-1][1]["motor"]["steppers"]
+
+    def test_named_axis_beyond_xyza(self):
+        self.motor.setup_motor("C", minPos=0, maxPos=10, stepSize=0.5, backlash=0)
+        self.motor.move_axis_by_name("C", 10, speed=1000)
+        self.assertEqual([(s["stepperid"], s["position"]) for s in self.steppers()], [(5, 20)])
+        self.motor.move_axis_by_name(7, 3, speed=1000)  # by stepperid
+        self.assertEqual(self.steppers()[0]["stepperid"], 7)
+
+    def test_move_axes_mixed_names(self):
+        self.motor.move_axes({"X": 100, "B": -50}, speed={"X": 2000, "B": 3000})
+        got = {s["stepperid"]: (s["position"], s["speed"]) for s in self.steppers()}
+        self.assertEqual(got, {1: (100, 2000), 4: (-50, 3000)})
+
+    def test_relative_zero_axes_are_not_sent(self):
+        self.motor.move_xyz((0, 5, 0), speed=1000)
+        self.assertEqual([s["stepperid"] for s in self.steppers()], [2])
+
+    def test_remapped_and_custom_names(self):
+        self.motor.setMotorAxisOrder([0, 2, 1, 3])  # legacy: X and Y swapped
+        self.motor.move_x(10, speed=1000)
+        self.assertEqual(self.steppers()[0]["stepperid"], 2)
+        self.motor.set_axis_ids({"T": 6})
+        self.motor.move_axis_by_name("t", 1, speed=1000)
+        self.assertEqual(self.steppers()[0]["stepperid"], 6)
+        with self.assertRaises(ValueError):
+            self.motor.axis_id("Q")
+        with self.assertRaises(ValueError):
+            self.motor.axis_id(10)
+
+    def test_feedback_reaches_every_callback(self):
+        seen = {}
+        self.motor.register_callback("stage1", lambda p: seen.setdefault("a", p[6]))
+        self.motor.register_callback("stage2", lambda p: seen.setdefault("b", p[6]))
+        self.motor.setup_motor("D", 0, 0, stepSize=2, backlash=0, direction=-1)
+        self.motor._callback_motor_status(
+            {"steppers": [{"stepperid": 6, "position": 10}, {"stepperid": 42, "position": 1}]})
+        self.assertEqual(seen, {"a": -20, "b": -20})
+
+    def test_stop_all_sends_only_known_ids(self):
+        self.motor.move_axis_by_name("E", 5, speed=1000)
+        self.motor.stop()
+        self.assertEqual([s["stepperid"] for s in self.steppers()], [0, 1, 2, 3, 7])
+
+    def test_move_forever_only_given_axes(self):
+        self.motor.move_forever({"C": 500})
+        self.assertEqual(self.steppers(), [{"stepperid": 5, "isforever": 1, "speed": 500}])
+
+    def test_get_position_filtered(self):
+        self.parent.reply = [{"steppers": [{"stepperid": 4, "position": 8}, {"stepperid": 5, "isDone": -1}]}]
+        self.motor.setup_motor("B", 0, 0, stepSize=0.25, backlash=0)
+        pos = self.motor.get_position(axis=["B", "C"])
+        self.assertEqual(self.parent.sent[-1][1]["motor"], {"steppers": [{"stepperid": 4}, {"stepperid": 5}]})
+        self.assertEqual((len(pos), pos[4], pos[5]), (10, 2, 0))
+
+    def test_legacy_step_size_attributes(self):
+        self.motor.stepSizeX = 2.0
+        self.assertEqual((self.motor.stepSize[1], self.motor.stepSizeX), (2.0, 2.0))
+
+    def test_backlash_only_on_reversal(self):
+        self.motor.set_backlash("X", 10)
+        self.motor.move_x(100, speed=1000)   # first move counts as a reversal
+        self.assertEqual(self.steppers()[0]["position"], 110)
+        self.motor.move_y(5, speed=1000)     # another axis must not reset X's direction
+        self.motor.move_x(100, speed=1000)
+        self.assertEqual(self.steppers()[0]["position"], 100)
+        self.motor.move_x(-100, speed=1000)
+        self.assertEqual(self.steppers()[0]["position"], -110)
+        self.motor.move_x(0, speed=1000, is_absolute=True)    # still moving down
+        self.assertEqual(self.steppers()[0]["position"], 0)
+        self.motor.move_x(50, speed=1000, is_absolute=True)   # up again: overshoot upwards
+        self.assertEqual(self.steppers()[0]["position"], 60)
+
+    def test_home_named_axis(self):
+        home = Home(self.parent)
+        home.home(axis="C", speed=1000)
+        self.assertEqual(self.parent.sent[-1][1]["home"]["steppers"][0]["stepperid"], 5)
+        home.home_x()
+        self.assertEqual(self.parent.sent[-1][1]["home"]["steppers"][0]["stepperid"], 1)
+
+
+if __name__ == "__main__":
+    unittest.main()

{uc2_rest-0.2.0.42 → uc2_rest-0.2.0.43}/uc2rest/__version__.py

@@ -6,7 +6,7 @@ __version__.py
 
 __title__ = 'UC2-REST'
 __description__ = 'This pacage will help you to drive the ESP32-driven microscopy control modules from UC2'
-__version__ = "v0.2.0.42"
+__version__ = "v0.2.0.43"
 __author__ = 'Benedict Diederich'
 __author_email__ = 'benedictdied@gmail.com'
 __license__ = 'GPL v3'

{uc2_rest-0.2.0.42 → uc2_rest-0.2.0.43}/uc2rest/home.py

@@ -1,6 +1,7 @@
 import time
 import json      
 import numpy as np  
+from .motor import AXIS_NAMES
         
 class Home(object):
     ## Laser
@@ -12,8 +13,8 @@ class Home(object):
         self.timeout = 20000
         self.endstoppolarity = 1
         
-        self.nMotors = 4
-        self.isHomed = np.zeros((self.nMotors))
+        self.nMotors = len(AXIS_NAMES)
+        self.isHomed = np.zeros((self.nMotors))  # indexed by stepperid
         
 
         # register a callback function for the motor status on the serial loop
@@ -43,15 +44,10 @@ class Home(object):
         into the position array of the motors '''
         try:
             steppers = data["home"]["steppers"]
-            # Handle both single stepper and multiple steppers
-            if isinstance(steppers, dict):
-                # Single stepper format: {"axis":1,"pos":0,"isDone":1}
-                stepperID = steppers["axis"]
-                self.isHomed[stepperID] = steppers["isDone"]
-            elif isinstance(steppers, list):
-                # Multiple steppers format: [{"axis":1,"pos":0,"isDone":1}, ...]
-                for stepper in steppers:
-                    stepperID = stepper["axis"]
+            # Single stepper {"axis":1,"pos":0,"isDone":1} or a list of them
+            for stepper in ([steppers] if isinstance(steppers, dict) else steppers):
+                stepperID = stepper["axis"]
+                if 0 <= stepperID < self.nMotors:
                     self.isHomed[stepperID] = stepper["isDone"]
             
             if callable(self._callbackPerKey[0]):
@@ -65,49 +61,21 @@ class Home(object):
         
                 
     def home_x(self, speed = None, direction = None, endposrelease = None, endstoppolarity=None, timeout=None, isBlocking=False):
-        # axis = 1 corresponds to 'X'
-        axis = 1
-        self.home(axis=axis, 
-                  endstoptimeout=timeout, 
-                  speed = speed, 
-                  direction = direction, 
-                  endposrelease=endposrelease,
-                  endstoppolarity=endstoppolarity,
-                  isBlocking=isBlocking)
+        return self.home(axis="X", endstoptimeout=timeout, speed=speed, direction=direction,
+                         endposrelease=endposrelease, endstoppolarity=endstoppolarity, isBlocking=isBlocking)
 
     def home_y(self, speed = None, direction = None, endposrelease = None, endstoppolarity=None, timeout=None, isBlocking=False):
-        # axis = 2 corresponds to 'Y'
-        axis = 2
-        self.home(axis=axis, 
-                  endstoptimeout=timeout, 
-                  speed = speed, 
-                  direction = direction, 
-                  endposrelease=endposrelease, 
-                  endstoppolarity=endstoppolarity,
-                  isBlocking=isBlocking)    
-    
+        return self.home(axis="Y", endstoptimeout=timeout, speed=speed, direction=direction,
+                         endposrelease=endposrelease, endstoppolarity=endstoppolarity, isBlocking=isBlocking)
+
     def home_z(self, speed = None, direction = None, endposrelease = None, endstoppolarity=None, timeout=None, isBlocking=False, hardhome=False):
-        # axisa = 3 corresponds to 'Z'
-        axis = 3
-        self.home(axis=axis, 
-                  endstoptimeout=timeout, 
-                  speed = speed, 
-                  direction = direction, 
-                  endposrelease=endposrelease, 
-                  endstoppolarity=endstoppolarity,
-                  isBlocking=isBlocking,
-                  hardhome=hardhome)    
-        
+        return self.home(axis="Z", endstoptimeout=timeout, speed=speed, direction=direction,
+                         endposrelease=endposrelease, endstoppolarity=endstoppolarity, isBlocking=isBlocking,
+                         hardhome=hardhome)
+
     def home_a(self, speed = None, direction = None, endposrelease = None, endstoppolarity=None, timeout=None, isBlocking=False):
-        # axis = 0 corresponds to 'A'
-        axis = 0
-        self.home(axis=axis,
-                  endstoptimeout=timeout, 
-                  speed = speed, 
-                  direction = direction, 
-                  endposrelease=endposrelease, 
-                  endstoppolarity=endstoppolarity,
-                  isBlocking=isBlocking)    
+        return self.home(axis="A", endstoptimeout=timeout, speed=speed, direction=direction,
+                         endposrelease=endposrelease, endstoppolarity=endstoppolarity, isBlocking=isBlocking)
 
     def home_xy(self, axes=["X", "Y"], speeds=None, directions=None, endposreleases=None, 
                 endstoppolarities=None, timeouts=None, isBlocking=False, preMove=True):
@@ -133,18 +101,8 @@ class Home(object):
                 timeouts=[400, 200]
             )
         """
-        # Convert axes to stepper IDs
-        # First get logical motor index, then map through motorAxisOrder to get physical stepper ID
-        stepper_ids = []
-        motorAxisOrder = self._parent.motor.motorAxisOrder if hasattr(self._parent.motor   , 'motorAxisOrder') else [0, 1, 2, 3]
-        for axis in axes:
-            if isinstance(axis, str):
-                logical_motor_index = self.xyztTo1230(axis)
-            else:
-                logical_motor_index = axis
-            # Map logical motor index to physical stepper ID
-            stepper_id = motorAxisOrder[logical_motor_index]
-            stepper_ids.append(stepper_id)
+        # axis names or stepperids -> stepperids
+        stepper_ids = [self.xyztTo1230(axis) for axis in axes]
         
         num_motors = len(stepper_ids)
         
@@ -180,18 +138,8 @@ class Home(object):
                 preMoveDistanceSteps = 100  # steps to move away from endstop
                 
                 # Move away from endstop using the motor controller
-                if stepper_id == 1:  # X
-                    self._parent.motor.move_x(steps=preMoveDirection*preMoveDistanceSteps, 
-                                            speed=speeds[i], is_blocking=True, is_absolute=False, is_enabled=True)
-                elif stepper_id == 2:  # Y
-                    self._parent.motor.move_y(steps=preMoveDirection*preMoveDistanceSteps, 
-                                            speed=speeds[i], is_blocking=True, is_absolute=False, is_enabled=True)
-                elif stepper_id == 3:  # Z
-                    self._parent.motor.move_z(steps=preMoveDirection*preMoveDistanceSteps, 
-                                            speed=speeds[i], is_blocking=True, is_absolute=False, is_enabled=True)
-                elif stepper_id == 0:  # A
-                    self._parent.motor.move_a(steps=preMoveDirection*preMoveDistanceSteps, 
-                                            speed=speeds[i], is_blocking=True, is_absolute=False, is_enabled=True)
+                self._parent.motor.move_axis_by_name(axis=stepper_id, steps=preMoveDirection*preMoveDistanceSteps,
+                                                     speed=speeds[i], is_blocking=True, is_absolute=False, is_enabled=True)
             time.sleep(0.5)
         
         # Build the steppers list for the JSON payload
@@ -227,22 +175,12 @@ class Home(object):
         return r
     
     def xyztTo1230(self, axis):
-        """Convert axis string to stepper ID number."""
-        if isinstance(axis, str):
-            axis = axis.upper()
-            if axis == "X":
-                return 1
-            elif axis == "Y":
-                return 2
-            elif axis == "Z":
-                return 3
-            elif axis == "A":
-                return 0
-        return axis
+        """Axis name ("X", "B", ...) or stepperid -> stepperid, see Motor.axis_id."""
+        return self._parent.motor.axis_id(axis)
     
     def home(self, axis=None, timeout=None, speed=None, direction=None, endposrelease=None, endstoppolarity=None, endstoptimeout=10000, isBlocking=False, preMove=False, hardhome=False):
         '''
-        axis = 0,1,2,3 or 'A, 'X','Y','Z'
+        axis = stepperid (A=0, X=1, Y=2, Z=3, B..G=4..9) or axis name ('X', 'B', ...)
         timeout => when to stop homing (it's a while loop on the MCU)
         speed => speed of homing (0...15000)
         direction => 1,-1 (left/right)
@@ -275,20 +213,10 @@ class Home(object):
             preMoveDistanceSteps = 100 # steps to move away from endstop
             
             # move away from endstop
-            if axis == 1 or axis == "X":
-                self._parent.motor.move_x(steps=preMoveDirection*preMoveDistanceSteps, speed=self.speed, is_blocking=True, is_absolute=False, is_enabled=True)
-            elif axis == 2 or axis == "Y":
-                self._parent.motor.move_y(steps=preMoveDirection*preMoveDistanceSteps, speed=self.speed, is_blocking=True, is_absolute=False, is_enabled=True)
-            elif axis == 3 or axis == "Z":
-                self._parent.motor.move_z(steps=preMoveDirection*preMoveDistanceSteps, speed=self.speed, is_blocking=True, is_absolute=False, is_enabled=True)
-            elif axis == 0 or axis == "A":
-                self._parent.motor.move_a(steps=preMoveDirection*preMoveDistanceSteps, speed=self.speed, is_blocking=True, is_absolute=False, is_enabled=True)
-            else:   
-                raise ValueError("Invalid axis. Use 'X', 'Y', 'Z', or 'A'.")
+            self._parent.motor.move_axis_by_name(axis=axis, steps=preMoveDirection*preMoveDistanceSteps, speed=self.speed, is_blocking=True, is_absolute=False, is_enabled=True)
             time.sleep(0.5)
         
-        # Map logical motor index to physical stepper ID through motorAxisOrder
-        stepper_id = self._parent.motor.motorAxisOrder[axis]
+        stepper_id = self.xyztTo1230(axis)
         
         # construct json string
         path = "/home_act"