Improvements

* Add __repr__ to the object classes
* Rename PDO Map to PdoMap
* Rename PDO Maps to PdoMaps
* Fix iterator in SdoArray
* Add alen() to SdoArray and SdoRecord
* Add __eq__ to SdoAbordedError

Author: sveinse

canopen/objectdictionary/__init__.py

@@ -109,8 +109,8 @@ def __getitem__(
         item = self.names.get(index) or self.indices.get(index)
         if item is None:
             if isinstance(index, str) and '.' in index:
-                parts = index.split('.')
-                return self[parts[0]][".".join(parts[1:])]
+                idx, sub = index.split('.', maxsplit=1)
+                return self[idx][sub]
             name = "0x%X" % index if isinstance(index, int) else index
             raise KeyError("%s was not found in Object Dictionary" % name)
         return item
@@ -182,6 +182,9 @@ def __init__(self, name: str, index: int):
         self.subindices = {}
         self.names = {}
 
+    def __repr__(self) -> str:
+        return f"<{type(self).__qualname__} {self.name!r} at 0x{self.index:04x}>"
+
     def __getitem__(self, subindex: Union[int, str]) -> "ODVariable":
         item = self.names.get(subindex) or self.subindices.get(subindex)
         if item is None:
@@ -238,6 +241,9 @@ def __init__(self, name: str, index: int):
         self.subindices = {}
         self.names = {}
 
+    def __repr__(self) -> str:
+        return f"<{type(self).__qualname__} {self.name!r} at 0x{self.index:04x}>"
+
     def __getitem__(self, subindex: Union[int, str]) -> "ODVariable":
         var = self.names.get(subindex) or self.subindices.get(subindex)
         if var is not None:
@@ -333,6 +339,15 @@ def __init__(self, name: str, index: int, subindex: int = 0):
         #: Can this variable be mapped to a PDO
         self.pdo_mappable = False
 
+    def __repr__(self) -> str:
+        suffix = f":{self.subindex:02x}" if isinstance(self.parent, (ODRecord, ODArray)) else ""
+        return f"<{type(self).__qualname__} {self.qualname!r} at 0x{self.index:04x}{suffix}>"
+
+    @property
+    def qualname(self) -> str:
+        if isinstance(self.parent, (ODRecord, ODArray)):
+            return f"{self.parent.name}.{self.name}"
+        return self.name
 
     def __eq__(self, other: "ODVariable") -> bool:
         return (self.index == other.index and

canopen/pdo/__init__.py

@@ -1,7 +1,7 @@
 import logging
 
 from canopen import node
-from canopen.pdo.base import PdoBase, Maps
+from canopen.pdo.base import PdoBase, PdoMaps
 
 # Compatibility
 from canopen.pdo.base import Variable
@@ -38,7 +38,7 @@ class RPDO(PdoBase):
 
     def __init__(self, node):
         super(RPDO, self).__init__(node)
-        self.map = Maps(0x1400, 0x1600, self, 0x200)
+        self.map = PdoMaps(0x1400, 0x1600, self, 0x200)
         logger.debug('RPDO Map as {0}'.format(len(self.map)))
 
     def stop(self):
@@ -63,7 +63,7 @@ class TPDO(PdoBase):
 
     def __init__(self, node):
         super(TPDO, self).__init__(node)
-        self.map = Maps(0x1800, 0x1A00, self, 0x180)
+        self.map = PdoMaps(0x1800, 0x1A00, self, 0x180)
         logger.debug('TPDO Map as {0}'.format(len(self.map)))
 
     def stop(self):

canopen/pdo/base.py

@@ -33,7 +33,7 @@ class PdoBase(Mapping):
 
     def __init__(self, node):
         self.network: Optional[Network] = None
-        self.map = None  # instance of Maps
+        self.map = None  # instance of PdoMaps
         self.node = node
 
     def __iter__(self):
@@ -140,7 +140,7 @@ def stop(self):
             pdo_map.stop()
 
 
-class Maps(Mapping):
+class PdoMaps(Mapping[int, "PdoMap"]):
     """A collection of transmit or receive maps."""
 
     def __init__(self, com_offset, map_offset, pdo_node: PdoBase, cob_base=None):
@@ -150,10 +150,10 @@ def __init__(self, com_offset, map_offset, pdo_node: PdoBase, cob_base=None):
         :param pdo_node:
         :param cob_base:
         """
-        self.maps: Dict[int, "Map"] = {}
+        self.maps: Dict[int, "PdoMap"] = {}
         for map_no in range(512):
             if com_offset + map_no in pdo_node.node.object_dictionary:
-                new_map = Map(
+                new_map = PdoMap(
                     pdo_node,
                     pdo_node.node.sdo[com_offset + map_no],
                     pdo_node.node.sdo[map_offset + map_no])
@@ -162,7 +162,7 @@ def __init__(self, com_offset, map_offset, pdo_node: PdoBase, cob_base=None):
                     new_map.predefined_cob_id = cob_base + map_no * 0x100 + pdo_node.node.id
                 self.maps[map_no + 1] = new_map
 
-    def __getitem__(self, key: int) -> "Map":
+    def __getitem__(self, key: int) -> "PdoMap":
         return self.maps[key]
 
     def __iter__(self) -> Iterable[int]:
@@ -172,7 +172,7 @@ def __len__(self) -> int:
         return len(self.maps)
 
 
-class Map:
+class PdoMap:
     """One message which can have up to 8 bytes of variables mapped."""
 
     def __init__(self, pdo_node: PdoBase, com_record, map_array):
@@ -211,6 +211,9 @@ def __init__(self, pdo_node: PdoBase, com_record, map_array):
         self.is_received: bool = False
         self._task = None
 
+    def __repr__(self) -> str:
+        return f"<{type(self).__qualname__} {self.name!r} at COB-ID 0x{self.cob_id}>"
+
     def __getitem_by_index(self, value):
         valid_values = []
         for var in self.map:
@@ -340,12 +343,12 @@ async def aon_message(self, can_id, data, timestamp):
                     if res is not None and asyncio.iscoroutine(res):
                         await res
 
-    def add_callback(self, callback: Callable[["Map"], None]) -> None:
+    def add_callback(self, callback: Callable[["PdoMap"], None]) -> None:
         """Add a callback which will be called on receive.
 
         :param callback:
             The function to call which must take one argument of a
-            :class:`~canopen.pdo.Map`.
+            :class:`~canopen.pdo.PdoMap`.
         """
         self.callbacks.append(callback)
 
@@ -734,3 +737,5 @@ async def aset_data(self, data: bytes):
 
 # For compatibility
 Variable = PdoVariable
+Maps = PdoMaps
+Map = PdoMap

canopen/profiles/p402.py

@@ -214,8 +214,8 @@ class BaseNode402(RemoteNode):
     def __init__(self, node_id, object_dictionary):
         super(BaseNode402, self).__init__(node_id, object_dictionary)
         self.tpdo_values = {}  # { index: value from last received TPDO }
-        self.tpdo_pointers = {}  # { index: pdo.Map instance }
-        self.rpdo_pointers = {}  # { index: pdo.Map instance }
+        self.tpdo_pointers = {}  # { index: pdo.PdoMap instance }
+        self.rpdo_pointers = {}  # { index: pdo.PdoMap instance }
 
     def setup_402_state_machine(self, read_pdos=True):
         """Configure the state machine by searching for a TPDO that has the StatusWord mapped.
@@ -474,7 +474,7 @@ def on_TPDOs_update_callback(self, mapobject):
         """Cache updated values from a TPDO received from this node.
 
         :param mapobject: The received PDO message.
-        :type mapobject: canopen.pdo.Map
+        :type mapobject: canopen.pdo.PdoMap
         """
         # NOTE: Callback. Called from another thread unless async
         for obj in mapobject:

canopen/sdo/base.py

@@ -114,6 +114,9 @@ def __init__(self, sdo_node: SdoBase, od: ObjectDictionary):
         self.sdo_node = sdo_node
         self.od = od
 
+    def __repr__(self) -> str:
+        return f"<{type(self).__qualname__} {self.od.name!r} at 0x{self.od.index:04x}>"
+
     def __getitem__(self, subindex: Union[int, str]) -> "SdoVariable":
         return SdoVariable(self.sdo_node, self.od[subindex])
 
@@ -130,6 +133,9 @@ def __aiter__(self):
     def __len__(self) -> int:
         return len(self.od)
 
+    async def alen(self) -> int:
+        return len(self.od)
+
     def __contains__(self, subindex: Union[int, str]) -> bool:
         return subindex in self.od
 
@@ -140,14 +146,17 @@ def __init__(self, sdo_node: SdoBase, od: ObjectDictionary):
         self.sdo_node = sdo_node
         self.od = od
 
+    def __repr__(self) -> str:
+        return f"<{type(self).__qualname__} {self.od.name!r} at 0x{self.od.index:04x}>"
+
     def __getitem__(self, subindex: Union[int, str]) -> "SdoVariable":
         return SdoVariable(self.sdo_node, self.od[subindex])
 
     def __iter__(self) -> Iterable[int]:
-        return iter(range(1, len(self) + 1))
+        return iter(self.od)
 
     async def aiter(self):
-        for i in range(1, await self[0].aget_raw() + 1):
+        for i in iter(self.od):
             yield i
 
     def __aiter__(self):
@@ -157,6 +166,9 @@ def __len__(self) -> int:
         # NOTE: Blocking - OK. Protected in SdoClient
         return self[0].get_raw()
 
+    async def alen(self) -> int:
+        return await self[0].aget_raw()
+
     def __contains__(self, subindex: int) -> bool:
         return 0 <= subindex <= len(self)
 

canopen/sdo/exceptions.py

@@ -54,6 +54,10 @@ def __str__(self):
             text = text + ", " + self.CODES[self.code]
         return text
 
+    def __eq__(self, other):
+        """Compare two exception objects based on SDO abort code."""
+        return self.code == other.code
+
 
 class SdoCommunicationError(SdoError):
     """No or unexpected response from slave."""

canopen/variable.py

@@ -25,6 +25,12 @@ def __init__(self, od: objectdictionary.ODVariable):
         #: Holds a local, overridable copy of the Object Subindex
         self.subindex = od.subindex
 
+    def __repr__(self) -> str:
+        suffix = f":{self.subindex:02x}" if isinstance(self.od.parent,
+            (objectdictionary.ODRecord, objectdictionary.ODArray)
+        ) else ""
+        return f"<{type(self).__qualname__} {self.name!r} at 0x{self.index:04x}{suffix}>"
+
     def get_data(self) -> bytes:
         """Byte representation of the object as :class:`bytes`."""
         raise NotImplementedError("Variable is not readable")

doc/pdo.rst

@@ -89,7 +89,7 @@ API
 
    .. describe:: pdo[no]
 
-      Return the :class:`canopen.pdo.Map` for the specified map number.
+      Return the :class:`canopen.pdo.PdoMap` for the specified map number.
       First map starts at 1.
 
    .. describe:: iter(pdo)
@@ -101,7 +101,7 @@ API
       Return the number of supported maps.
 
 
-.. autoclass:: canopen.pdo.Map
+.. autoclass:: canopen.pdo.PdoMap
    :members:
 
    .. describe:: map[name]