moteus-gui 0.3.89__tar.gz → 0.3.91__tar.gz

{moteus-gui-0.3.89 → moteus-gui-0.3.91}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: moteus-gui
-Version: 0.3.89
+Version: 0.3.91
 Summary: moteus brushless controller graphical user interfaces
 Home-page: https://github.com/mjbots/moteus
 Author: mjbots Robotic Systems

{moteus-gui-0.3.89 → moteus-gui-0.3.91}/moteus_gui/tview.py

@@ -88,7 +88,6 @@ RIGHT_LEGEND_LOC = 2
 
 DEFAULT_RATE = 100
 MAX_HISTORY_SIZE = 100
-MAX_SEND = 61
 POLL_TIMEOUT_S = 0.1
 STARTUP_TIMEOUT_S = 0.5
 
@@ -107,6 +106,32 @@ def _has_nonascii(data):
     return any([ord(x) > 127 for x in data])
 
 
+def calculate_optimal_uuid_prefix(full_uuid, other_uuids):
+    """Pure function to find the shortest unique UUID prefix.
+
+    Args:
+        full_uuid: The full 16-byte UUID to find a prefix for
+        other_uuids: List of other UUIDs to check conflicts against
+
+    Returns:
+        The shortest unique prefix (4, 8, 12, or 16 bytes)
+    """
+    for prefix_len in [4, 8, 12, 16]:
+        proposed_prefix = full_uuid[:prefix_len]
+
+        # Check if this prefix conflicts with any other UUID
+        has_conflict = any(
+            other_uuid[:prefix_len] == proposed_prefix
+            for other_uuid in other_uuids
+        )
+
+        if not has_conflict:
+            return proposed_prefix
+
+    # Should never happen, but return full UUID as fallback
+    return full_uuid
+
+
 # TODO jpieper: Factor these out of tplot.py
 def _get_data(value, name):
     fields = name.split('.')
@@ -502,6 +527,9 @@ class DeviceStream:
         self.emit_count = 0
         self.poll_count = 0
 
+    def update_controller(self, controller):
+        self.controller = controller
+
     def ignore_all(self):
         self._read_data = b''
 
@@ -518,8 +546,9 @@ class DeviceStream:
 
         self.emit_count += 1
 
+        max_send = self.controller.max_diagnostic_write
         to_write, self._write_data = (
-            self._write_data[0:MAX_SEND], self._write_data[MAX_SEND:])
+            self._write_data[0:max_send], self._write_data[max_send:])
         await self.transport.write(self.controller.make_diagnostic_write(to_write))
 
     async def process_message(self, message):
@@ -532,7 +561,7 @@ class DeviceStream:
             return False
         if data[1] != 1:
             return False
-        if data[2] > MAX_SEND:
+        if data[2] > 61:
             return False
         datalen = data[2]
         if datalen > (len(data) - 3):
@@ -598,15 +627,28 @@ class Device:
     STATE_SCHEMA = 3
     STATE_DATA = 4
 
-    def __init__(self, number, transport, console, prefix,
-                 config_tree_item, data_tree_item, can_prefix=None):
+    def __init__(self, address, source_can_id, transport, console, prefix,
+                 config_tree_item, data_tree_item,
+                 can_prefix, main_window, can_id):
         self.error_count = 0
         self.poll_count = 0
+        self.poll_lock = asyncio.Lock()  # Lock for poll-address change synchronization
+
+        self.address = address
+        self.source_can_id = source_can_id
+        self._can_prefix = can_prefix
 
-        self.number = number
-        self.controller = moteus.Controller(number, can_prefix=can_prefix)
+        # We keep around an estimate of the current CAN ID to enable
+        # user friendly commands.
+        self.can_id = can_id
+
+        self.controller = moteus.Controller(
+            address,
+            source_can_id=source_can_id,
+            can_prefix=can_prefix)
         self._transport = transport
         self._stream = DeviceStream(transport, self.controller)
+        self._main_window = main_window
 
         self._console = console
         self._prefix = prefix
