UC2-REST 0.2.0.35__tar.gz → 0.2.0.37__tar.gz

{uc2_rest-0.2.0.35 → uc2_rest-0.2.0.37}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: UC2-REST
-Version: 0.2.0.35
+Version: 0.2.0.37
 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.35 → uc2_rest-0.2.0.37}/UC2_REST.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: UC2-REST
-Version: 0.2.0.35
+Version: 0.2.0.37
 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.35 → uc2_rest-0.2.0.37}/uc2rest/UC2Client.py

@@ -47,9 +47,9 @@ class UC2Client(object):
     is_serial = False
     BAUDRATE = 115200
 
-    def __init__(self, host=None, port=31950, serialport=None, identity="UC2_Feather", baudrate=BAUDRATE, 
+    def __init__(self, host=None, port=31950, serialport=None, identity="UC2_Feather", baudrate=BAUDRATE,
                  NLeds=64, SerialManager=None, DEBUG=False, logger=None, skipFirmwareCheck=False,
-                 isPyScript=False):
+                 isPyScript=False, device_id=None, requireMaster=False):
         '''
         This client connects to the UC2-REST microcontroller that can be found here
         https://github.com/openUC2/UC2-REST
@@ -80,7 +80,7 @@ class UC2Client(object):
         # initialize communication channel (serial only)
         if serialport is not None:
             # use USB connection
-            self.serial = Serial(serialport, baudrate, parent=self, identity=identity, DEBUG=DEBUG, skipFirmwareCheck=skipFirmwareCheck)
+            self.serial = Serial(serialport, baudrate, parent=self, identity=identity, DEBUG=DEBUG, skipFirmwareCheck=skipFirmwareCheck, device_id=device_id, requireMaster=requireMaster)
             self.is_serial = True
             self.is_connected = self.serial.is_connected
             self.serial.DEBUG = DEBUG

{uc2_rest-0.2.0.35 → uc2_rest-0.2.0.37}/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.35"
+__version__ = "v0.2.0.37"
 __author__ = 'Benedict Diederich'
 __author_email__ = 'benedictdied@gmail.com'
 __license__ = 'GPL v3'

uc2_rest-0.2.0.37/uc2rest/can.py

@@ -0,0 +1,282 @@
+class CAN(object):
+    def __init__(self, parent):
+        """
+        CANController handles sending commands to a remote CAN device via the parent post_json interface.
+
+        :param parent: Parent object with post_json(path, payload, getReturn, timeout, nResponses)
+        """
+        self._parent = parent
+        
+        # Store latest scan results
+        self.scanResults = []
+        self.deviceCount = 0
+        
+        # Register a callback function for the CAN status on the serial loop
+        if hasattr(self._parent, "serial"):
+            self._parent.serial.register_callback(self._callback_can_status, pattern="scan")
+        
+        # Announce a function that is called when we receive a CAN scan update through the callback
+        self._callbackPerKey = {}
+        self.nCallbacks = 10
+        self._callbackPerKey = self.init_callback_functions(nCallbacks=self.nCallbacks)
+        print(self._callbackPerKey)
+    
+    def init_callback_functions(self, nCallbacks=10):
+        """Initialize the callback functions."""
+        _callbackPerKey = {}
+        self.nCallbacks = nCallbacks
+        for i in range(nCallbacks):
+            _callbackPerKey[i] = []
+        return _callbackPerKey
+    
+    def _callback_can_status(self, data):
+        """
+        Cast the json in the form:
+        {
+            "scan": [
+                {"canId": 20, "deviceType": 1, "status": 0, "deviceTypeStr": "laser", "statusStr": "idle"},
+                {"canId": 10, "deviceType": 0, "status": 0, "deviceTypeStr": "motor", "statusStr": "idle"}
+            ],
+            "qid": 2,
+            "count": 1
+        }
+        into the scan results array.
+        """
+        try:
+            if "scan" in data:
+                self.scanResults = data["scan"]
+                self.deviceCount = data.get("count", len(self.scanResults))
+                
+                # Call registered callback function with scan results
+                if callable(self._callbackPerKey[0]):
+                    self._callbackPerKey[0](self.scanResults)
+        except Exception as e:
+            print("Error in _callback_can_status: ", e)
+    
+    def register_callback(self, key, callbackfct):
+        """Register a callback function for a specific key."""
+        self._callbackPerKey[key] = callbackfct
+
+    def get_can_ids(self):
+        """Return CAN node IDs from the latest scan (e.g. for OTA flashing)."""
+        return [entry.get("canId") for entry in self.scanResults
+                if entry.get("canId") is not None]
+
+    def reboot_remote(self, qid=1, can_address=0, isBlocking=False, timeout=2):
+        """
+        Reboot a CAN device.
+
+        - ``can_address == 0`` reboots the master (this ESP32) itself.
+        - ``can_address in 1..127`` reboots a remote slave by SDO-writing 1
+          to OD index 0x2507 sub 0 on the target node. The slave's
+          CO_tmr_task observes the write and calls ESP.restart() ~200 ms
+          later.
+
+        :param qid: Query ID for the CAN command (unused by firmware, kept
+            for API compatibility)
+        :param can_address: 0 = master, 1..127 = remote slave nodeId
+        :param isBlocking: If True, wait for response
+        :param timeout: Timeout for the command in seconds
+        :return: Response from the device, e.g.
+            ``{"status":"ok","nodeId":11}`` or
+            ``{"status":"error","error":"SDO write failed","nodeId":11}``.
+        """
+        path = "/can_act"
+        payload = {
+            "task": path,
+            "restart": int(can_address)
+        }
+        nResponses = 1 if isBlocking else 0
+        # Send the payload to the parent, which handles the actual communication
+        return self._parent.post_json(
+            path,
+            payload,
+            getReturn=isBlocking,
+            timeout=timeout if isBlocking else 0,
+            nResponses=nResponses
+        )
+
+    def scan(self, qid=1, timeout=5, probe_range=False, id_from=1, id_to=127):
+        """
+        Scan the CAN bus for connected devices.
+
+        :param qid: Query ID for the CAN command (default: 1)
+        :param timeout: Timeout for the scan in seconds (default: 5)
+        :param probe_range: if True, additionally SDO-probe node-ids
+            ``id_from..id_to`` for their MAC so brand-new / unrouted nodes are
+            discovered (reported with deviceTypeStr "unrouted"). Absent ids
+            fast-fail on the firmware side. Use this for MAC-keyed provisioning.
+        :param id_from: first node-id to probe when ``probe_range`` is set
+        :param id_to: last node-id to probe when ``probe_range`` is set
+        :return: Response containing scan results with device information.
+                 Reachable nodes are SDO-probed for their firmware build
+                 timestamp (OD 0x2508), version (0x2500) and MAC (0x2509);
+                 the master reports its own identity under the "master" key.
+                 Example: {
+                     "master": {"canId": 1, "build": "Jun 22 2026 14:30:11",
+                                "fwVersion": "UC2-ESP v2.0", "mac": "AA:BB:CC:DD:EE:01"},
+                     "scan": [
+                         {"canId": 10, "deviceType": 0, "deviceTypeStr": "motor",
+                          "status": 0, "statusStr": "idle",
+                          "build": "Jun 22 2026 14:31:02", "fwVersion": "UC2-ESP v2.0",
+                          "mac": "AA:BB:CC:DD:EE:10"},
+                         {"canId": 20, "deviceType": 1, "deviceTypeStr": "laser",
+                          "status": 1, "statusStr": "unreachable"}
+                     ],
+                     "qid": 1,
+                     "count": 2
+                 }
+                 Note: "build"/"fwVersion"/"mac" are only present for nodes that
+                 answered the SDO probe (i.e. statusStr == "idle").
+        """
+        path = "/can_act" #         {"task":"/can_act", "scan": true}
+        payload = {
+            "task": path,
+            "scan": True,
+            "qid": qid
+        }
+        if probe_range:
+            payload["probeRange"] = True
+            payload["from"] = int(id_from)
+            payload["to"] = int(id_to)
+        return self._parent.post_json(
+            path,
+            payload,
+            getReturn=True,
+            timeout=timeout,
+            nResponses=1
+        )
+
+    def discover(self, qid=1, timeout=8, id_from=1, id_to=127):
+        """
+        Discover all nodes on the bus by SDO-probing a node-id range.
+
+        Convenience wrapper around ``scan(probe_range=True, ...)`` — finds nodes
+        that aren't in the master's routing table yet (e.g. freshly flashed
+        boards), reporting their MAC + build info so they can be provisioned by
+        MAC via :meth:`assign_node_id_by_mac`.
+
+        :return: same shape as :meth:`scan`; probed-but-unrouted nodes carry
+            deviceTypeStr "unrouted".
+        """
+        return self.scan(qid=qid, timeout=timeout,
+                         probe_range=True, id_from=id_from, id_to=id_to)
+
+    def get_available_devices(self, timeout=2):
+        """
+        Get list of available CAN devices.
+
+        :param timeout: Timeout for the command in seconds (default: 2)
+        :return: Response containing available CAN IDs and other bus information
+                 Example: {
+                     "input": {"task": "/can_get"},
+                     "address": 1,
+                     "addresspref": 1,
+                     "addressgetcan": 1,
+                     "nonworking": [0,0,0,...],
+                     "available": [20,0,0,...],
+                     "rx": 18,
+                     "tx": 17
+                 }
+        """
+        path = "/can_act"
+        payload = {
+            "task": path,
+            "scan": True
+        }
+        return self._parent.post_json(
+            path,
+            payload,
+            getReturn=True,
+            timeout=timeout,
+            nResponses=2
+        )
+
+    def get_device_build_info(self):
+        """
+        Return per-node firmware build info from the latest scan results.
+
+        :return: dict keyed by CAN id, e.g.
+                 {10: {"build": "Jun 22 2026 14:31:02",
+                       "fwVersion": "UC2-ESP v2.0",
+                       "mac": "AA:BB:CC:DD:EE:10"}}
+                 Only nodes that answered the SDO probe during the last scan()
+                 appear here. Call scan() first to refresh.
+        """
+        info = {}
+        for entry in self.scanResults:
+            cid = entry.get("canId")
+            if cid is None:
+                continue
+            fields = {k: entry[k] for k in ("build", "fwVersion", "mac")
+                      if k in entry}
+            if fields:
+                info[cid] = fields
+        return info
+
+    def set_remote_node_id(self, new_id, target=None, by_mac=None,
+                           expect_mac=None, qid=1, isBlocking=True, timeout=4):
+        """
+        Reassign a remote node's CAN id over the bus (SDO write to OD 0x250A).
+
+        Identify the node EITHER by its current id (``target``, optionally with
+        ``expect_mac`` for a safety check) OR purely by its MAC (``by_mac``), in
+        which case the firmware probes the bus to find which id currently has
+        that MAC — use this when you don't know the current id. ``new_id`` is
+        always the desired new id.
+
+        The slave persists the new id to NVS and performs a CANopen
+        communication reset, so it reappears at ``new_id`` after ~0.3 s.
+
+        :param new_id: desired CAN id (1..127)
+        :param target: current CAN id (1..127) of the node to reconfigure
+        :param by_mac: target MAC "AA:BB:CC:DD:EE:FF" — firmware finds the node
+            (use instead of ``target`` when the current id is unknown)
+        :param expect_mac: when using ``target``, verify the node's MAC matches
+            before committing (id only ever binds to the intended device)
+        :param qid: Query ID (kept for API symmetry)
+        :param isBlocking: wait for the firmware acknowledgement
+        :param timeout: command timeout in seconds
+        :return: firmware response, e.g. ``{"status":"ok","target":60,"newId":70}``
+            or ``{"status":"error","error":"MAC not found on bus","mac":"..."}``
+        """
+        if by_mac is None and target is None:
+            raise ValueError("set_remote_node_id requires either target or by_mac")
+        path = "/can_act"
+        payload = {
+            "task": path,
+            "setRemoteNodeId": int(new_id),
+            "qid": qid,
+        }
+        if by_mac is not None:
+            payload["byMac"] = str(by_mac)
+        else:
+            payload["target"] = int(target)
+            if expect_mac is not None:
+                payload["expectMac"] = str(expect_mac)
+        nResponses = 1 if isBlocking else 0
+        return self._parent.post_json(
+            path,
+            payload,
+            getReturn=isBlocking,
+            timeout=timeout if isBlocking else 0,
+            nResponses=nResponses,
+        )
+
+    def assign_node_id_by_mac(self, mac, new_id, qid=1, timeout=5):
+        """
+        Assign a CAN id to the node with the given MAC address.
+
+        The firmware probes the bus to locate whichever node currently
+        advertises ``mac`` and reassigns it to ``new_id`` in a single round-trip
+        (no need to know the node's current id). This is the canonical
+        MAC-keyed provisioning call.
+
+        :param mac: target MAC as "AA:BB:CC:DD:EE:FF" (case-insensitive)
+        :param new_id: desired CAN id (1..127)
+        :param qid: Query ID
+        :param timeout: request timeout in seconds
+        :return: firmware response, e.g. ``{"status":"ok","target":60,"newId":70,
+            "mac":"..."}`` or ``{"status":"error","error":"MAC not found on bus"}``
+        """
+        return self.set_remote_node_id(new_id, by_mac=mac, qid=qid, timeout=timeout)

{uc2_rest-0.2.0.35 → uc2_rest-0.2.0.37}/uc2rest/motor.py

@@ -91,12 +91,19 @@ class Motor(object):
             nSteppers = len(data["steppers"])
             stepSizes = np.array((self.stepSizeA, self.stepSizeX, self.stepSizeY, self.stepSizeZ))
             for iMotor in range(nSteppers):
-                stepperID = data["steppers"][iMotor]["stepperid"]
+                stepper = data["steppers"][iMotor]
+                # Intermediate status frames during a move carry only
+                # {stepperid, isDone} with no "position" key — skip them instead
+                # of raising KeyError 'position' (which previously aborted the
+                # whole callback and left currentPosition stale).
+                if "position" not in stepper:
+                    continue
+                stepperID = stepper["stepperid"]
                 # Hardware returns raw steps in firmware frame; convert to physical units
                 # in user frame: phys = hw_steps * stepSize * direction. The direction sign
                 # hides any wiring polarity flip from the caller.
                 self.currentPosition[stepperID] = (
-                    data["steppers"][iMotor]["position"]
+                    stepper["position"]
                     * stepSizes[stepperID]
                     * self.direction[stepperID]
                 )
@@ -333,6 +340,26 @@ class Motor(object):
             self.stepSizeA = stepSize
         self.backlash[axisIdx] = backlash
 
+    def set_backlash(self, axis, backlash):
+        """Set the per-axis backlash (in hardware steps) used as a reversal overshoot.
+
+        ``axis`` may be a name (\"X\"/\"Y\"/\"Z\"/\"A\") or a hardware index (0-3).
+        The value is stored in :attr:`backlash` and consumed by
+        :meth:`move_stepper`, which adds ``direction * backlash`` extra steps
+        whenever the axis changes direction, taking up the mechanical slack so the
+        stage still reaches the commanded target. Pass ``0`` to disable
+        compensation for that axis. Typically fed from a camera-based backlash
+        measurement (microns) after converting to steps with the axis step size.
+        """
+        idx = self.xyztTo1230(axis) if isinstance(axis, str) else int(axis)
+        self.backlash[idx] = backlash
+        return float(self.backlash[idx])
+
+    def get_backlash(self, axis):
+        """Return the per-axis backlash (in hardware steps)."""
+        idx = self.xyztTo1230(axis) if isinstance(axis, str) else int(axis)
+        return float(self.backlash[idx])
+
     def xyztTo1230(self, axis):
         axis = axis.upper()
         if axis == "X":
@@ -613,10 +640,15 @@ class Motor(object):
             if isAbsoluteArray[iMotor]:
                 # Compare current position (physical) with target (physical, already includes offset)
                 self.currentDirection[iMotor] = 1 if (self.currentPosition[iMotor]  > targetPositionPhysical[iMotor]) else -1
-                # Calculate distance to travel in HARDWARE STEPS:
-                # Current position (physical) -> convert to steps, then subtract target (already in steps)
-                currentPosition_steps = self.currentPosition[iMotor] / stepSizes[iMotor]
-                absoluteDistances_steps[iMotor] = abs(currentPosition_steps - steps[iMotor])
+                # Travel distance for the time estimate = |current - target| in
+                # PHYSICAL units, converted to hardware steps. Computing it in
+                # physical units keeps it direction-agnostic: the hardware `steps`
+                # target carries the per-axis direction sign, so subtracting it
+                # from an unsigned current-in-steps produced a *sum* (not a
+                # difference) on inverted axes, hugely inflating the estimate.
+                absoluteDistances_steps[iMotor] = abs(
+                    self.currentPosition[iMotor] - targetPositionPhysical[iMotor]
+                ) / stepSizes[iMotor]
             else:
                 self.currentDirection[iMotor] = np.sign(steps[iMotor])
                 # For relative motion, steps[iMotor] is already the distance in hardware steps
@@ -629,19 +661,20 @@ class Motor(object):
                 if not isAbsoluteArray[iMotor]:
                     absoluteDistances_steps[iMotor] = abs(steps[iMotor])
     
-        # Convert speed and acceleration from physical units to steps/second
+        # Speed and acceleration are already in firmware step units (the same raw
+        # values sent to the device), and absoluteDistances_steps is in hardware
+        # steps too, so the time estimate is unit-consistent WITHOUT any stepSize
+        # division — dividing here would desync it from the distance and break the
+        # estimate. Just take magnitudes.
         speed_steps = np.zeros(4)
         acceleration_steps = np.zeros(4)
         for iMotor in range(4):
             if speed[iMotor] != 0:
-                # Speed: µm/s -> steps/s => divide by stepSize (µm/step)
-                speed_steps[iMotor] = abs(speed[iMotor]) # TODO: This is actually given in steps/s / stepSizes[iMotor]
+                speed_steps[iMotor] = abs(speed[iMotor])
             if acceleration[iMotor] is not None and acceleration[iMotor] != 0:
-                # Acceleration: µm/s² -> steps/s² => divide by stepSize
-                acceleration_steps[iMotor] = abs(acceleration[iMotor]) # TODO: This is actually given in steps/s / stepSizes[iMotor]
+                acceleration_steps[iMotor] = abs(acceleration[iMotor])
             else:
-                # Default acceleration in steps/s²
-                acceleration_steps[iMotor] = 20000  # This should also be converted, but we use a safe default
+                acceleration_steps[iMotor] = 20000  # safe default (firmware steps/s^2)
         
         # Calculate travel time using HARDWARE STEPS and converted speed/acceleration
         # Find the axis that will take the longest (limits overall movement time)
@@ -696,8 +729,10 @@ class Motor(object):
                              "redu": int(is_reduced)}
                 if acceleration[iMotor] is not None:
                     motorProp["accel"] = int(acceleration[iMotor])
+                    motorProp["acceleration"] = int(acceleration[iMotor])
                 else:
                     motorProp["accel"] = self.DEFAULT_ACCELERATION
+                    motorProp["acceleration"] = self.DEFAULT_ACCELERATION
                 motorPropList.append(motorProp)
         if len(motorPropList)==0:
             return "{'return':-1}"
@@ -1243,6 +1278,44 @@ class Motor(object):
         r = self._parent.post_json(path, payload, timeout=timeout)
         return r
 
+    def get_tmc_parameters(self, axis=0, timeout=1):
+        ''' Read the TMC parameters for a specific axis back from the device.
+
+        Sends {"task":"/tmc_get", "axis":<n>} and parses the response. Returns a
+        dict with msteps/rms_current/sgthrs/semin/semax/blank_time/toff, or None
+        if the firmware does not implement TMC readback (older firmwares only
+        accept /tmc_act). Callers should fall back to their last-applied values
+        in that case.
+        '''
+        if type(axis) == str:
+            axis = self.xyztTo1230(axis)
+        path = "/tmc_get"
+        payload = {"task": path}
+        if axis is not None:
+            payload["axis"] = axis
+        try:
+            r = self._parent.post_json(path, payload, timeout=timeout)
+            if isinstance(r, list):
+                r = r[0] if r else {}
+            if not isinstance(r, dict):
+                return None
+            # firmware may nest the values under "tmc" or return them flat
+            tmc = r.get("tmc", r)
+            if not isinstance(tmc, dict):
+                return None
+            keys = ("msteps", "rms_current", "sgthrs", "semin", "semax", "blank_time", "toff")
+            if not any(k in tmc for k in keys):
+                # nothing TMC-shaped came back -> readback unsupported
+                return None
+            return {k: tmc[k] for k in keys if k in tmc}
+        except Exception as e:
+            self._parent.logger.debug(f"get_tmc_parameters failed: {e}")
+            return None
+
+    # camelCase alias used by the ImSwitch ESP32StageManager
+    def getTMCSettings(self, axis=0, timeout=1):
+        return self.get_tmc_parameters(axis=axis, timeout=timeout)
+
     def set_hard_limits(self, axis=1, enabled=True, polarity=0, timeout=1):
         '''
         Configure hard limits (emergency stop) for a motor axis.

