rename io to formated_io because io is a system-module

ebroecker · hardbyte · commit b0ce54f4f9de · 2017-10-16T13:59:45.000+11:00
rename serial to basic_serial because serial is a system-module
add slcan/lawicel serial interface
diff --git a/can/CAN.py b/can/CAN.py
@@ -9,7 +9,7 @@
 from can.message import Message
 from can.listener import Listener, BufferedReader, RedirectReader
 from can.util import set_logging_level
-from can.io import *
+from can.formated_io import *
 
 import logging
 
diff --git a/can/__init__.py b/can/__init__.py
@@ -17,11 +17,11 @@ class CanError(IOError):
 
 from can.listener import Listener, BufferedReader, RedirectReader
 
-from can.io import Logger, Printer, LogReader
-from can.io import ASCWriter
-from can.io import BLFReader, BLFWriter
-from can.io import CSVWriter
-from can.io import SqliteWriter, SqlReader
+from can.formated_io import Logger, Printer, LogReader
+from can.formated_io import ASCWriter
+from can.formated_io import BLFReader, BLFWriter
+from can.formated_io import CSVWriter
+from can.formated_io import SqliteWriter, SqlReader
 
 from can.util import set_logging_level
 
diff --git a/can/formated_io/__init__.py b/can/formated_io/__init__.py
diff --git a/can/formated_io/asc.py b/can/formated_io/asc.py
diff --git a/can/formated_io/blf.py b/can/formated_io/blf.py
diff --git a/can/formated_io/csv.py b/can/formated_io/csv.py
diff --git a/can/formated_io/logger.py b/can/formated_io/logger.py
diff --git a/can/formated_io/player.py b/can/formated_io/player.py
@@ -5,7 +5,7 @@
 from .blf import BLFReader
 from .sqlite import SqlReader
 
-log = logging.getLogger('can.io.player')
+log = logging.getLogger('can.formated_io.player')
 
 
 class LogReader(object):
diff --git a/can/formated_io/sqlite.py b/can/formated_io/sqlite.py
@@ -7,7 +7,7 @@
 import sqlite3
 import logging
 
-log = logging.getLogger('can.io.sql')
+log = logging.getLogger('can.formated_io.sql')
 
 if sys.version_info > (3,):
     buffer = memoryview
diff --git a/can/formated_io/stdout.py b/can/formated_io/stdout.py
@@ -1,7 +1,7 @@
 from can.listener import Listener
 import logging
 
-log = logging.getLogger('can.io.stdout')
+log = logging.getLogger('can.formated_io.stdout')
 
 
 class Printer(Listener):
diff --git a/can/interface.py b/can/interface.py
@@ -11,7 +11,7 @@
     'kvaser':           ('can.interfaces.kvaser', 'KvaserBus'),
     'socketcan_ctypes': ('can.interfaces.socketcan', 'SocketcanCtypes_Bus'),
     'socketcan_native': ('can.interfaces.socketcan', 'SocketcanNative_Bus'),
-    'serial':           ('can.interfaces.serial.serial_can', 'SerialBus'),
+    'basic_serial':     ('can.interfaces.basic_serial.serial_can', 'SerialBus'),
     'pcan':             ('can.interfaces.pcan', 'PcanBus'),
     'usb2can':          ('can.interfaces.usb2can', 'Usb2canBus'),
     'ixxat':            ('can.interfaces.ixxat', 'IXXATBus'),
@@ -20,7 +20,8 @@
     'remote':           ('can.interfaces.remote', 'RemoteBus'),
     'virtual':          ('can.interfaces.virtual', 'VirtualBus'),
     'neovi':            ('can.interfaces.neovi_api', 'NeoVIBus'),
-    'vector':           ('can.interfaces.vector', 'VectorBus')
+    'vector':           ('can.interfaces.vector', 'VectorBus'),
+    'slcan':            ('can.interfaces.slcan', 'slcanBus')
 }
 
 
diff --git a/can/interfaces/__init__.py b/can/interfaces/__init__.py
@@ -3,6 +3,6 @@
 Interfaces contain low level implementations that interact with CAN hardware.
 """
 
-VALID_INTERFACES = set(['kvaser', 'serial', 'pcan', 'socketcan_native',
+VALID_INTERFACES = set(['kvaser', 'basic_serial', 'pcan', 'socketcan_native',
                         'socketcan_ctypes', 'socketcan', 'usb2can', 'ixxat',
-                        'nican', 'iscan', 'vector', 'remote', 'virtual', 'neovi'])
+                        'nican', 'iscan', 'vector', 'remote', 'virtual', 'neovi','slcan'])
diff --git a/can/interfaces/basic_serial/__init__.py b/can/interfaces/basic_serial/__init__.py
@@ -0,0 +1 @@
+from can.interfaces.basic_serial.serial_can import SerialBus as Bus
diff --git a/can/interfaces/basic_serial/serial_can.py b/can/interfaces/basic_serial/serial_can.py
@@ -7,12 +7,12 @@
 
 import logging
 
-logger = logging.getLogger('can.serial')
+logger = logging.getLogger('can.basic_serial')
 
 try:
     import serial
 except ImportError:
-    logger.error("You won't be able to use the serial can backend without the serial module installed!")
+    logger.error("You won't be able to use the basic_serial can backend without the basic_serial module installed!")
     serial = None
 
 from can.bus import BusABC
@@ -22,22 +22,22 @@
 class SerialBus(BusABC):
 
     def __init__(self, channel, *args, **kwargs):
-        """A serial interface to CAN.
+        """A basic_serial interface to CAN.
 
         :param str channel:
-            The serial device to open.
+            The basic_serial device to open.
         """
         if channel == '':