@@ -634,11 +676,132 @@ class Device:
 
         self._stream.ignore_all()
 
+        # Make sure we have a UUID based address available in case we
+        # need it later.
+        if isinstance(self.address, int) or self.address.can_id is not None:
+            self.uuid_address = await self._get_uuid_address()
+        else:
+            self.uuid_address = self.address
+
+        # Save the full UUID for later.
+        self.full_uuid = (self.uuid_address.uuid
+                          if self.uuid_address
+                          else None)
+
+        # Are we able to be addressed by UUID?
+        has_uuid_capability = self.uuid_address is not None
+
+        # Register UUID query completion with main window
+        await self._main_window.register_uuid_query_complete(
+            self, has_uuid_capability)
+
         await self.update_config()
         await self.update_telemetry()
 
         await self.run()
 
+    async def _get_uuid_address(self):
+        try:
+            to_query = {
+                moteus.Register.UUID1 : moteus.INT32,
+                moteus.Register.UUID2 : moteus.INT32,
+                moteus.Register.UUID3 : moteus.INT32,
+                moteus.Register.UUID4 : moteus.INT32,
+                moteus.Register.UUID_MASK_CAPABLE : moteus.INT32,
+            }
+            result = await self.controller.custom_query(to_query)
+
+
+            if result.values.get(moteus.Register.UUID_MASK_CAPABLE, None) is None:
+                return None
+
+            # We'll just use the full 16 byte UUID in this case for
+            # now.  Eventually maybe we could find an appropriate
+            # shorter prefix.
+            uuid_bytes = struct.pack(
+                '<iiii',
+                *[result.values[reg] for reg in [
+                    moteus.Register.UUID1,
+                    moteus.Register.UUID2,
+                    moteus.Register.UUID3,
+                    moteus.Register.UUID4]])
+
+            return moteus.DeviceAddress(
+                uuid=uuid_bytes,
+                transport_device=self.address.transport_device
+                if isinstance(self.address, moteus.DeviceAddress)
+                else None)
+        except Exception as e:
+            print(f"UUID query failed: {e}")
+            return None
+
+    def _update_tree_items(self, tree_key):
+        """Update tree items with the new tree key."""
+        self._config_tree_item.setText(0, tree_key)
+        self._data_tree_item.setText(0, tree_key)
+        self._prefix = f'{tree_key}>'
+
+    async def _handle_id_change(self):
+        if self.uuid_address is None:
+            # We don't have a UUID to work with, so this controller
+            # may become not addressable.
+            print(f"WARNING: controller {self.address} may now be unreachable")
+            return
+
+        if self.uuid_address == self.address:
+            # We are already using UUID based addressing, so nothing
+            # to do.
+            return
+
+        # Wait for all devices to complete UUID queries if not done
+        if not self._main_window.uuid_query_event.is_set():
+            print("Waiting for all devices to complete UUID queries...")
+            await self._main_window.uuid_query_event.wait()
+
+        # Check if all devices on this transport support UUID
+        transport_device = self._main_window._get_transport_device(self.address)
+
+        if not self._main_window.can_use_uuid_on_transport(transport_device):
+            print(f"WARNING: Not all devices on transport {transport_device} support UUID addressing")
+            print(f"Device {self.address} will remain on CAN ID addressing and may become unreachable")
+            return
+
+        # Acquire lock to ensure no poll is in progress when changing address
+        async with self.poll_lock:
+            await asyncio.sleep(0.1)
+
+            # Calculate optimal UUID prefix.
+            optimal_uuid = self.uuid_address  # Default to full UUID
+
+            other_uuids = self._main_window.get_other_device_uuids(self, transport_device)
+
+            optimal_prefix = calculate_optimal_uuid_prefix(self.full_uuid, other_uuids)
+
+            # Create new address with optimal prefix
+            optimal_uuid = moteus.DeviceAddress(
+                uuid=optimal_prefix,
+                transport_device=self.address.transport_device
+                if isinstance(self.address, moteus.DeviceAddress)
+                else None)
+
+            print(f"Switching device {self.address} to UUID addressing: {optimal_prefix.hex()}")
+
+            # Now perform the state change (while holding lock)
+            self.address = optimal_uuid
+
+            self.controller = moteus.Controller(
+                self.address,
+                source_can_id=self.source_can_id,
+                can_prefix=self._can_prefix)
+
+            self._stream.update_controller(self.controller)
+
+        # Update tree items (can be done outside lock)
+        if self._main_window:
+            new_tree_key = self._main_window._calculate_tree_key(
+                self.address, self._transport)
+            self._update_tree_items(new_tree_key)
+
     async def update_config(self):
         self._updating_config = True
 
