Add timeout argument to send()

Add timeout argument to send() and clarify timeout argument in docs.
Give Kvaser a chance to transmit all messages before shutdown()

Author: christiansandberg

can/bus.py

@@ -50,11 +50,15 @@ def recv(self, timeout=None):
         raise NotImplementedError("Trying to read from a write only bus?")
 
     @abc.abstractmethod
-    def send(self, msg):
+    def send(self, msg, timeout=None):
         """Transmit a message to CAN bus.
         Override this method to enable the transmit path.
 
         :param msg: A :class:`can.Message` object.
+        :param float timeout:
+            If > 0, wait up to this many seconds for message to be ACK:ed.
+            If timeout is exceeded, an exception will be raised.
+            Might not be supported by all interfaces.
 
         :raise: :class:`can.CanError`
             if the message could not be written.

can/interfaces/ixxat/canlib.py

@@ -153,6 +153,8 @@ def __check_status(result, function, arguments):
     _canlib.map_symbol("canChannelWaitRxEvent", ctypes.c_long, (HANDLE, ctypes.c_uint32), __check_status)
     #HRESULT canChannelPostMessage (HANDLE hChannel, PCANMSG pCanMsg );
     _canlib.map_symbol("canChannelPostMessage", ctypes.c_long, (HANDLE, structures.PCANMSG), __check_status)
+    #HRESULT canChannelSendMessage (HANDLE hChannel, UINT32 dwMsTimeout, PCANMSG pCanMsg );
+    _canlib.map_symbol("canChannelSendMessage", ctypes.c_long, (HANDLE, ctypes.c_uint32, structures.PCANMSG), __check_status)
 
     #EXTERN_C HRESULT VCIAPI canControlOpen( IN  HANDLE  hDevice, IN  UINT32  dwCanNo, OUT PHANDLE phCanCtl );
     _canlib.map_symbol("canControlOpen", ctypes.c_long, (HANDLE, ctypes.c_uint32, PHANDLE), __check_status)
@@ -433,7 +435,7 @@ def recv(self, timeout=None):
         log.debug('Recv()ed message %s', rx_msg)
         return rx_msg
 
-    def send(self, msg):
+    def send(self, msg, timeout=None):
         log.debug("Sending message: %s", msg)
 
         # This system is not designed to be very efficient
@@ -447,9 +449,11 @@ def send(self, msg):
             adapter = (ctypes.c_uint8 * msg.dlc).from_buffer(msg.data)
             ctypes.memmove(self._message.abData, adapter, msg.dlc)
 
-        # This does not block but may raise if TX fifo is full
-        # if you prefer a blocking call use canChannelSendMessage
-        _canlib.canChannelPostMessage (self._channel_handle, self._message)
+        if timeout:
+            _canlib.canChannelSendMessage(
+                self._channel_handle, int(timeout * 1000), self._message)
+        else:
+            _canlib.canChannelPostMessage(self._channel_handle, self._message)
 
     def shutdown(self):
         _canlib.canChannelClose(self._channel_handle)

can/interfaces/kvaser/canlib.py

@@ -195,18 +195,21 @@ def __check_bus_handle_validity(handle, function, arguments):
                                     restype=canstat.c_canStatus,
                                     errcheck=__check_status_read)
 
-canWriteWait = __get_canlib_function("canWriteWait",
-                                     argtypes=[
-                                         c_canHandle,
-                                         ctypes.c_long,
-                                         ctypes.c_void_p,
-                                         ctypes.c_uint,
-                                         ctypes.c_uint,
-                                         ctypes.c_ulong],
+canWrite = __get_canlib_function("canWrite",
+                                 argtypes=[
+                                     c_canHandle,
+                                     ctypes.c_long,
+                                     ctypes.c_void_p,
+                                     ctypes.c_uint,
+                                     ctypes.c_uint],
+                                 restype=canstat.c_canStatus,
+                                 errcheck=__check_status)
+
+canWriteSync = __get_canlib_function("canWriteSync",
+                                     argtypes=[c_canHandle, ctypes.c_ulong],
                                      restype=canstat.c_canStatus,
                                      errcheck=__check_status)
 
-
 canIoCtl = __get_canlib_function("canIoCtl",
                                  argtypes=[c_canHandle, ctypes.c_uint,
                                            ctypes.c_void_p, ctypes.c_uint],
@@ -515,7 +518,7 @@ def recv(self, timeout=None):
             #log.debug('read complete -> status not okay')
             return None
 
-    def send(self, msg):
+    def send(self, msg, timeout=None):
         #log.debug("Writing a message: {}".format(msg))
         flags = canstat.canMSG_EXT if msg.id_type else canstat.canMSG_STD
         if msg.is_remote_frame:
@@ -524,12 +527,13 @@ def send(self, msg):
             flags |= canstat.canMSG_ERROR_FRAME
         ArrayConstructor = ctypes.c_byte * msg.dlc
         buf = ArrayConstructor(*msg.data)
-        canWriteWait(self._write_handle,
-                     msg.arbitration_id,
-                     ctypes.byref(buf),
-                     msg.dlc,
-                     flags,
-                     10)
+        canWrite(self._write_handle,
+                 msg.arbitration_id,
+                 ctypes.byref(buf),
+                 msg.dlc,
+                 flags)
+        if timeout:
+            canWriteSync(self._write_handle, int(timeout * 1000))
 
     def flash(self, flash=True):
         """