-            raise TypeError("Must specify a serial port.")
+            raise TypeError("Must specify a basic_serial port.")
         else:
             self.channel_info = "Serial interface: " + channel
 
-            # Note: Some serial port implementations don't care about the baud rate
+            # Note: Some basic_serial port implementations don't care about the baud rate
             self.ser = serial.Serial(channel, baudrate=115200, timeout=0.1)
         super(SerialBus, self).__init__(*args, **kwargs)
 
     def send(self, msg, timeout=None):
-        raise NotImplementedError("This serial interface doesn't support transmit.")
+        raise NotImplementedError("This basic_serial interface doesn't support transmit.")
 
     def recv(self, timeout=None):
 
diff --git a/can/interfaces/serial/__init__.py b/can/interfaces/serial/__init__.py
diff --git a/can/interfaces/slcan.py b/can/interfaces/slcan.py
@@ -0,0 +1,146 @@
+"""
+Interface for slcan compatible interfaces (win32/linux).
+(Linux could use slcand/socketcan also).
+"""
+
+import serial
+import io
+import time
+import logging
+
+from can import CanError, BusABC, Message
+
+
+logger = logging.getLogger(__name__)
+
+class slcanBus(BusABC):
+    """slcan interface"""
+
+    def write(self, str):
+        if not str.endswith("\r"):
+            str += "\r"
+        self.serialPort.write(str.decode())
+        self.serialPort.flush()
+
+    def open(self):
+        self.write("O")
+
+    def close(self):
+        self.write("C")
+
+
+    def __init__(self, channel, ttyBaudrate=115200, timeout=1, bitrate=None, poll_interval=0.01 , **kwargs):
+        """
+        :param string channel:
+            port of underlying basic_serial or usb device (e.g. /dev/ttyUSB0, COM8, ...)
+        :param int ttyBaudrate:
+            baudrate of underlying basic_serial or usb device
+        :param int bitrate:
+            Bitrate in bits/s
+        :param float poll_interval:
+            Poll interval in seconds when reading messages
+        :param float timeout
+            timeout in seconds when reading message
+        """
+
+
+        if channel == '':
+            raise TypeError("Must specify a serial port.")
+        if '@' in channel:
+            (channel, ttyBaudrate) = channel.split('@')
+
+        self.poll_interval = poll_interval
+
+        self.serialPortOrig = serial.Serial(channel, baudrate=ttyBaudrate, timeout=timeout)
+        self.serialPort = io.TextIOWrapper(io.BufferedRWPair(self.serialPortOrig, self.serialPortOrig, 1),
+                                               newline='\r', line_buffering=True)
+
+        time.sleep(2)
+        if bitrate is not None:
+            self.close()
+            if bitrate == 10000:
+                self.write('S0')
+            elif bitrate == 20000:
+                self.write('S1')
+            elif bitrate == 50000:
+                self.write('S2')
+            elif bitrate == 100000:
+                self.write('S3')
+            elif bitrate == 125000:
+                self.write('S4')
+            elif bitrate == 250000:
+                self.write('S5')
+            elif bitrate == 500000:
+                self.write('S6')
+            elif bitrate == 750000:
+                self.write('S7')
+            elif bitrate == 1000000:
+                self.write('S8')
+            elif bitrate == 83300:
+                self.write('S9')
+            else:
+                raise ValueError("Invalid bitrate, choose one of 10000 20000 50000 100000 125000 250000 500000 750000 1000000 83300")
+
+        self.open()
+        super(slcanBus, self).__init__(channel, **kwargs)
+
+    def recv(self, timeout=None):
+        if timeout is not None:
+            self.serialPortOrig.timeout = timeout
+
+        canId = None
+        remote = False
+        frame = []
+        str = self.serialPort.readline()
+        if str is None or len(str) == 0:
+            return None
+        else:
+            if str[0] == 'T':  # entended frame
+                canId = int(str[1:9], 16)
+                dlc = int(str[9])
+                extended = True
+                for i in range(0, dlc):
+                    frame.append(int(str[10 + i * 2:12 + i * 2], 16))
+            elif str[0] == 't':  # normal frame
+                canId = int(str[1:4], 16)
+                dlc = int(str[4])
+                for i in range(0, dlc):
+                    frame.append(int(str[5 + i * 2:7 + i * 2], 16))
+                extended = False
+            elif str[0] == 'r':  # remote frame
+                canId = int(str[1:4], 16)
+                remote = True
+            elif str[0] == 'R':  # remote extended frame
+                canId = int(str[1:9], 16)
+                extended = True
+                remote = True
+
+            if canId is not None:
+                return Message(arbitration_id=canId,
+                               extended_id=extended,
+                               timestamp=time.time(),   # Better than nothing...
+                               is_remote_frame=remote,
+                               dlc=dlc,
+                               data=frame)
+            else:
+                return None
+
+    def send(self, msg, timeout=None):
+        if bool(msg.is_remote_frame):
+            if bool(msg.is_extended_id):
+                sendStr = "R%08X0" % (msg.arbitration_id)
+            else:
+                sendStr = "r%03X0" % (msg.arbitration_id)
+        else:
+            if bool(msg.is_extended_id):
+                sendStr = "T%08X%d" % (msg.arbitration_id, msg.dlc)
+            else:
+                sendStr = "t%03X%d" % (msg.arbitration_id, msg.dlc)
+
+            for i in range(0, msg.dlc):
+                sendStr += "%02X" % msg.data[i]
+        self.write(sendStr)
+
+
+    def shutdown(self):
+        self.close()
diff --git a/can/interfaces/usb2can/serial_selector.py b/can/interfaces/usb2can/serial_selector.py
@@ -29,7 +29,7 @@ def serial():
 
     for objItem in colItems:
         string = objItem.Dependent