@@ -686,9 +849,15 @@ class Device:
 
             _add_schema_item(item, archive, terminal_flags=flags)
             self._config_tree_items[element] = item
-            struct = archive.read(reader.Stream(io.BytesIO(data)))
-            _set_tree_widget_data(item, struct, archive, terminal_flags=flags)
+            data_struct = archive.read(reader.Stream(io.BytesIO(data)))
+            _set_tree_widget_data(item, data_struct, archive, terminal_flags=flags)
+
+            # Try to grab our current can_id.
+            if (element == 'id' and
+                getattr(data_struct, 'id', None) is not None
+                and self.can_id is None):
 
+                self.can_id = data_struct.id
 
     async def update_telemetry(self):
         self._data_tree_item.takeChildren()
@@ -814,6 +983,32 @@ class Device:
     def write(self, data):
         self._stream.write(data)
 
+        line = data.decode('latin1')
+
+        # For some commands, we need to take special actions.
+        if line.startswith('conf set id.id '):
+            # Extract the new CAN ID from the command
+            try:
+                new_id_str = line.split('conf set id.id ')[1].strip()
+                new_can_id = int(new_id_str)
+                # Update our current CAN ID for future matching
+                self.can_id = new_can_id
+            except (IndexError, ValueError):
+                # Invalid command format, ignore
+                pass
+
+            asyncio.create_task(self._handle_id_change())
+        elif line.startswith('conf default') or line.startswith('conf load'):
+            # Eventually it would be nice to reload the configuration
+            # here so the UI stays consistent.  For now, we'll satisfy
+            # ourselves with trying to switch to UUID based operation
+            # so that we don't lose communication.
+
+            # Reloading configuration is complicated, as we need to
+            # dispense with the OK that the above commands would
+            # create, but the current layering doesn't make that easy.
+            asyncio.create_task(self._handle_id_change())
+
     def config_item_changed(self, name, value, schema):
         if self._updating_config:
             return
@@ -937,6 +1132,13 @@ class TviewMainWindow():
 
         self.user_task = None
 
+        # UUID coordination infrastructure
+        self.uuid_query_event = asyncio.Event()
+        self.uuid_query_count = 0
+        self.expected_device_count = 0
+        self.device_uuid_support = {}
+        self.uuid_query_lock = asyncio.Lock()
+
         current_script_dir = os.path.dirname(os.path.abspath(__file__))
         uifilename = os.path.join(current_script_dir, "tview_main_window.ui")
 
@@ -1005,25 +1207,147 @@ class TviewMainWindow():
         self.transport = self._make_transport()
         asyncio.create_task(self._run_transport())
 