@@ -547,6 +551,12 @@ def flash(self, flash=True):
             log.error('Could not flash LEDs (%s)', e)
 
     def shutdown(self):
+        # Wait for transmit queue to be cleared
+        try:
+            canWriteSync(self._write_handle, 100)
+        except CANLIBError as e:
+            log.warning("There may be messages in the transmit queue that could "
+                        "not be transmitted before going bus off (%s)", e)
         if not self.single_handle:
             canBusOff(self._read_handle)
             canClose(self._read_handle)
@@ -570,7 +580,7 @@ def get_channel_info(channel):
                       ctypes.byref(number), ctypes.sizeof(number))
 
     return '%s, S/N %d (#%d)' % (
-        name.value.decode(), serial.value, number.value + 1)
+        name.value.decode("ascii"), serial.value, number.value + 1)
 
 
 init_kvaser_library()

can/interfaces/nican.py

@@ -225,7 +225,7 @@ def recv(self, timeout=None):
                       data=raw_msg.data[:dlc])
         return msg
 
-    def send(self, msg):
+    def send(self, msg, timeout=None):
         """
         Send a message to NI-CAN.
 
@@ -252,7 +252,7 @@ def send(self, msg):
         # bit overkill at the moment.
         #state = ctypes.c_ulong()
         #nican.ncWaitForState(
-        #    self.handle, NC_ST_WRITE_SUCCESS, 10, ctypes.byref(state))
+        #    self.handle, NC_ST_WRITE_SUCCESS, int(timeout * 1000), ctypes.byref(state))
 
     def flush_tx_buffer(self):
         """

can/interfaces/pcan/pcan.py

@@ -190,7 +190,7 @@ def recv(self, timeout=None):
 
         return rx_msg
 
-    def send(self, msg):
+    def send(self, msg, timeout=None):
         if msg.id_type:
             msgType = PCAN_MESSAGE_EXTENDED
         else:

can/interfaces/remote/client.py

@@ -91,7 +91,7 @@ def recv(self, timeout=None):
             raise event.exc
         return None
 
