Kvaser filtering improvements.

Updated documentation regarding filtering behavior.
Apply same filters for both read and write handle to allow HW filtering.
Removed documentation on threading.

Author: christiansandberg

can/interfaces/kvaser/canlib.py

@@ -349,9 +349,6 @@ def __init__(self, channel, can_filters=None, **config):
                  4)
         canSetBusParams(self._read_handle, bitrate, tseg1, tseg2, sjw, no_samp, 0)
 
-        self.sw_filters = []
-        self.set_filters(can_filters)
-
         if self.single_handle:
             log.debug("We don't require separate handles to the bus")
             self._write_handle = self._read_handle
@@ -360,6 +357,9 @@ def __init__(self, channel, can_filters=None, **config):
             self._write_handle = canOpenChannel(channel, canstat.canOPEN_ACCEPT_VIRTUAL)
             canBusOn(self._read_handle)
 
+        self.sw_filters = []
+        self.set_filters(can_filters)
+
         can_driver_mode = canstat.canDRIVER_SILENT if driver_mode == DRIVER_MODE_SILENT else canstat.canDRIVER_NORMAL
         canSetBusOutputControl(self._write_handle, can_driver_mode)
         log.debug('Going bus on TX handle')
@@ -407,9 +407,10 @@ def set_filters(self, can_filters=None):
             log.info('Filtering is handled in Python')
             self.sw_filters = can_filters
 
-        # Set filters for both std and ext IDs
-        for ext in (0, 1):
-            canSetAcceptanceFilter(self._read_handle, can_id, can_mask, ext)
+        # Set same filter for both handles as well as standard and extended IDs
+        for handle in (self._read_handle, self._write_handle):
+            for ext in (0, 1):
+                canSetAcceptanceFilter(handle, can_id, can_mask, ext)
 
     def flush_tx_buffer(self):
         """

doc/kvaser.rst

@@ -16,25 +16,20 @@ Internals
 The Kvaser :class:`~can.Bus` object with a physical CAN Bus can be operated in two
 modes; ``single_handle`` mode with one shared bus handle used for both reading and
 writing to the CAN bus, or with two separate bus handles.
+Two separate handles are needed if receiving and sending messages are done in
+different threads (see `Kvaser documentation
+<http://www.kvaser.com/canlib-webhelp/page_user_guide_threads_applications.html>`_).
 
 
 .. warning:: Any objects inheriting from `Bus`_ should *not* directly
         use the interface handle(/s).
 
 
-Threading
-~~~~~~~~~
+Message filtering
+~~~~~~~~~~~~~~~~~
 
-To avoid contention for the bus handle in ``single_handle`` mode, access is protected for
-the **read** and **write** daemon threads with a ``writing_event`` *Event* and a
-``done_writing`` *Condition*.
-
-The read thread acquires ``done_writing`` and while ``writing_event`` is set
-blocks waiting on the ``done_writing`` Condition. A 1ms blocking read is carried
-out before ``done_writing`` is released.
-
-The write thread blocks for 5ms on a queue (to allow the thread to stop). If
-a message was received it *sets* the writing_event to tell the read thread
-that a message in waiting to be sent. The ``done_writing`` is acquired for
-the actual write, the writing_event is cleared and the ``done_writing`` event
-is notified to start the read thread again.
+The Kvaser driver and hardware only supports setting one filter per handle.
+If one filter is requested, this is will be handled by the Kvaser driver.
+If more than one filter is needed, these will be handled in Python code
+in the ``recv`` method. If a message does not match any of the filters,
+``recv()`` will return None.

test/test_kvaser.py

@@ -53,8 +53,10 @@ def test_bus_shutdown(self):
     def test_filter_setup(self):
         # No filter in constructor
         expected_args = [
-            ((0, 0, 0, 0),),       # Disable filtering STD
-            ((0, 0, 0, 1),),       # Disable filtering EXT
+            ((0, 0, 0, 0),),       # Disable filtering STD on read handle
+            ((0, 0, 0, 1),),       # Disable filtering EXT on read handle
+            ((0, 0, 0, 0),),       # Disable filtering STD on write handle
+            ((0, 0, 0, 1),),       # Disable filtering EXT on write handle
         ]
         self.assertEqual(canlib.canSetAcceptanceFilter.call_args_list,
                          expected_args)
@@ -65,8 +67,10 @@ def test_filter_setup(self):
             {'can_id': 0x8, 'can_mask': 0xff}
         ])
         expected_args = [
-            ((0, 0x8, 0xff, 0),),       # Enable filtering STD
-            ((0, 0x8, 0xff, 1),),       # Enable filtering EXT
+            ((0, 0x8, 0xff, 0),),       # Enable filtering STD on read handle
+            ((0, 0x8, 0xff, 1),),       # Enable filtering EXT on read handle
+            ((0, 0x8, 0xff, 0),),       # Enable filtering STD on write handle
+            ((0, 0x8, 0xff, 1),),       # Enable filtering EXT on write handle
         ]
         self.assertEqual(canlib.canSetAcceptanceFilter.call_args_list,
                          expected_args)
@@ -79,8 +83,10 @@ def test_filter_setup(self):
         ]
         self.bus.set_filters(multiple_filters)
         expected_args = [
-            ((0, 0, 0, 0),),       # Disable filtering STD
-            ((0, 0, 0, 1),),       # Disable filtering EXT
+            ((0, 0, 0, 0),),       # Disable filtering STD on read handle
+            ((0, 0, 0, 1),),       # Disable filtering EXT on read handle
+            ((0, 0, 0, 0),),       # Disable filtering STD on write handle
+            ((0, 0, 0, 1),),       # Disable filtering EXT on write handle
         ]
         self.assertEqual(canlib.canSetAcceptanceFilter.call_args_list,
                          expected_args)