Add PDO support.

Author: Christian Sandberg

README.rst

@@ -1,8 +1,23 @@
 A Python implementation of the CANopen standard. The application will act as a master.
 
 
+Hardware support
+================
+
+This library support multiple hardware and drivers through the
+`python-can <https://pypi.python.org/pypi/python-can/>`_ package.
+At the time of writing this includes:
+
+* Kvaser
+* Peak CAN
+* USB2CAN
+* Anything supported by socketcan on Linux
+
+It is also possible to integrate this library with a custom backend.
+
+
 Examples
---------
+========
 
 Here are some quick examples:
 
@@ -45,7 +60,7 @@ Here are some quick examples:
 
 
 TODO
-----
+====
 
 There are a lot of things that still needs implementing and fixing.
 Pull requests are most welcome!

canopen/common.py

@@ -0,0 +1,100 @@
+import logging
+
+
+logger = logging.getLogger(__name__)
+
+
+class Variable(object):
+
+    def __init__(self, od):
+        self.od = od
+        self.bits = Bits(self)
+
+    def get_data(self):
+        raise NotImplementedError()
+
+    def set_data(self, data):
+        raise NotImplementedError()
+
+    @property
+    def data(self):
+        if self.od.access_type == "wo":
+            logger.warning("Variable is write only")
+        return self.get_data()
+
+    @data.setter
+    def data(self, data):
+        if "w" not in self.od.access_type:
+            logger.warning("Variable is read only")
+        self.set_data(data)
+
+    @property
+    def raw(self):
+        value = self.od.decode_raw(self.data)
+        text = "Value of %s (0x%X:%d) is %s" % (
+            self.od.name, self.od.index,
+            self.od.subindex, value)
+        if value in self.od.value_descriptions:
+            text += " (%s)" % self.od.value_descriptions[value]
+        logger.debug(text)
+        return value
+
+    @raw.setter
+    def raw(self, value):
+        logger.debug("Writing %s (0x%X:%d) = %s",
+                     self.od.name, self.od.index,
+                     self.od.subindex, value)
+        self.data = self.od.encode_raw(value)
+
+    @property
+    def phys(self):
+        value = self.od.decode_phys(self.data)
+        logger.debug("Value of %s (0x%X:%d) is %s %s",
+                     self.od.name, self.od.index,
+                     self.od.subindex, value, self.od.unit)
+        return value
+
+    @phys.setter
+    def phys(self, value):
+        logger.debug("Writing %s (0x%X:%d) = %s",
+                     self.od.name, self.od.index,
+                     self.od.subindex, value)
+        self.data = self.od.encode_phys(value)
+
+    @property
+    def desc(self):
+        value = self.od.decode_desc(self.data)
+        logger.debug("Description of %s (0x%X:%d) is %s",
+                     self.od.name, self.od.index,
+                     self.od.subindex, value)
+        return value
+
+    @desc.setter
+    def desc(self, desc):
+        logger.debug("Setting description of %s (0x%X:%d) to %s",
+                     self.od.name, self.od.index,
+                     self.od.subindex, desc)
+        self.data = self.od.encode_desc(desc)
+
+
+class Bits(object):
+
+    def __init__(self, variable):
+        self.variable = variable
+
+    def _get_bits(self, key):
+        if isinstance(key, slice):
+            bits = range(key.start, key.stop, key.step)
+        elif isinstance(key, int):
+            bits = [key]
+        else:
+            bits = key
+        return bits
+
+    def __getitem__(self, key):
+        return self.variable.od.decode_bits(self.variable.data,
+            self._get_bits(key))
+
+    def __setitem__(self, key, value):
+        self.variable.data = self.variable.od.encode_bits(
+            self.variable.data, self._get_bits(key), value)

canopen/network.py

@@ -1,6 +1,9 @@
 import collections
 import logging
+import threading
+
 import can
+
 from .node import Node
 
 
@@ -14,6 +17,7 @@ def __init__(self):
         self.listeners = [MessageDispatcher(self)]
         self.notifier = None
         self.nodes = []