-    def send(self, msg):
+    def send(self, msg, timeout=None):
         """Transmit a message to CAN bus.
 
         :param can.Message msg: A Message object.

can/interfaces/serial/serial_can.py

@@ -36,7 +36,7 @@ def __init__(self, channel, *args, **kwargs):
             self.ser = serial.Serial(channel, baudrate=115200, timeout=0.1)
         super(SerialBus, self).__init__(*args, **kwargs)
 
-    def send(self, msg):
+    def send(self, msg, timeout=None):
         raise NotImplementedError("This serial interface doesn't support transmit.")
 
     def recv(self, timeout=None):

can/interfaces/socketcan/socketcan_ctypes.py

@@ -51,12 +51,12 @@ def __init__(self,
         self.socket = createSocket()
 
         log.debug("Result of createSocket was %d", self.socket)
-        
+
         # Add any socket options such as can frame filters
         if 'can_filters' in kwargs and len(kwargs['can_filters']) > 0:
             log.debug("Creating a filtered can bus")
             self.set_filters(kwargs['can_filters'])
-        
+
         error = bindSocket(self.socket, channel)
 
         if receive_own_messages:
@@ -86,7 +86,7 @@ def set_filters(self, can_filters=None):
         # TODO Is this serious enough to raise a CanError exception?
         if res != 0:
             log.error('Setting filters failed: ' + str(res))
-    
+
     def recv(self, timeout=None):
 
         log.debug("Trying to read a msg")
@@ -117,7 +117,7 @@ def recv(self, timeout=None):
 
         return rx_msg
 
-    def send(self, msg):
+    def send(self, msg, timeout=None):
         frame = _build_can_frame(msg)
         bytes_sent = libc.write(self.socket, ctypes.byref(frame), ctypes.sizeof(frame))
         if bytes_sent == -1:

can/interfaces/socketcan/socketcan_native.py

@@ -383,7 +383,7 @@ def recv(self, timeout=None):
 
         return rx_msg
 
-    def send(self, msg):
+    def send(self, msg, timeout=None):
         log.debug("We've been asked to write a message to the bus")
         arbitration_id = msg.arbitration_id
         if msg.id_type:

can/interfaces/usb2can/usb2canInterface.py

@@ -123,9 +123,12 @@ def __init__(self, channel, *args, **kwargs):
 
         self.handle = self.can.open(connector, enable_flags)
 
-    def send(self, msg):
+    def send(self, msg, timeout=None):
         tx = message_convert_tx(msg)
-        self.can.send(self.handle, byref(tx))
+        if timeout:
+            self.can.blocking_send(self.handle, byref(tx), int(timeout * 1000))
+        else:
+            self.can.send(self.handle, byref(tx))
 
     def recv(self, timeout=None):
 

can/interfaces/virtual.py

@@ -12,7 +12,7 @@
 import logging
 import time
 try:
-    import queue as queue
+    import queue
 except ImportError:
     import Queue as queue
 from can.bus import BusABC
@@ -49,7 +49,7 @@ def recv(self, timeout=None):
         logger.log(9, 'Received message:\n%s', msg)
         return msg
 
-    def send(self, msg):
+    def send(self, msg, timeout=None):
         msg.timestamp = time.time()
         # Add message to all listening on this channel
         for bus_queue in self.channel:

test/test_kvaser.py

@@ -15,7 +15,7 @@
 
 
 class KvaserTest(unittest.TestCase):
-    
+
     def setUp(self):
         canlib.canGetNumberOfChannels = Mock(return_value=1)
         canlib.canOpenChannel = Mock(return_value=0)
@@ -27,7 +27,8 @@ def setUp(self):
         canlib.canSetBusOutputControl = Mock()
         canlib.canGetChannelData = Mock()
         canlib.canSetAcceptanceFilter = Mock()
-        canlib.canWriteWait = self.canWriteWait
+        canlib.canWriteSync = Mock()
+        canlib.canWrite = self.canWrite
         canlib.canReadWait = self.canReadWait
 
         self.msg = {}
@@ -160,7 +161,7 @@ def test_recv_standard(self):
         self.assertEqual(msg.id_type, False)
         self.assertSequenceEqual(msg.data, [100, 101])
 
-    def canWriteWait(self, handle, arb_id, buf, dlc, flags, timeout):
+    def canWrite(self, handle, arb_id, buf, dlc, flags):
         self.msg['arb_id'] = arb_id
         self.msg['dlc'] = dlc
         self.msg['flags'] = flags