Implement multi rate sending for socketcan native. Extend cyclic example.

Closes #58

Author: hardbyte

can/interfaces/socketcan_native.py

@@ -126,7 +126,15 @@ def create_bcm_socket(channel):
     return s
 
 
-class CyclicSendTask(CyclicSendTaskABC):
+class SocketCanBCMBase(object):
+    """Mixin to add a BCM socket"""
+
+    def __init__(self, channel, *args, **kwargs):
+        self.bcm_socket = create_bcm_socket(channel)
+        super(SocketCanBCMBase, self).__init__(channel, *args, **kwargs)
+
+
+class CyclicSendTask(SocketCanBCMBase, CyclicSendTaskABC):
 
     def __init__(self, channel, message, period):
         """
@@ -135,8 +143,7 @@ def __init__(self, channel, message, period):
         :param message: The message to be sent periodically.
         :param period: The rate in seconds at which to send the message.
         """
-        super(CyclicSendTask,self).__init__(channel, message, period)
-        self.bcm_socket = create_bcm_socket(channel)
+        super(CyclicSendTask, self).__init__(channel, message, period)
         self._tx_setup(message)
         self.message = message
 
@@ -169,6 +176,29 @@ def start(self):
         self._tx_setup(self.message)
 
 
+class MultiRateCyclicSendTask(CyclicSendTask):
+
+    """Exposes more of the full power of the TX_SETUP opcode.
+
+    Transmits a message `count` times at `initial_period` then
+    continues to transmit message at `subsequent_period`.
+    """
+
+    def __init__(self, channel, message, count, initial_period, subsequent_period):
+        super(MultiRateCyclicSendTask, self).__init__(channel, message, subsequent_period)
+
+        # Create a low level packed frame to pass to the kernel
+        frame = build_can_frame(self.can_id, message.data)
+        header = build_bcm_transmit_header(
+            self.can_id,
+            count,
+            initial_period,
+            subsequent_period)
+
+        log.info("Sending BCM TX_SETUP command")
+        self.bcm_socket.send(header + frame)
+
+
 def createSocket(can_protocol=None):
     """Creates a CAN socket. The socket can be BCM or RAW. The socket will
     be returned unbound to any interface.

examples/cyclic.py

@@ -20,29 +20,40 @@
 
 
 def test_simple_periodic_send():
-    print("Trying to send a message...")
-    msg = can.Message(arbitration_id=0x0cf02200, data=[0, 1, 3, 1, 4, 1])
-    task = can.send_periodic('vcan0', msg, 0.020)
+    print("Starting to send a message every 200ms. Initial data is zeros")
+    msg = can.Message(arbitration_id=0x0cf02200, data=[0, 0, 0, 0, 0, 0])
+    task = can.send_periodic('vcan0', msg, 0.20)
     time.sleep(2)
+    task.stop()
+    print("stopped cyclic send")
 
-    print("Trying to change data")
-    msg.data[0] = 99
+
+def test_periodic_send_with_modifying_data():
+    print("Starting to send a message every 200ms. Initial data is ones")
+    msg = can.Message(arbitration_id=0x0cf02200, data=[1, 1, 1, 1])
+    task = can.send_periodic('vcan0', msg, 0.20)
+    time.sleep(2)
+    print("Changing data of running task to begin with 99")
+    msg.data[0] = 0x99
     task.modify_data(msg)
     time.sleep(2)
 
     task.stop()
     print("stopped cyclic send")
-
+    print("Changing data of stopped task to single ff byte")
+    msg.data = bytearray([0xff])
+    task.modify_data(msg)
     time.sleep(1)
-    task.start()
     print("starting again")
+    task.start()
     time.sleep(1)
+    task.stop()
     print("done")
 
 
 def test_dual_rate_periodic_send():
     """Send a message 10 times at 1ms intervals, then continue to send every 500ms"""
-    msg = can.Message(arbitration_id=0x0c112200, data=[0, 1, 2, 3, 4, 5])
+    msg = can.Message(arbitration_id=0x123, data=[0, 1, 2, 3, 4, 5])
     print("Creating cyclic task to send message 10 times at 1ms, then every 500ms")
     task = can.interface.MultiRateCyclicSendTask('vcan0', msg, 10, 0.001, 0.50)
     time.sleep(2)
@@ -60,6 +71,7 @@ def test_dual_rate_periodic_send():
     task.start()
     print("starting again")
     time.sleep(2)
+    task.stop()
     print("done")
 
 
@@ -68,12 +80,11 @@ def test_dual_rate_periodic_send():
     for interface in {'socketcan_ctypes', 'socketcan_native'}:
         print("Carrying out cyclic tests with {} interface".format(interface))
         can.rc['interface'] = interface
+
         test_simple_periodic_send()
 
+        test_periodic_send_with_modifying_data()
 
-    for interface in {'socketcan_ctypes', }:
-        print("Carrying out cyclic tests with {} interface".format(interface))
+        print("Carrying out multirate cyclic test for {} interface".format(interface))
         can.rc['interface'] = interface
         test_dual_rate_periodic_send()
-
-    print("socketcan_native doesn't yet support MultiRate Cyclic Tasks")