{uc2_rest-0.2.0.35 → uc2_rest-0.2.0.37}/uc2rest/mserial.py

@@ -16,8 +16,8 @@ except ImportError:
 T_SERIAL_WARMUP = 2.5
 class Serial:
     def __init__(self, port, baudrate=115200, timeout=5,
-                 identity="UC2_Feather", parent=None, DEBUG=False, 
-                 skipFirmwareCheck=False):
+                 identity="UC2_Feather", parent=None, DEBUG=False,
+                 skipFirmwareCheck=False, device_id=None, requireMaster=False):
 
         self.serialdevice = None
         self.serialport = port
@@ -26,6 +26,15 @@ class Serial:
         self._parent = parent
         self.manufacturer = ""
         self.skipFirmwareCheck = skipFirmwareCheck
+        # Connect only to a specific board / only to the CANopen master.
+        # device_id pins a physical board by its USB serial number (or a
+        # substring of the port path / hwid). requireMaster makes auto-discovery
+        # skip any board whose firmware does NOT report a "*_master" pindef, so a
+        # motor/slave board (ESP32-S3, native USB) is never picked accidentally.
+        self.device_id = device_id
+        self.requireMaster = requireMaster
+        # identity of the board we actually connected to (filled by checkFirmware)
+        self.firmware_info = {}
         if self._parent is None:
             import logging
             self._logger = logging.getLogger(__name__)
