Merge virtual-interface into default.

Updated tests so that by default use virtual channel for network_test

Author: hardbyte

bin/can_logger.py

@@ -27,7 +27,7 @@
     parser = argparse.ArgumentParser(description="Log CAN traffic, printing messages to stdout or to a given file")
 
     parser.add_argument("-f", "--file_name", dest="log_file",
-                        help="""Path and base log filename, extension can be .txt, .csv, .db, .npz""",
+                        help="""Path and base log filename, extension can be .txt, .asc, .csv, .db, .npz""",
                         default=None)
 
     parser.add_argument("-v", action="count", dest="verbosity",
@@ -70,10 +70,12 @@
 
     bus = can.interface.Bus(results.channel, bustype=results.interface, can_filters=can_filters)
     print('Can Logger (Started on {})\n'.format(datetime.datetime.now()))
-    notifier = can.Notifier(bus, [can.Printer(results.log_file)], timeout=0.1)
+    logger = can.Logger(results.log_file)
+    notifier = can.Notifier(bus, [logger], timeout=0.1)
 
     try:
         while True:
             time.sleep(1)
     except KeyboardInterrupt:
         bus.shutdown()
+        notifier.stop()

can/CAN.py

@@ -8,6 +8,10 @@
 from __future__ import print_function
 
 import logging
+from datetime import datetime
+import time
+import base64
+import sqlite3
 
 try:
     import queue
@@ -42,6 +46,11 @@ def on_message_received(self, msg):
     def __call__(self, msg):
         return self.on_message_received(msg)
 
+    def stop(self):
+        """
+        Override to cleanup any open resources.
+        """
+
 
 class BufferedReader(Listener):
     """
@@ -60,15 +69,43 @@ def on_message_received(self, msg):
     def get_message(self, timeout=0.5):
         """
         Attempts to retrieve the latest message received by the instance. If no message is
-        available it blocks for 0.5 seconds or until a message is received (whichever
-        is shorter), and returns the message if there is one, or None if there is not.
+        available it blocks for given timeout or until a message is received (whichever
+        is shorter),
+
+        :param float timeout: The number of seconds to wait for a new message.
+        :return: the :class:`~can.Message` if there is one, or None if there is not.
         """
         try:
             return self.buffer.get(block=True, timeout=timeout)
         except queue.Empty:
             return None
 
 
+class Logger(object):
+    """
+    Logs CAN messages to a file.
+
+    The format is determined from the file format which can be one of:
+      * .asc: :class:`can.ASCWriter`
+      * .csv: :class:`can.CSVWriter`
+      * .db: :class:`can.SqliteWriter`
+      * other: :class:`can.Printer`
+    """
+
+    @classmethod
+    def __new__(cls, other, filename):
+        if not filename:
+            return Printer()
+        elif filename.endswith(".asc"):
+            return ASCWriter(filename)
+        elif filename.endswith(".csv"):
+            return CSVWriter(filename)
+        elif filename.endswith(".db"):
+            return SqliteWriter(filename)
+        else:
+            return Printer(filename)
+
+
 class Printer(Listener):
     """
     The Printer class is a subclass of :class:`~can.Listener` which simply prints
@@ -89,9 +126,9 @@ def on_message_received(self, msg):
         else:
             print(msg)
 
-    def __del__(self):
-        self.output_file.write("\n")
+    def stop(self):
         if self.output_file:
+            self.output_file.write("\n")
             self.output_file.close()
 
 
@@ -105,30 +142,125 @@ def __init__(self, filename):
         self.csv_file = open(filename, 'wt')
 
         # Write a header row
-        self.csv_file.write("timestamp, arbitrationid, flags, dlc, data")
+        self.csv_file.write("timestamp, arbitration id, extended, remote, error, dlc, data\n")
 
     def on_message_received(self, msg):
-        row = ','.join([msg.timestamp,
-                        msg.arbitration_id,
-                        msg.flags,
-                        msg.dlc,
-                        msg.data])
+        row = ','.join([
+            str(msg.timestamp),
+            hex(msg.arbitration_id),
+            '1' if msg.id_type else '0',
+            '1' if msg.is_remote_frame else '0',
+            '1' if msg.is_error_frame else '0',
+            str(msg.dlc),
+            base64.b64encode(msg.data).decode('utf8')
+            ])
         self.csv_file.write(row + '\n')
 
-    def __del__(self):
+    def stop(self):
+        self.csv_file.flush()
         self.csv_file.close()
-        super(CSVWriter, self).__del__()
 
 
 class SqliteWriter(Listener):
-    """TODO"""
+    """Logs received CAN data to a simple SQL database.
+
+    The sqlite database may already exist, otherwise it will
+    be created when the first message arrives.
+    """
+
+    insert_msg_template = '''
+        INSERT INTO messages VALUES
+        (?, ?, ?, ?, ?, ?, ?)
+        '''
 
     def __init__(self, filename):
-        self.db_file = open(filename, 'wt')
+        self.db_fn = filename
+        self.db_setup = False
+
+    def _create_db(self):
+        # Note you can't share sqlite3 connections between threads
+        # hence we setup the db here.
+        log.info("Creating sqlite db")
+        self.conn = sqlite3.connect(self.db_fn)
+        c = self.conn.cursor()
 
         # create table structure
-        raise NotImplementedError("TODO")
+        c.execute('''
+        CREATE TABLE IF NOT EXISTS messages
+        (
+          ts REAL,
+          arbitration_id INTEGER,
+          extended INTEGER,
+          remote INTEGER,
+          error INTEGER,
+          dlc INTEGER,
+          data BLOB
+        )
+        ''')
+        self.conn.commit()
+
+        self.db_setup = True
+
+    def on_message_received(self, msg):
+        if not self.db_setup:
+            self._create_db()
+
+        # add row to db
+        row_data = (
+            msg.timestamp,
+            msg.arbitration_id,
+            msg.id_type,
+            msg.is_remote_frame,
+            msg.is_error_frame,
+            msg.dlc,
+            msg.data
+        )
+        c = self.conn.cursor()
+        c.execute(SqliteWriter.insert_msg_template, row_data)
+
+        self.conn.commit()
+
+    def stop(self):
+        if self.db_setup:
+            self.conn.commit()
+            self.conn.close()
+
+
+class ASCWriter(Listener):
+    """Logs CAN data to an ASCII log file (.asc)"""
+
+    LOG_STRING = "{time: 9.4f} {channel}  {id:<15} Rx   d {dlc} {data}\n"
+
+    def __init__(self, filename):
+        now = datetime.now().strftime("%a %b %m %I:%M:%S %p %Y")
+        self.start = time.time()
+        self.log_file = open(filename, "w")
+        self.log_file.write("date %s\n" % now)
+        self.log_file.write("base hex  timestamps absolute\n")
+        self.log_file.write("internal events logged\n")
+        self.log_file.write("Begin Triggerblock %s\n" % now)
+        self.log_file.write("   0.0000 Start of measurement\n")
+
+    def stop(self):
+        """Stops logging and closes the file."""
+        if self.log_file:
+            self.log_file.write("End TriggerBlock\n")
+            self.log_file.close()
+            self.log_file = None
 
     def on_message_received(self, msg):
-        # add row
-        raise NotImplementedError("TODO")
+        data = ["{:02X}".format(byte) for byte in msg.data]
+        arb_id = "{:X}".format(msg.arbitration_id)
+        if msg.id_type:
+            arb_id = arb_id + "x"
+        timestamp = msg.timestamp
+        if timestamp >= self.start:
+            timestamp -= self.start
+
+        line = self.LOG_STRING.format(time=timestamp,
+                                      channel=1,
+                                      id=arb_id,
+                                      dlc=msg.dlc,
+                                      data=" ".join(data))
+        if self.log_file:
+            self.log_file.write(line)

can/__init__.py

@@ -16,7 +16,7 @@
 class CanError(IOError):
     pass
 
-from can.CAN import BufferedReader, Listener, Printer, CSVWriter, SqliteWriter, set_logging_level
+from can.CAN import BufferedReader, Listener, Logger, Printer, CSVWriter, SqliteWriter, ASCWriter, set_logging_level
 from can.message import Message
 from can.bus import BusABC
 from can.notifier import Notifier

can/bus.py

@@ -33,6 +33,8 @@ def __init__(self, channel=None, can_filters=None, **config):
 
             >>> [{"can_id": 0x11, "can_mask": 0x21}]
 
+            A filter matches, when ``<received_can_id> & can_mask == can_id & can_mask``
+
         :param dict config:
             Any backend dependent configurations are passed in this dictionary
         """
@@ -80,6 +82,10 @@ def flush_tx_buffer(self):
         pass
 
     def shutdown(self):
+        """
+        Called to carry out any interface specific cleanup required
+        in shutting down a bus.
+        """
         self.flush_tx_buffer()
 
     __metaclass__ = abc.ABCMeta

can/ctypesutil.py

@@ -46,7 +46,12 @@ def map_symbol(self, func_name, restype=None, argtypes=(), errcheck=None):
         return symbol
 
 
-class CLibrary_Win32(ctypes.WinDLL, LibraryMixin):
+try:
+    _LibBase = ctypes.WinDLL
+except AttributeError:
+    _LibBase = ctypes.CDLL
+
+class CLibrary_Win32(_LibBase, LibraryMixin):
     " Basic ctypes.WinDLL derived class + LibraryMixin "
 
     def __init__(self, library_or_path):

can/interfaces/interface.py

@@ -1,6 +1,6 @@
 import can
-from can.util import load_config, choose_socketcan_implementation
 from can.broadcastmanager import CyclicSendTaskABC, MultiRateCyclicSendTaskABC
+from can.util import load_config, choose_socketcan_implementation
 
 VALID_INTERFACES = set(['kvaser', 'serial', 'pcan', 'socketcan_native',
                         'socketcan_ctypes', 'socketcan', 'usb2can', 'ixxat',
@@ -11,6 +11,9 @@ class Bus(object):
     """
     Instantiates a CAN Bus of the given `bustype`, falls back to reading a
     configuration file from default locations.
+
+    :raises: NotImplementedError if the bustype isn't recognized
+
     """
 
     @classmethod
@@ -43,7 +46,7 @@ def __new__(cls, other, channel=None, *args, **kwargs):
             from can.interfaces.socketcan_native import SocketscanNative_Bus
             cls = SocketscanNative_Bus
         elif interface == 'serial':
-            from can.interfaces.serial_can import SerialBus
+            from can.interfaces.serial.serial_can import SerialBus
             cls = SerialBus
         elif interface == 'pcan':
             from can.interfaces.pcan import PcanBus

can/interfaces/ixxat/__init__.py

@@ -2,6 +2,6 @@
 """
 Ctypes wrapper module for IXXAT Virtual CAN Interface V3 on win32 systems
 Copyright (C) 2016 Giuseppe Corbelli <[email protected]>
-"""
-
-from can.interfaces.ixxat.canlib import *
+"""
+
+from can.interfaces.ixxat.canlib import IXXATBus as Bus

can/interfaces/ixxat/canlib.py

@@ -141,7 +141,8 @@ def __check_status(result, function, arguments):
 
 
 class IXXATBus(BusABC):
-    " The CAN Bus implemented for the IXXAT interface. "
+    """The CAN Bus implemented for the IXXAT interface.
+    """
 
     CHANNEL_BITRATES = {
         0: {
@@ -178,12 +179,10 @@ def __init__(self, channel, can_filters=None, **config):
 
             >>> [{"can_id": 0x11, "can_mask": 0x21}]
 
-        Backend Configuration
-        ---------------------
-
         :param int UniqueHardwareId:
             UniqueHardwareId to connect (optional, will use the first found if not supplied)
-        :param int bitrate
+
+        :param int bitrate:
             Channel bitrate in bit/s
         """
         if (_canlib is None):
@@ -241,13 +240,13 @@ def __init__(self, channel, can_filters=None, **config):
             self.CHANNEL_BITRATES[1][bitrate]
         )
         _canlib.canControlGetCaps(self._control_handle, ctypes.byref(self._channel_capabilities))
+        
         # With receive messages, this field contains the relative reception time of
         # the message in ticks. The resolution of a tick can be calculated from the fields
-        # dwClockFreq and dwTscDivisor of the structure  CANCAPABILITIES in accor-
-        # dance with the following formula:
-        # Resolution [s] = dwTscDivisor / dwClockFreq
-        # Reversed the terms, so that we have the number of ticks in a second
-        self._tick_resolution =  self._channel_capabilities.dwClockFreq / self._channel_capabilities.dwTscDivisor
+        # dwClockFreq and dwTscDivisor of the structure  CANCAPABILITIES in accordance with the following formula:
+        # frequency [1/s] = dwClockFreq / dwTscDivisor
+        # We explicitly cast to float for Python 2.x users
+        self._tick_resolution =  float(self._channel_capabilities.dwClockFreq / self._channel_capabilities.dwTscDivisor)
 
         # Setup filters before starting the channel
         if can_filters is not None and len(can_filters):