Migrate to vars access methods and deprecate attr

Author: sveinse

canopen/nmt.py

@@ -230,7 +230,7 @@ def send_command(self, code: int) -> None:
         # The heartbeat service should start on the transition
         # between INITIALIZING and PRE-OPERATIONAL state
         if old_state == 0 and self._state == 127:
-            heartbeat_time_ms = self._local_node.sdo[0x1017].raw
+            heartbeat_time_ms = self._local_node.sdo[0x1017].get_raw()
             self.start_heartbeat(heartbeat_time_ms)
         else:
             self.update_heartbeat()

canopen/node/remote.py

@@ -135,9 +135,9 @@ def __load_configuration_helper(self, index, subindex, name, value):
                     subindex=subindex,
                     name=name,
                     value=value)))
-                self.sdo[index][subindex].raw = value
+                self.sdo[index][subindex].set_raw(value)
             else:
-                self.sdo[index].raw = value
+                self.sdo[index].set_raw(value)
                 logger.info(str('SDO [{index:#06x}]: {name}: {value:#06x}'.format(
                     index=index,
                     name=name,

canopen/pdo/base.py

@@ -343,41 +343,41 @@ def add_callback(self, callback: Callable[["Map"], None]) -> None:
 
     def read(self) -> None:
         """Read PDO configuration for this map using SDO."""
-        cob_id = self.com_record[1].raw
+        cob_id = self.com_record[1].get_raw()
         self.cob_id = cob_id & 0x1FFFFFFF
         logger.info("COB-ID is 0x%X", self.cob_id)
         self.enabled = cob_id & PDO_NOT_VALID == 0
         logger.info("PDO is %s", "enabled" if self.enabled else "disabled")
         self.rtr_allowed = cob_id & RTR_NOT_ALLOWED == 0
         logger.info("RTR is %s", "allowed" if self.rtr_allowed else "not allowed")
-        self.trans_type = self.com_record[2].raw
+        self.trans_type = self.com_record[2].get_raw()
         logger.info("Transmission type is %d", self.trans_type)
         if self.trans_type >= 254:
             try:
-                self.inhibit_time = self.com_record[3].raw
+                self.inhibit_time = self.com_record[3].get_raw()
             except (KeyError, SdoAbortedError) as e:
                 logger.info("Could not read inhibit time (%s)", e)
             else:
                 logger.info("Inhibit time is set to %d ms", self.inhibit_time)
 
             try:
-                self.event_timer = self.com_record[5].raw
+                self.event_timer = self.com_record[5].get_raw()
             except (KeyError, SdoAbortedError) as e:
                 logger.info("Could not read event timer (%s)", e)
             else:
                 logger.info("Event timer is set to %d ms", self.event_timer)
 
             try:
-                self.sync_start_value = self.com_record[6].raw
+                self.sync_start_value = self.com_record[6].get_raw()
             except (KeyError, SdoAbortedError) as e:
                 logger.info("Could not read SYNC start value (%s)", e)
             else:
                 logger.info("SYNC start value is set to %d ms", self.sync_start_value)
 
         self.clear()
-        nof_entries = self.map_array[0].raw
+        nof_entries = self.map_array[0].get_raw()
         for subindex in range(1, nof_entries + 1):
-            value = self.map_array[subindex].raw
+            value = self.map_array[subindex].get_raw()
             index = value >> 16
             subindex = (value >> 8) & 0xFF
             size = value & 0xFF
@@ -443,44 +443,44 @@ def save(self) -> None:
         """Save PDO configuration for this map using SDO."""
         logger.info("Setting COB-ID 0x%X and temporarily disabling PDO",
                     self.cob_id)
-        self.com_record[1].raw = self.cob_id | PDO_NOT_VALID | (RTR_NOT_ALLOWED if not self.rtr_allowed else 0x0)
+        self.com_record[1].set_raw(self.cob_id | PDO_NOT_VALID | (RTR_NOT_ALLOWED if not self.rtr_allowed else 0x0))
         if self.trans_type is not None:
             logger.info("Setting transmission type to %d", self.trans_type)
-            self.com_record[2].raw = self.trans_type
+            self.com_record[2].set_raw(self.trans_type)
         if self.inhibit_time is not None:
             logger.info("Setting inhibit time to %d us", (self.inhibit_time * 100))
-            self.com_record[3].raw = self.inhibit_time
+            self.com_record[3].set_raw(self.inhibit_time)
         if self.event_timer is not None:
             logger.info("Setting event timer to %d ms", self.event_timer)
-            self.com_record[5].raw = self.event_timer
+            self.com_record[5].set_raw(self.event_timer)
         if self.sync_start_value is not None:
             logger.info("Setting SYNC start value to %d", self.sync_start_value)
-            self.com_record[6].raw = self.sync_start_value
+            self.com_record[6].set_raw(self.sync_start_value)
 
         if self.map is not None:
             try:
-                self.map_array[0].raw = 0
+                self.map_array[0].set_raw(0)
             except SdoAbortedError:
                 # WORKAROUND for broken implementations: If the array has a
                 # fixed number of entries (count not writable), generate dummy
                 # mappings for an invalid object 0x0000:00 to overwrite any
                 # excess entries with all-zeros.
-                self._fill_map(self.map_array[0].raw)
+                self._fill_map(self.map_array[0].get_raw())
             subindex = 1
             for var in self.map:
                 logger.info("Writing %s (0x%X:%d, %d bits) to PDO map",
                             var.name, var.index, var.subindex, var.length)
                 if hasattr(self.pdo_node.node, "curtis_hack") and self.pdo_node.node.curtis_hack:  # Curtis HACK: mixed up field order
-                    self.map_array[subindex].raw = (var.index |
-                                                    var.subindex << 16 |
-                                                    var.length << 24)
+                    self.map_array[subindex].set_raw(var.index |
+                                                     var.subindex << 16 |
+                                                     var.length << 24)
                 else:
-                    self.map_array[subindex].raw = (var.index << 16 |
-                                                    var.subindex << 8 |
-                                                    var.length)
+                    self.map_array[subindex].set_raw(var.index << 16 |
+                                                     var.subindex << 8 |
+                                                     var.length)
                 subindex += 1
             try:
-                self.map_array[0].raw = len(self.map)
+                self.map_array[0].set_raw(len(self.map))
             except SdoAbortedError as e:
                 # WORKAROUND for broken implementations: If the array
                 # number-of-entries parameter is not writable, we have already
@@ -492,7 +492,7 @@ def save(self) -> None:
             self._update_data_size()
 
         if self.enabled:
-            self.com_record[1].raw = self.cob_id | (RTR_NOT_ALLOWED if not self.rtr_allowed else 0x0)
+            self.com_record[1].set_raw(self.cob_id | (RTR_NOT_ALLOWED if not self.rtr_allowed else 0x0))
             self.subscribe()
 
     def subscribe(self) -> None:

canopen/profiles/p402.py

@@ -402,7 +402,7 @@ def op_mode(self):
             code = self.tpdo_values[0x6061]
         except KeyError:
             logger.warning('The object 0x6061 is not a configured TPDO, fallback to SDO')
-            code = self.sdo[0x6061].raw
+            code = self.sdo[0x6061].get_raw()
         return OperationMode.CODE2NAME[code]
 
     @op_mode.setter
@@ -414,12 +414,12 @@ def op_mode(self, mode):
                     'Operation mode {m} not suppported on node {n}.'.format(n=self.id, m=mode))
             # Update operation mode in RPDO if possible, fall back to SDO
             if 0x6060 in self.rpdo_pointers:
-                self.rpdo_pointers[0x6060].raw = OperationMode.NAME2CODE[mode]
+                self.rpdo_pointers[0x6060].set_raw(OperationMode.NAME2CODE[mode])
                 pdo = self.rpdo_pointers[0x6060].pdo_parent
                 if not pdo.is_periodic:
                     pdo.transmit()
             else:
-                self.sdo[0x6060].raw = OperationMode.NAME2CODE[mode]
+                self.sdo[0x6060].set_raw(OperationMode.NAME2CODE[mode])
             timeout = time.monotonic() + self.TIMEOUT_SWITCH_OP_MODE
             while self.op_mode != mode:
                 if time.monotonic() > timeout:
@@ -436,7 +436,7 @@ def _clear_target_values(self):
         # [target velocity, target position, target torque]
         for target_index in [0x60FF, 0x607A, 0x6071]:
             if target_index in self.sdo.keys():
-                self.sdo[target_index].raw = 0
+                self.sdo[target_index].set_raw(0)
 
     def is_op_mode_supported(self, mode):
         """Check if the operation mode is supported by the node.
@@ -450,7 +450,7 @@ def is_op_mode_supported(self, mode):
         """
         if not hasattr(self, '_op_mode_support'):
             # Cache value only on first lookup, this object should never change.
-            self._op_mode_support = self.sdo[0x6502].raw
+            self._op_mode_support = self.sdo[0x6502].get_raw()
             logger.info('Caching node {n} supported operation modes 0x{m:04X}'.format(
                 n=self.id, m=self._op_mode_support))
         bits = OperationMode.SUPPORTED[mode]
@@ -463,7 +463,7 @@ def on_TPDOs_update_callback(self, mapobject):
         :type mapobject: canopen.pdo.Map
         """
         for obj in mapobject:
-            self.tpdo_values[obj.index] = obj.raw
+            self.tpdo_values[obj.index] = obj.get_raw()
 
     @property
     def statusword(self):
@@ -477,7 +477,7 @@ def statusword(self):
             return self.tpdo_values[0x6041]
         except KeyError:
             logger.warning('The object 0x6041 is not a configured TPDO, fallback to SDO')
-            return self.sdo[0x6041].raw
+            return self.sdo[0x6041].get_raw()
 
     def check_statusword(self, timeout=None):
         """Report an up-to-date reading of the statusword (0x6041) from the device.
@@ -512,12 +512,12 @@ def controlword(self):
     def controlword(self, value):
         logger.warning("Accessing BaseNode402.controlword setter is deprecated")
         if 0x6040 in self.rpdo_pointers:
-            self.rpdo_pointers[0x6040].raw = value
+            self.rpdo_pointers[0x6040].set_raw(value)
             pdo = self.rpdo_pointers[0x6040].pdo_parent
             if not pdo.is_periodic:
                 pdo.transmit()
         else:
-            self.sdo[0x6040].raw = value
+            self.sdo[0x6040].set_raw(value)
 
     @property
     def state(self):

canopen/sdo/base.py

@@ -127,7 +127,7 @@ def __iter__(self) -> Iterable[int]:
         return iter(range(1, len(self) + 1))
 
     def __len__(self) -> int:
-        return self[0].raw
+        return self[0].get_raw()
 
     def __contains__(self, subindex: int) -> bool:
         return 0 <= subindex <= len(self)

canopen/variable.py

@@ -87,6 +87,7 @@ def get_raw(self) -> Union[int, bool, float, str, bytes]:
         return self._get_raw(self.get_data())
 
     async def aget_raw(self) -> Union[int, bool, float, str, bytes]:
+        """Raw representation of the object, async variant"""
         return self._get_raw(await self.aget_data())
 
     def _get_raw(self, data: bytes) -> Union[int, bool, float, str, bytes]:
@@ -101,7 +102,7 @@ def _get_raw(self, data: bytes) -> Union[int, bool, float, str, bytes]:
 
     @raw.setter
     def raw(self, value: Union[int, bool, float, str, bytes]):
-        logger.warning("Accessing Variable.data setter is deprecated")
+        logger.warning("Accessing Variable.raw setter is deprecated")
         self.set_raw(value)
 
     def set_raw(self, value: Union[int, bool, float, str, bytes]):
@@ -174,6 +175,9 @@ def desc(self, desc: str):
     def set_desc(self, desc: str):
         self.set_raw(self.od.encode_desc(desc))
 
+    async def aset_desc(self, desc: str):
+        await self.aset_raw(self.od.encode_desc(desc))
+
     @property
     def bits(self) -> "Bits":
         """Access bits using integers, slices, or bit descriptions."""
@@ -223,11 +227,11 @@ def write(
              - 'desc'
         """
         if fmt == "raw":
-            self.raw = value
+            self.set_raw(value)
         elif fmt == "phys":
-            self.phys = value
+            self.set_phys(value)
         elif fmt == "desc":
-            self.desc = value
+            self.set_desc(value)
 
     async def awrite(
         self, value: Union[int, bool, float, str, bytes], fmt: str = "raw"
@@ -281,7 +285,7 @@ def __len__(self):
         return len(self.variable.od.bit_definitions)
 
     def read(self):
-        self.raw = self.variable.raw
+        self.raw = self.variable.get_raw()
 
     def write(self):
-        self.variable.raw = self.raw
+        self.variable.set_raw(self.raw)