+        asyncio.create_task(self._populate_devices())
+
+    def _calculate_tree_key(self, device_address, transport):
+        """Calculate the tree key for a device based on its address."""
+        needs_suffix = (transport.count() > 1 and
+                        not isinstance(device_address, int) and
+                        hasattr(device_address, 'transport_device') and
+                        device_address.transport_device)
+
+        suffix_str = f'/{device_address.transport_device}' if needs_suffix else ''
+
+        tree_key = (
+            str(device_address) if isinstance(device_address, int)
+            else f'{device_address.can_id}{suffix_str}' if hasattr(device_address, 'can_id') and device_address.can_id
+            else f'{device_address.uuid.hex()}{suffix_str}')
+
+        return tree_key
+
+    def _init_uuid_coordination(self, device_count):
+        """Initialize UUID query coordination for a set of devices"""
+        self.expected_device_count = device_count
+
+    async def register_uuid_query_complete(self, device, has_uuid):
+        """Called by each device when UUID query completes"""
+        async with self.uuid_query_lock:
+            # Track device UUID capability
+            transport_device = self._get_transport_device(device.address)
+            if transport_device not in self.device_uuid_support:
+                self.device_uuid_support[transport_device] = []
+            self.device_uuid_support[transport_device].append((device, has_uuid))
+
+            # Update counter
+            self.uuid_query_count += 1
+
+            # Signal if all complete
+            if self.uuid_query_count >= self.expected_device_count:
+                self.uuid_query_event.set()
+
+    def _get_transport_device(self, address):
+        """Extract transport device from an address"""
+        if isinstance(address, int):
+            return None  # Default transport
+        elif hasattr(address, 'transport_device'):
+            return address.transport_device
+        return None
+
+    def can_use_uuid_on_transport(self, transport_device):
+        """Check if all devices on a transport support UUID"""
+        if transport_device not in self.device_uuid_support:
+            return False
+
+        devices_on_transport = self.device_uuid_support[transport_device]
+        return all(has_uuid for _, has_uuid in devices_on_transport)
+
+    def get_other_device_uuids(self, device, transport_device):
+        """Get the UUIDs of other devices on the same transport.
+
+        Args:
+            device: The device to exclude from the list
+            transport_device: The transport to query
+
+        Returns:
+            List of full UUIDs from other devices on this transport
+        """
+        other_uuids = []
+        devices_on_transport = self.device_uuid_support.get(transport_device, [])
+
+        for other_device, has_uuid in devices_on_transport:
+            if other_device != device and has_uuid:
+                # Check if device has stored full UUID
+                if hasattr(other_device, 'full_uuid'):
+                    other_uuids.append(other_device.full_uuid)
+
+        return other_uuids
+
+    def is_can_id_unique(self, can_id):
+        """Check if a CAN ID is unique across all devices in the system."""
+        matching_devices = [d for d in self.devices
+                            if d.can_id == can_id]
+        return len(matching_devices) == 1
+
+    async def _populate_devices(self):
         self.devices = []
+
+        targets = moteus.moteus_tool.expand_targets(self.options.devices)
+        if not targets:
+            discovered = await self.transport.discover(
+                can_prefix=self.options.can_prefix, source=0x7e)
+            not_addressable = [x for x in discovered if x.address is None]
+
+            if len(not_addressable) > 0:
+                print("No target specified, and one or more devices are not addressable", file=sys.stderr)
+                print(file=sys.stderr)
+                for x in not_addressable:
+                    print(f' * {x}', file=sys.stderr)
+                sys.exit(1)
+
+            targets = [x.address for x in discovered]
+
         self.ui.configTreeWidget.clear()
         self.ui.telemetryTreeWidget.clear()
 
-        for device_id in moteus.moteus_tool.expand_targets(
-                self.options.devices or ['1']):
+        # Initialize UUID coordination for all devices
+        self._init_uuid_coordination(len(targets))
+
+        device_count = 0
+        source_can_id = 0x7d
+
+        for device_address in targets:
+            # Extract current CAN ID from the target specification
+            current_can_id = None
+            if isinstance(device_address, int):
+                # Direct integer CAN ID specification
+                current_can_id = device_address
+            elif getattr(device_address, 'can_id', None) is not None:
+                # DeviceAddress with CAN ID
+                current_can_id = device_address.can_id
+
+            # UUID-only addresses will have current_can_id = None
+
+            tree_key = self._calculate_tree_key(device_address, self.transport)
+
             config_item = QtWidgets.QTreeWidgetItem()
-            config_item.setText(0, str(device_id))
+
+            config_item.setText(0, tree_key)
             self.ui.configTreeWidget.addTopLevelItem(config_item)
 
             data_item = QtWidgets.QTreeWidgetItem()
-            data_item.setText(0, str(device_id))
+            data_item.setText(0, tree_key)
             self.ui.telemetryTreeWidget.addTopLevelItem(data_item)
 
