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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: UC2-REST
-Version: 0.2.0.42
+Version: 0.2.0.44
 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.44}/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.44
 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.44}/UC2_REST.egg-info/SOURCES.txt

@@ -8,6 +8,8 @@ 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_motor_get_reply.py
 tests/test_stage_scan.py
 uc2rest/MockSerial.py
 uc2rest/UC2Client.py

uc2_rest-0.2.0.44/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.44/tests/test_motor_get_reply.py

@@ -0,0 +1,92 @@
+"""/motor_get answers vs. position pushes that share their qid (no hardware).
+
+The firmware tags a motor's position push ({"steppers":[{.., "isDone": 1}]}) with the qid of
+that motor's last move; uc2rest's qids wrap after 254 commands, so such a frame can carry the
+qid of a later /motor_get. Taken as the answer, every other axis read 0 (ImSwitch FRAME
+calibration, 2026-11-12: "X reads 728.2 after a move to 19394.5" = device X 0).
+
+Run: python -m unittest tests.test_motor_get_reply  (from the repo root)
+"""
+import threading
+import time
+import unittest
+from unittest import mock
+
+import numpy as np
+
+from uc2rest.motor import Motor
+from uc2rest.mserial import Serial
+
+PUSH = {"steppers": [{"stepperid": 0, "position": -29000, "isDone": 1}], "qid": 7}
+REPLY = {"motor": {"steppers": [{"stepperid": i, "position": p} for i, p in enumerate((-29000, 19000, 60000, 5900))]},
+         "qid": 7}
+
+
+class _Parent:
+    def __init__(self, frames):
+        self.serial = mock.Mock()
+        self.logger = mock.Mock()
+        self.frames = frames
+
+    def post_json(self, path, payload, accept=None, **kwargs):
+        # like Serial.sendMessage: with accept, the matching frame first
+        if accept is not None:
+            hit = next((f for f in self.frames if accept(f)), None)
+            return "communication interrupted by timeout" if hit is None else [hit] + [f for f in self.frames if f is not hit]
+        return list(self.frames)
+
+
+class MotorGetReplyTest(unittest.TestCase):
+    def motor(self, frames):
+        parent = _Parent(frames)
+        m = parent.motor = Motor(parent=parent)
+        for ax in "AXYZ":
+            m.setup_motor(ax, minPos=-1e9, maxPos=1e9, stepSize=1, backlash=0)
+        return m
+
+    def test_push_with_our_qid_is_not_the_answer(self):
+        p = self.motor([PUSH, REPLY]).get_position()
+        self.assertEqual(list(p[:4]), [-29000, 19000, 60000, 5900])
+
+    def test_no_answer_reports_missing(self):
+        m = self.motor([PUSH])
+        self.assertTrue(np.isnan(m.get_position(missing=np.nan)[:4]).all())
+        self.assertEqual(list(m.get_position()[:4]), [0, 0, 0, 0])        # default: as before
+        self.assertEqual(m._read_firmware_positions(), {})
+
+    def test_filtered_can_reply_is_an_answer(self):
+        can = {"steppers": [{"stepperid": 4, "position": 3}, {"stepperid": 5, "isDone": -1}], "qid": 2}
+        self.assertTrue(Motor._is_motor_get_reply(can, ids=[4, 5]))
+        self.assertFalse(Motor._is_motor_get_reply(can))                 # a bare request wants {"motor": ...}
+        self.assertFalse(Motor._is_motor_get_reply(PUSH, ids=[0, 1]))
+        self.assertFalse(Motor._is_motor_get_reply(PUSH))
+        self.assertFalse(Motor._is_motor_get_reply("communication interrupted"))
+
+
+class SendMessageAcceptTest(unittest.TestCase):
+    """Serial.sendMessage waits past frames that share the qid but fail accept."""
+
+    def test_waits_for_the_accepted_frame(self):
+        s = Serial.__new__(Serial)
+        s.lock, s.responses, s.commands = threading.Lock(), {}, {}
+        s.identifier_counter, s.running, s.is_connected = 0, True, True
+        s.resetLastCommand, s.use_qid_done, s.DEBUG, s.manufacturer = False, False, False, "test"
+        s.timeReturnReceived, s._logger, s.cmdWriteCallBackFct = 5, mock.Mock(), None
+
+        def write(dev, payload):
+            qid = s.identifier_counter
+            def arrive():
+                for f in ({**PUSH, "qid": qid}, {**REPLY, "qid": qid}):
+                    time.sleep(0.05)
+                    with s.lock:
+                        s.responses.setdefault(qid, []).append(f)
+            threading.Thread(target=arrive, daemon=True).start()
+        s._write, s.serialdevice = write, None
+        r = s.sendMessage({"task": "/motor_get", "position": True}, nResponses=1, timeout=2,
+                          accept=Motor._is_motor_get_reply)
+        self.assertIn("motor", r[0])
+        self.assertEqual(len(r), 2)
+
+
+if __name__ == "__main__":
+    unittest.main()

{uc2_rest-0.2.0.42 → uc2_rest-0.2.0.44}/uc2rest/UC2Client.py

@@ -177,10 +177,13 @@ class UC2Client(object):
         # initialize module controller
         self.modules = Modules(parent=self)
     
-    def post_json(self, path, payload, getReturn=True, nResponses=1, timeout=1):
+    def post_json(self, path, payload, getReturn=True, nResponses=1, timeout=1, accept=None):
         if timeout <=0:
             getReturn = False
-        return self.serial.post_json(path, payload, getReturn=getReturn, nResponses=nResponses, timeout=timeout)
+        if accept is None:      # serial implementations without the accept argument keep working
+            return self.serial.post_json(path, payload, getReturn=getReturn, nResponses=nResponses, timeout=timeout)
+        return self.serial.post_json(path, payload, getReturn=getReturn, nResponses=nResponses, timeout=timeout,
+                                     accept=accept)
 
     def get_json(self, path, getReturn=True, timeout=1):
         if self.is_serial or self.isPyScript:

{uc2_rest-0.2.0.42 → uc2_rest-0.2.0.44}/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.44"
 __author__ = 'Benedict Diederich'
 __author_email__ = 'benedictdied@gmail.com'
 __license__ = 'GPL v3'

{uc2_rest-0.2.0.42 → uc2_rest-0.2.0.44}/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"