@@ -160,6 +169,64 @@ class Serial:
 
         return ser
 
+    def _portMatchesDeviceId(self, port):
+        '''True if `port` matches the configured device_id, or if no device_id
+        is set (then everything matches). The device_id is compared as a
+        case-insensitive substring against the USB serial number, the port path
+        and the hwid, so the user can pin a board by whichever is stable on
+        their OS.'''
+        if not self.device_id:
+            return True
+        did = str(self.device_id).lower()
+        candidates = [getattr(port, "serial_number", None),
+                      getattr(port, "device", None),
+                      getattr(port, "hwid", None)]
+        return any(c and did in str(c).lower() for c in candidates)
+
+    def _probeDeviceIdentity(self, ser, timeout=2):
+        '''Send /state_get and parse the firmware identity block into
+        self.firmware_info: {name, version, date, author, pindef, isMaster}.
+        Used by requireMaster to reject motor/slave boards. Best-effort: returns
+        an empty dict (and leaves firmware_info empty) if nothing parses.'''
+        info = {}
+        try:
+            self._write(ser, {"task": "/state_get"})
+            ser.write(b'\n')
+            buffer = ""
+            reading_json = False
+            t0 = time.time()
+            while time.time() - t0 < timeout:
+                raw = self._read(ser)
+                try:
+                    line = raw.decode('utf-8').strip()
+                except Exception:
+                    continue
+                if line == "":
+                    continue
+                if line.find("++") >= 0:
+                    reading_json = True
+                    continue
+                if reading_json and line.find("--") >= 0:
+                    break
+                if reading_json:
+                    buffer += line
+            if buffer:
+                data = json.loads(buffer)
+                state = data.get("state", data) if isinstance(data, dict) else {}
+                pindef = state.get("pindef", "")
+                info = {
+                    "name": state.get("identifier_name", ""),
+                    "version": state.get("identifier_id", ""),
+                    "date": state.get("identifier_date", ""),
+                    "author": state.get("identifier_author", ""),
+                    "pindef": pindef,
+                    "isMaster": "master" in str(pindef).lower(),
+                }
+        except Exception as e:
+            self._logger.debug(f"_probeDeviceIdentity failed: {e}")
+        self.firmware_info = info
+        return info
+
     def findCorrectSerialDevice(self):
         '''
         This function tries to find the correct serial device from the list of available ports
@@ -183,6 +250,9 @@ class Serial:
             descriptions_to_check = ["CH340", "CP2102", "USB2.0-Serial", "USB-Serial"]
 
         for port in _available_ports:
+            # If a specific board was requested, ignore everything else.
+            if not self._portMatchesDeviceId(port):
+                continue
             if any(port.device.startswith(p) for p in ports_to_check) or \
             any(port.description.startswith(d) for d in descriptions_to_check):
                 if current_os.startswith("darwin") and port.device.startswith("/dev/cu.usbserial-"):
@@ -217,6 +287,22 @@ class Serial:
             #time.sleep(T_SERIAL_WARMUP)
             self._freeSerialBuffer(self.serialdevice, timeout=2, timeMinimum=1)
             if self.skipFirmwareCheck or self.checkFirmware(self.serialdevice):
+                # When only the master may be used, read the firmware identity and
+                # reject boards that are not a CANopen master (e.g. ESP32-S3 motor
+                # boards on native USB that also speak the UC2 protocol).
+                if self.requireMaster:
+                    self._probeDeviceIdentity(self.serialdevice)
+                    if not self.firmware_info.get("isMaster", False):
+                        self._logger.debug(
+                            f"Skipping non-master board on {getattr(port, 'device', '?')} "
+                            f"(pindef={self.firmware_info.get('pindef', '?')})"
+                        )
+                        try:
+                            self.serialdevice.close()
+                        except Exception:
+                            pass
+                        self.is_connected = False
+                        return False
                 self.is_connected = True
                 self.NumberRetryReconnect = 0
                 return True

{uc2_rest-0.2.0.35 → uc2_rest-0.2.0.37}/uc2rest/state.py

@@ -137,6 +137,41 @@ class State(object):
         r = self._parent.get_json(path, timeout=timeout)
         return r
 
+    def get_firmware_info(self, timeout=3):
+        '''
+        Return the firmware identity of the USB-connected ESP32 as a flat dict:
+        {"name", "version", "date", "author", "pindef", "isMaster"}.
+
+        Parsed from /state_get, e.g.
+          {"state":{"identifier_name":"UC2_Feather","identifier_id":"V2.0",
+                    "identifier_date":"Jun 17 2026 07:17:22","identifier_author":"BD",
+                    "pindef":"UC2_canopen_master", ...},"qid":0}
+        The build date and pindef are the fields that matter for telling boards
+        apart. Returns an empty dict if nothing could be parsed.
+        '''
+        r = self.get_state(timeout=timeout)
+        try:
+            if isinstance(r, list):
+                r = r[0] if r else {}
+            state = r.get("state", r) if isinstance(r, dict) else {}
+            pindef = state.get("pindef", "")
+            return {
+                "name": state.get("identifier_name", ""),
+                "version": state.get("identifier_id", ""),
+                "date": state.get("identifier_date", ""),
+                "author": state.get("identifier_author", ""),
+                "pindef": pindef,
+                "isMaster": "master" in str(pindef).lower(),
+            }
+        except Exception as e:
+            self._parent.logger.debug(f"get_firmware_info failed: {e}")
+            return {}
+
+    def is_master(self, timeout=1):
+        '''True if the connected board reports a CANopen-master pindef.'''
+        info = self.get_firmware_info(timeout=timeout)
+        return bool(info.get("isMaster", False))
+
     def delay(self, delay=1, getReturn=True):
         path = "/state_act"
         payload = {

uc2_rest-0.2.0.35/uc2rest/can.py

@@ -1,157 +0,0 @@
-class CAN(object):
-    def __init__(self, parent):
-        """
-        CANController handles sending commands to a remote CAN device via the parent post_json interface.
-
-        :param parent: Parent object with post_json(path, payload, getReturn, timeout, nResponses)
-        """
-        self._parent = parent
-        
-        # Store latest scan results
-        self.scanResults = []
-        self.deviceCount = 0
-        
-        # Register a callback function for the CAN status on the serial loop
-        if hasattr(self._parent, "serial"):
-            self._parent.serial.register_callback(self._callback_can_status, pattern="scan")
-        
-        # Announce a function that is called when we receive a CAN scan update through the callback
-        self._callbackPerKey = {}
-        self.nCallbacks = 10
-        self._callbackPerKey = self.init_callback_functions(nCallbacks=self.nCallbacks)
-        print(self._callbackPerKey)
-    
-    def init_callback_functions(self, nCallbacks=10):
-        """Initialize the callback functions."""
-        _callbackPerKey = {}
-        self.nCallbacks = nCallbacks
-        for i in range(nCallbacks):
-            _callbackPerKey[i] = []
-        return _callbackPerKey
-    
-    def _callback_can_status(self, data):
-        """
-        Cast the json in the form:
-        {
-            "scan": [
-                {"canId": 20, "deviceType": 1, "status": 0, "deviceTypeStr": "laser", "statusStr": "idle"},
-                {"canId": 10, "deviceType": 0, "status": 0, "deviceTypeStr": "motor", "statusStr": "idle"}
-            ],
-            "qid": 2,
-            "count": 1
-        }
-        into the scan results array.
-        """
-        try:
-            if "scan" in data:
-                self.scanResults = data["scan"]
-                self.deviceCount = data.get("count", len(self.scanResults))
-                
-                # Call registered callback function with scan results
-                if callable(self._callbackPerKey[0]):
-                    self._callbackPerKey[0](self.scanResults)
-        except Exception as e:
-            print("Error in _callback_can_status: ", e)
-    
-    def register_callback(self, key, callbackfct):
-        """Register a callback function for a specific key."""
-        self._callbackPerKey[key] = callbackfct
-
-    def get_can_ids(self):
-        """Return CAN node IDs from the latest scan (e.g. for OTA flashing)."""
-        return [entry.get("canId") for entry in self.scanResults
-                if entry.get("canId") is not None]
-
-    def reboot_remote(self, qid=1, can_address=0, isBlocking=False, timeout=2):
-        """
-        Reboot a CAN device.
-
-        - ``can_address == 0`` reboots the master (this ESP32) itself.
-        - ``can_address in 1..127`` reboots a remote slave by SDO-writing 1
-          to OD index 0x2507 sub 0 on the target node. The slave's
-          CO_tmr_task observes the write and calls ESP.restart() ~200 ms
-          later.
-
-        :param qid: Query ID for the CAN command (unused by firmware, kept
-            for API compatibility)
-        :param can_address: 0 = master, 1..127 = remote slave nodeId
-        :param isBlocking: If True, wait for response
-        :param timeout: Timeout for the command in seconds
-        :return: Response from the device, e.g.
-            ``{"status":"ok","nodeId":11}`` or
-            ``{"status":"error","error":"SDO write failed","nodeId":11}``.
-        """
-        path = "/can_act"
-        payload = {
-            "task": path,
-            "restart": int(can_address)
-        }
-        nResponses = 1 if isBlocking else 0
-        # Send the payload to the parent, which handles the actual communication
-        return self._parent.post_json(
-            path,
-            payload,
-            getReturn=isBlocking,
-            timeout=timeout if isBlocking else 0,
-            nResponses=nResponses
-        )
-
-    def scan(self, qid=1, timeout=5):
-        """
-        Scan the CAN bus for connected devices.
-
-        :param qid: Query ID for the CAN command (default: 1)
-        :param timeout: Timeout for the scan in seconds (default: 5)
-        :return: Response containing scan results with device information
-                 Example: {
-                     "scan": [
-                         {"canId": 10, "deviceType": 0, "deviceTypeStr": "motor", "status": 0, "statusStr": "idle"},
-                         {"canId": 20, "deviceType": 1, "deviceTypeStr": "laser", "status": 0, "statusStr": "idle"}
-                     ],
-                     "qid": 1,
-                     "count": 2
-                 }
-        """
-        path = "/can_act" #         {"task":"/can_act", "scan": true}
-        payload = {
-            "task": path,
-            "scan": True,
-            "qid": qid
-        }
-        return self._parent.post_json(
-            path,
-            payload,
-            getReturn=True,
-            timeout=timeout,
-            nResponses=1
-        )
-
-    def get_available_devices(self, timeout=2):
-        """
-        Get list of available CAN devices.
-
-        :param timeout: Timeout for the command in seconds (default: 2)
-        :return: Response containing available CAN IDs and other bus information
-                 Example: {
-                     "input": {"task": "/can_get"},
-                     "address": 1,
-                     "addresspref": 1,
-                     "addressgetcan": 1,
-                     "nonworking": [0,0,0,...],
-                     "available": [20,0,0,...],
-                     "rx": 18,
-                     "tx": 17
-                 }
-        """
-        path = "/can_act"
-        payload = {
-            "task": path,
-            "scan": True
-        }
-        return self._parent.post_json(
-            path,
-            payload,
-            getReturn=True,
-            timeout=timeout,
-            nResponses=2
-        )