-            device = Device(device_id, self.transport,
-                            self.console, '{}>'.format(device_id),
+            device = Device(device_address, source_can_id,
+                            self.transport,
+                            self.console, '{}>'.format(tree_key),
                             config_item,
                             data_item,
-                            self.options.can_prefix)
+                            self.options.can_prefix,
+                            self,
+                            current_can_id)
+
+            source_can_id -= 1
 
             config_item.setData(0, QtCore.Qt.UserRole, device)
             asyncio.create_task(device.start())
@@ -1039,10 +1363,15 @@ class TviewMainWindow():
             message = await self.transport.read()
             if message is None:
                 continue
-            source_id = (message.arbitration_id >> 8) & 0xff
+            source_id = (message.arbitration_id >> 8) & 0x7f
+            dest_id = (message.arbitration_id & 0x7f)
             any_data_read = False
             for device in self.devices:
-                if device.number == source_id:
+                if ((device.address.transport_device is None or
+                     device.address.transport_device == message.channel) and
+                    device.source_can_id == dest_id and
+                    (device.address.can_id is None or
+                     device.address.can_id == source_id)):
                     any_data_read = await device.process_message(message)
                     break
             if predicate(message):
@@ -1072,24 +1401,29 @@ class TviewMainWindow():
                 device.poll_count -= 1
                 continue
 
-            await device.poll()
+            # Acquire lock for the entire poll-response cycle
+            async with device.poll_lock:
+                await device.poll()
 
-            try:
-                this_data_read = await asyncio.wait_for(
-                    self._dispatch_until(
-                        lambda x: (x.arbitration_id >> 8) & 0xff == device.number),
-                    timeout = POLL_TIMEOUT_S)
-
-                device.error_count = 0
-                device.poll_count = 0
-
-                if this_data_read:
-                    any_data_read = True
-            except asyncio.TimeoutError:
-                # Mark this device as error-full, which will then
-                # result in backoff in polling.
-                device.error_count = min(1000, device.error_count + 1)
-                device.poll_count = device.error_count
+                try:
+                    this_data_read = await asyncio.wait_for(
+                        self._dispatch_until(
+                            lambda x: (
+                                (x.arbitration_id & 0x7f) == device.source_can_id and
+                                (device.address.can_id is None or
+                                 (x.arbitration_id >> 8) & 0x7f == device.address.can_id))),
+                        timeout = POLL_TIMEOUT_S)
+
+                    device.error_count = 0
+                    device.poll_count = 0
+
+                    if this_data_read:
+                        any_data_read = True
+                except asyncio.TimeoutError:
+                    # Mark this device as error-full, which will then
+                    # result in backoff in polling.
+                    device.error_count = min(1000, device.error_count + 1)
+                    device.poll_count = device.error_count
 
         return any_data_read
 
@@ -1118,12 +1452,41 @@ class TviewMainWindow():
 
             # Otherwise ignore problems so that tview keeps running.
 
+    def _match(self, device, s):
+        # Try to parse as integer for CAN ID matching
+        try:
+            target_id = int(s)
+            if target_id < 1 or target_id > 126:
+                # These are not valid IDs.
+                target_id = None
+        except:
+            target_id = None
+
+        # Check current address CAN ID.
+        if device.address.can_id is not None and target_id is not None:
+            if target_id == device.address.can_id:
+                return True
+
+        # Check UUID addressing.
+        if device.address.uuid is not None:
+            if s.upper() == device.address.uuid.hex().upper():
+                return True
+
+        # Check tracked CAN ID if it's unique in the system
+        if (target_id is not None and
+            getattr(device, 'can_id', None) is not None and
+            target_id == device.can_id and
+            self.is_can_id_unique(target_id)):
+            return True
+
+        return False
+
     async def _wait_user_query(self, maybe_id):
-        device_nums = [self.devices[0].number]
-        if maybe_id:
-            device_nums = [int(maybe_id)]
+        devices = [self.devices[0]]
 