+        self.send_lock = threading.Lock()
         # NMT to all nodes
         #self.nmt = NmtNode(0)
 
@@ -30,7 +34,8 @@ def connect(self, *args, **kwargs):
         self.notifier = can.Notifier(self.bus, self.listeners, 1)
 
     def disconnect(self):
-        self.notifier.running.clear()
+        self.notifier.stop()
+        self.bus.shutdown()
 
     def add_listener(self, listener):
         self.listeners.append(listener)
@@ -47,14 +52,15 @@ def send_message(self, can_id, data):
         msg = can.Message(extended_id=False,
                           arbitration_id=can_id,
                           data=data)
-        self.bus.send(msg)
+        with self.send_lock:
+            self.bus.send(msg)
 
     def put_message(self, can_id, data, timestamp):
         node_id = can_id & 0x7F
         for node in self.nodes:
             if node.id == node_id or node_id == 0:
                 node.on_message(can_id, data, timestamp)
-            for callback in node.callbacks:
+            for callback in node.message_callbacks:
                 callback(can_id, data, timestamp)
 
     def __getitem__(self, node_id):

canopen/nmt.py

@@ -39,12 +39,12 @@
 
 class NmtNode(object):
 
-    def __init__(self):
+    def __init__(self, parent):
         self._state = 0
         self._state_received = False
         self.timestamp = 0
         self.state_change = threading.Condition()
-        self.parent = None
+        self.parent = parent
 
     def on_heartbeat(self, can_id, data, timestamp):
         self.timestamp = timestamp

canopen/node.py

@@ -1,6 +1,7 @@
 from .sdo import SdoNode
 from .nmt import NmtNode
 from .emcy import EmcyNode
+from .pdo import PdoNode
 from . import objectdictionary
 
 
@@ -16,24 +17,25 @@ def __init__(self, node_id=1, object_dictionary=None):
         self.network = None
         self.object_dictionary = objectdictionary.ObjectDictionary()
         self.service_callbacks = {}
-        self.callbacks = []
+        self.message_callbacks = []
 
         if object_dictionary:
             self.set_object_dictionary(object_dictionary)
 
-        self.sdo = SdoNode(node_id)
-        self.sdo.parent = self
+        self.sdo = SdoNode(self, node_id)
         self.register_service(SDO_RESPONSE, self.sdo.on_response)
 
-        self.nmt = NmtNode()
-        self.nmt.parent = self
+        self.pdo = PdoNode(self)
+        self.add_callback(self.pdo.on_message)
+
+        self.nmt = NmtNode(self)
         self.register_service(HEARTBEAT, self.nmt.on_heartbeat)
 
         self.emcy = EmcyNode()
         self.register_service(EMCY, self.emcy.on_emcy)
 
     def add_callback(self, callback):
-        self.callbacks.append(callback)
+        self.message_callbacks.append(callback)
 
     def set_node_id(self, node_id):
         self.id = node_id

canopen/objectdictionary/__init__.py

@@ -19,6 +19,9 @@
 INTEGER64 = 21
 UNSIGNED64 = 27
 
+SIGNED_TYPES = (INTEGER8, INTEGER16, INTEGER32, INTEGER64)
+UNSIGNED_TYPES = (BOOLEAN, UNSIGNED8, UNSIGNED16, UNSIGNED32, UNSIGNED64)
+
 
 def import_any(filename):
     if filename.endswith(".eds"):
@@ -110,7 +113,7 @@ def __getitem__(self, subindex):
         return var
 
     def __len__(self):
-        return 255
+        return 256
 
 
 class Variable(object):
@@ -150,9 +153,9 @@ def __eq__(self, other):
 
     def __len__(self):
         if self.data_type in self.STRUCT_TYPES:
-            return self.STRUCT_TYPES[self.data_type].size
+            return self.STRUCT_TYPES[self.data_type].size * 8
         else:
-            return 1
+            return 8
 
     def add_value_description(self, value, descr):
         self.value_descriptions[value] = descr