-        # find based on beginning of serial
+        # find based on beginning of basic_serial
         if "ED" in string:
             # print "Dependent:" + ` objItem.Dependent`
             string = string[len(string) - 9:len(string) - 1]
diff --git a/can/interfaces/usb2can/usb2canInterface.py b/can/interfaces/usb2can/usb2canInterface.py
@@ -76,8 +76,8 @@ class Usb2canBus(BusABC):
     Note the USB2CAN interface doesn't implement set_filters, or flush_tx_buffer methods.
 
     :param str channel:
-        The device's serial number. If not provided, Windows Management Instrumentation
-        will be used to identify the first such device. The *kwarg* `serial` may also be
+        The device's basic_serial number. If not provided, Windows Management Instrumentation
+        will be used to identify the first such device. The *kwarg* `basic_serial` may also be
         used.
 
     :param int bitrate:
@@ -99,9 +99,9 @@ def __init__(self, channel, *args, **kwargs):
         else:
             enable_flags = 0x00000008
 
-        # code to get the serial number of the device
-        if 'serial' in kwargs:
-            deviceID = kwargs["serial"]
+        # code to get the basic_serial number of the device
+        if 'basic_serial' in kwargs:
+            deviceID = kwargs["basic_serial"]
         elif channel is not None:
             deviceID = channel
         else:
diff --git a/can/logger.py b/can/logger.py
@@ -20,7 +20,7 @@
 import socket
 
 import can
-from can.io.logger import Logger
+from can.formated_io.logger import Logger
 
 
 def main():
@@ -35,7 +35,7 @@ def main():
                         You can add several of these e.g., -vv is DEBUG''', default=2)
 
     parser.add_argument('-c', '--channel', help='''Most backend interfaces require some sort of channel.
-    For example with the serial interface the channel might be a rfcomm device: "/dev/rfcomm0"
+    For example with the basic_serial interface the channel might be a rfcomm device: "/dev/rfcomm0"
     With the socketcan interfaces valid channel examples include: "can0", "vcan0"''')
 
     parser.add_argument('-i', '--interface', dest="interface",
diff --git a/can/player.py b/can/player.py
@@ -10,7 +10,7 @@
 import datetime
 
 import can
-from can.io.player import LogReader, MessageSync
+from can.formated_io.player import LogReader, MessageSync
 
 
 def main():
@@ -26,7 +26,7 @@ def main():
 
     parser.add_argument('-c', '--channel',
                         help='''Most backend interfaces require some sort of channel.
-    For example with the serial interface the channel might be a rfcomm device: "/dev/rfcomm0"
+    For example with the basic_serial interface the channel might be a rfcomm device: "/dev/rfcomm0"
     With the socketcan interfaces valid channel examples include: "can0", "vcan0"''')
 
     parser.add_argument('-i', '--interface', dest="interface",
diff --git a/can/server.py b/can/server.py
@@ -15,7 +15,7 @@ def main():
                         You can add several of these e.g., -vv is DEBUG''', default=3)
 
     parser.add_argument('-c', '--channel', help='''Most backend interfaces require some sort of channel.
-    For example with the serial interface the channel might be a rfcomm device: "/dev/rfcomm0"
+    For example with the basic_serial interface the channel might be a rfcomm device: "/dev/rfcomm0"
     With the socketcan interfaces valid channel examples include: "can0", "vcan0".
     The server will only serve this channel. Start additional servers at different
     ports to share more channels.''')
diff --git a/doc/conf.py b/doc/conf.py
@@ -204,6 +204,6 @@ def __getattr__(cls, name):
         else:
             return Mock()
 
-MOCK_MODULES = ['serial']
+MOCK_MODULES = ['basic_serial']
 for mod_name in MOCK_MODULES:
     sys.modules[mod_name] = Mock()
diff --git a/examples/send_one.py b/examples/send_one.py