-        devices = [x for x in self.devices if x.number in device_nums]
+        if maybe_id:
+            devices = [x for x in self.devices if
+                       self._match(x, maybe_id)]
 
         record = 'servo_stats'
 
@@ -1145,10 +1508,10 @@ class TviewMainWindow():
 
     async def _run_user_command(self, command):
         delay_re = re.search(r"^:(\d+)$", command)
-        device_re = re.search(r"^(A|\d+)>\s*(.*)$", command)
-        traj_re = re.search(r"^(\?(\d+)?)$", command)
+        device_re = re.search(r"^(A|\d+|[a-fA-F0-9]{8,32})>\s*(.*)$", command)
+        traj_re = re.search(r"^(\?(\d+|[a-fA-F0-9]{8,32})?)$", command)
 
-        device_nums = [self.devices[0].number]
+        devices = [self.devices[0]]
 
         if traj_re:
             await self._wait_user_query(traj_re.group(2))
@@ -1159,11 +1522,12 @@ class TviewMainWindow():
         elif device_re:
             command = device_re.group(2)
             if device_re.group(1) == 'A':
-                device_nums = [x.number for x in self.devices]
+                devices = self.devices
             else:
-                device_nums = [int(device_re.group(1))]
+                devices = [x for x in self.devices
+                           if self._match(x, device_re.group(1))]
 
-        for device in [x for x in self.devices if x.number in device_nums]:
+        for device in devices:
             device.write((command + '\n').encode('latin1'))
 
     def _handle_tree_expanded(self, item):
@@ -1289,8 +1653,6 @@ def main():
                         action='append', type=str, default=[])
     parser.add_argument('--can-prefix', type=int, default=0)
 
-    parser.add_argument('--max-receive-bytes', default=48, type=int)
-
     moteus.make_transport_args(parser)
 
     args = parser.parse_args()
@@ -1303,7 +1665,8 @@ def main():
     loop = asyncqt.QEventLoop(app)
     asyncio.set_event_loop(loop)
 
-    # To work around https://bugreports.qt.io/browse/PYSIDE-88
+    # Currently there are many things that can barf on exit, let's
+    # just ignore all of them because, hey, we're about to exit!
     app.aboutToQuit.connect(lambda: os._exit(0))
 
     tv = TviewMainWindow(args)

{moteus-gui-0.3.89 → moteus-gui-0.3.91}/moteus_gui/version.py

@@ -12,4 +12,4 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-VERSION="0.3.89"
+VERSION="0.3.91"

{moteus-gui-0.3.89 → moteus-gui-0.3.91}/moteus_gui.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: moteus-gui
-Version: 0.3.89
+Version: 0.3.91
 Summary: moteus brushless controller graphical user interfaces
 Home-page: https://github.com/mjbots/moteus
 Author: mjbots Robotic Systems

{moteus-gui-0.3.89 → moteus-gui-0.3.91}/moteus_gui.egg-info/requires.txt

@@ -1,7 +1,7 @@
 PySide6>=6.8
 asyncqt>=0.8
 matplotlib>=3.9
-moteus>=0.3.74
+moteus>=0.3.91
 qtconsole>=5.6
 qtpy>=2.0.1
 scipy>=1.14

{moteus-gui-0.3.89 → moteus-gui-0.3.91}/setup.py

@@ -24,7 +24,7 @@ long_description = (here / 'README.md').read_text(encoding='utf-8')
 
 setuptools.setup(
     name = 'moteus-gui',
-    version = "0.3.89",
+    version = "0.3.91",
     description = 'moteus brushless controller graphical user interfaces',
     long_description = long_description,
     long_description_content_type = 'text/markdown',
@@ -51,7 +51,7 @@ setuptools.setup(
     python_requires = '>=3.7, <4',
     install_requires = [
         'asyncqt>=0.8',
-        'moteus>=0.3.74',
+        'moteus>=0.3.91',
         'matplotlib>=3.9',
         # For some reason, matplotlib can barf without this, but
         # doesn't actually list it as a dependency on Windows.