Merge branch 'api-cleanup'

README.md

@@ -1,4 +1,4 @@
-##**Canmatrix** is a python package to read and write several CAN database formats.##
+##**Canmatrix** is a python package to read and write several CAN (Controller Area Network) database formats.##
 
 ###About
 

canmatrix/canmatrix.py

@@ -106,32 +106,84 @@ class Signal(object):
     contains on Signal of canmatrix-object
     with following attributes:
             _name, _startbit,_signalsize (in Bits)
-            _byteorder (1: Intel, 0: Motorola)
-            _valuetype ()
+            _is_little_endian (1: Intel, 0: Motorola)
+            _is_signed ()
             _factor, _offset, _min, _max
             _receiver  (Boarunit/ECU-Name)
             _attributes, _values, _unit, _comment
             _multiplex ('Multiplexor' or Number of Multiplex)
     """
-    def __init__(self, name, startbit, signalsize, byteorder, valuetype="+", factor=1, offset=0, min=0, max=0, unit="", receiver=[], multiplex=None):
+#    def __init__(self, name, startbit, signalsize, is_little_endian, is_signed=False, factor=1, offset=0, min=0, max=0, unit="", receiver=[], multiplex=None):
+    def __init__(self, name, **kwargs):
+
+        if 'startBit' in kwargs:
+            self._startbit = int(kwargs["startBit"])
+        else:
+            self._startbit = 0
+
+        if 'signalSize' in kwargs:
+            self._signalsize = int(kwargs["signalSize"])
+        else:
+            self._signalsize = 0
+
+        if 'is_little_endian' in kwargs:
+            self._is_little_endian = kwargs["is_little_endian"]
+        else:
+            self._is_little_endian = True
+
+        if 'is_signed' in kwargs:
+            self._is_signed = kwargs["is_signed"]
+        else:
+            self._is_signed = True
+
+        if 'factor' in kwargs:
+            self._factor = float(kwargs["factor"])
+        else:
+            self._factor = float(1)
+
+        if 'offset' in kwargs:
+            self._offset = float(kwargs["offset"])
+        else:
+            self._offset = float(0)
+
+        if 'min' in kwargs:
+            self._min = float(kwargs["min"])
+        else:
+            self._min = float(0)
+
+        if 'max' in kwargs:
+            self._max = float(kwargs["max"])
+        else:
+            self._max = float(0)
+
+        if 'unit' in kwargs:
+            self._unit = kwargs["unit"]
+        else:
+            self._unit = ""
+
+        if 'receiver' in kwargs:
+            self._receiver = kwargs["receiver"]
+        else:
+            self._receiver = []
+
+        if 'comment' in kwargs:
+            self._comment = kwargs["comment"]
+        else:
+            self._comment = None
+
+        if 'multiplex' in kwargs:
+            if kwargs["multiplex"] is not None and kwargs["multiplex"] != 'Multiplexor':
+                multiplex = int(kwargs["multiplex"])
+            else:
+                multiplex = kwargs["multiplex"]
+            self._multiplex = multiplex
+        else:
+            self._multiplex = None
+
         self._name = name
-        self._startbit = int(startbit)
-        self._signalsize = int(signalsize)
-        self._byteorder = int(byteorder)
-        # byteorder: 1: Intel, 0: Motorola
-        self._valuetype = valuetype
-        self._factor = str(factor)
-        self._offset = str(offset)
-        self._min = str(min)
-        self._max = str(max)
-        self._receiver = receiver
         self._attributes = {}
         self._values = {}
-        self._unit = unit
-        self._comment = None
-        if multiplex is not None and multiplex != 'Multiplexor':
-            multiplex = int(multiplex)
-        self._multiplex = multiplex
+
     def addComment(self, comment):
         """
         Set comment of Signal
@@ -150,7 +202,7 @@ def addValues(self, value, valueName):
         """
         self._values[int(value)] = valueName
     def setMsbReverseStartbit(self, msbStartBitReverse, length=None):
-        if self._byteorder == 1:
+        if self._is_little_endian == 1:
             #Intel
             self._startbit = msbStartBitReverse
         else:
@@ -164,7 +216,7 @@ def setMsbStartbit(self, msbStartBit, length=None):
         set startbit while given startbit is most significant bit
         if length is not given, use length from object
         """
-        if self._byteorder == 1:
+        if self._is_little_endian == 1:
             #Intel
             self._startbit = msbStartBit
         else:
@@ -185,7 +237,7 @@ def setLsbStartbit(self, lsbStartBit):
         self._startbit = lsbStartBit
 
     def getMsbReverseStartbit(self):
-        if self._byteorder == 1:
+        if self._is_little_endian == 1:
             #Intel
             return self._startbit
         else:
@@ -197,7 +249,7 @@ def getMsbReverseStartbit(self):
             return int(startBit)
 
     def getMsbStartbit(self):
-        if self._byteorder == 1:
+        if self._is_little_endian == 1:
             #Intel
             return self._startbit
         else:
@@ -250,20 +302,42 @@ class Frame(object):
     _signals (list of signal-objects), _attributes (list of attributes),
     _receiver (list of boardunits/ECU-names), _extended (Extended Frame = 1), _comment
     """
-    def __init__(self,bid, name, size, transmitter):
-        self._Id = int(bid)
+#    def __init__(self,bid, name, size, transmitter):
+    def __init__(self, name, **kwargs):
         self._name = name
-        if transmitter is not None:
-            self._Transmitter = [transmitter]
+        if 'Id' in kwargs:
+            self._Id = int(kwargs["Id"])
+        else:
+            self._Id = 0
+
+        if 'dlc' in kwargs:
+            self._Size = int(kwargs["dlc"])
+        else:
+            self._Size = 0
+
+        if 'transmitter' in kwargs:
+            self._Transmitter = [kwargs["transmitter"]]
         else:
             self._Transmitter = []
-        self._Size = int(size)
-        self._signals = []
+
+        if 'extended' in kwargs:
+            self._extended = kwargs["extended"]
+        else:
+            self._extended = 0
+
+        if 'comment' in kwargs:
+            self._comment = kwargs["comment"]
+        else:
+            self._comment = None
+
+        if 'signals' in kwargs:
+            self._signals = kwargs["signals"]
+        else:
+            self._signals = []
+
         self._attributes = {}
         self._receiver = []
         self._SignalGroups = []
-        self._extended = 0
-        self._comment = None
 
     def addSignalGroup(self, Name, Id, signalNames):
         newGroup = SignalGroup(Name, Id)
@@ -334,10 +408,10 @@ def calcDLC(self):
         """
         maxBit = 0
         for sig in self._signals:
-            if sig._byteorder == 1  and sig.getLsbStartbit() + int(sig._signalsize) > maxBit:
+            if sig._is_little_endian == 1  and sig.getLsbStartbit() + int(sig._signalsize) > maxBit:
                 # check intel signal (startbit + length):
                 maxBit = sig.getLsbStartbit() + int(sig._signalsize)
-            elif sig._byteorder == 0  and sig.getLsbStartbit() > maxBit:
+            elif sig._is_little_endian == 0  and sig.getLsbStartbit() > maxBit:
                 #check motorola signal (starbit is least significant bit):
                 maxBit = sig.getLsbStartbit()
         self._Size =  max(self._Size, math.ceil(maxBit / 8))
@@ -474,19 +548,17 @@ def deleteZeroSignals(self):
                     frame._signals.remove(signal)
 
     def recalcDLC(self, strategy):
-        print("recalcDLC")
-        print(strategy)
         for frame in self._fl._list:
             originalDlc = frame._Size
             if "max" == strategy:
                 frame.calcDLC()
             if "force" == strategy:
                 maxBit = 0
                 for sig in frame._signals:
-                    if sig._byteorder == 1  and sig.getLsbStartbit() + int(sig._signalsize) > maxBit:
+                    if sig._is_little_endian == 1  and sig.getLsbStartbit() + int(sig._signalsize) > maxBit:
                         # check intel signal (startbit + length):
                         maxBit = sig.getLsbStartbit() + int(sig._signalsize)
-                    elif sig._byteorder == 0  and sig.getLsbStartbit() > maxBit:
+                    elif sig._is_little_endian == 0  and sig.getLsbStartbit() > maxBit:
                         #check motorola signal (starbit is least significant bit):
                         maxBit = sig.getLsbStartbit()
                 frame._Size = math.ceil(maxBit / 8)

canmatrix/compare.py

@@ -254,18 +254,18 @@ def compareSignal(s1,s2, ignore = None):
         result.addChild(compareResult("changed", "startbit", s1, [" %d" % s1._startbit, " %d" % s2._startbit]))
     if s1._signalsize != s2._signalsize:
         result.addChild(compareResult("changed", "signalsize", s1, [" %d" % s1._signalsize, " %d" % s2._signalsize]))
-    if s1._factor != s2._factor:
+    if float(s1._factor) != float(s2._factor):
         result.addChild(compareResult("changed", "factor", s1, [s1._factor, s2._factor]))
-    if s1._offset != s2._offset:
+    if float(s1._offset) != float(s2._offset):
         result.addChild(compareResult("changed", "offset", s1, [ s1._offset, s2._offset]))
-    if s1._min != s2._min:
+    if float(s1._min) != float(s2._min):
         result.addChild(compareResult("changed", "min", s1, [ s1._min, s2._min]))
-    if s1._max != s2._max:
+    if float(s1._max) != float(s2._max):
         result.addChild(compareResult("changed", "max", s1, [ s1._max,  s2._max]))
-    if s1._byteorder != s2._byteorder:
-        result.addChild(compareResult("changed", "byteorder", s1, [" %d" % s1._byteorder, " %d" % s2._byteorder]))
-    if s1._valuetype != s2._valuetype:
-        result.addChild(compareResult("changed", "valuetype", s1, [" %s" % s1._valuetype, " %s" % s2._valuetype]))
+    if s1._is_little_endian != s2._is_little_endian:
+        result.addChild(compareResult("changed", "is_little_endian", s1, [" %d" % s1._is_little_endian, " %d" % s2._is_little_endian]))
+    if s1._is_signed != s2._is_signed:
+        result.addChild(compareResult("changed", "sign", s1, [" %d" % s1._is_signed, " %d" % s2._is_signed]))
     if s1._multiplex != s2._multiplex:
         result.addChild(compareResult("changed", "multiplex", s1, [str(s1._multiplex), str(s2._multiplex)]))
     if s1._unit != s2._unit:
@@ -343,11 +343,11 @@ def main():
     import canmatrix.importany as im
 
     logger.info("Importing " + matrix1 + " ... ")
-    db1 = im.importany(matrix1)
+    db1 = next(iter(im.importany(matrix1).values()))
     logger.info("%d Frames found" % (db1._fl._list.__len__()))
 
     logger.info("Importing " + matrix2 + " ... ")
-    db2 = im.importany(matrix2)
+    db2 = next(iter(im.importany(matrix2).values()))
     logger.info("%d Frames found" % (db2._fl._list.__len__()))
 
     ignore = {}

canmatrix/exportarxml.py

@@ -148,7 +148,7 @@ def exportArxml(db, filename):
             signalToPduMapping = etree.SubElement(signalToPduMappings,'I-SIGNAL-TO-I-PDU-MAPPING')
             createSubElement(signalToPduMapping, 'SHORT-NAME', signal._name)
             createSubElement(signalToPduMapping, 'START-POSITION', str(signal.getMsbStartbit()))
-            if signal._byteorder == 1: # Intel
+            if signal._is_little_endian == 1: # Intel
                 createSubElement(signalToPduMapping, 'PACKING-BYTE-ORDER', 'MOST-SIGNIFICANT-BYTE-LAST')
             else: #Motorola
                 createSubElement(signalToPduMapping, 'PACKING-BYTE-ORDER', 'MOST-SIGNIFICANT-BYTE-FIRST')
@@ -258,8 +258,8 @@ def exportArxml(db, filename):
                 compuScale = etree.SubElement(compuScales,'COMPU-SCALE')
                 compuRationslCoeff = etree.SubElement(compuScale,'COMPU-RATIONAL-COEFFS')
                 compuNumerator = etree.SubElement(compuRationslCoeff,'COMPU-NUMERATOR')
-                createSubElement(compuNumerator, 'V', signal._offset)
-                createSubElement(compuNumerator, 'V', signal._factor)
+                createSubElement(compuNumerator, 'V', "%g" % signal._offset)
+                createSubElement(compuNumerator, 'V', "%g" % signal._factor)
                 compuDenomiator = etree.SubElement(compuRationslCoeff,'COMPU-DENOMINATOR')
                 createSubElement(compuDenomiator, 'V', "1")
 

canmatrix/exportcsv.py

@@ -159,7 +159,7 @@ def writeSignalx(db, sig, row, rearCol):
         row[11] = sig._attributes["GenSigSNA"][1:-1]
 
     # eval byteorder (intel == 1 / motorola == 0)
-    if sig._byteorder == 1:
+    if sig._is_little_endian == True:
         row[12] = "i"
     else:
         row[12] = "m"
@@ -255,7 +255,7 @@ def exportCsv(db, filename, delimiter=','):
                 writeSignalx(db, sig, signalRow, col)
 
                 if float(sig._min) != 0 or float(sig._max) != 1.0:
-                    signalRow[col+1] = str("%s..%s" %(sig._min, sig._max))
+                    signalRow[col+1] = str("%g..%g" %(sig._min, sig._max))
 
                 # next row
                 row += 1

canmatrix/exportdbc.py

@@ -100,9 +100,13 @@ def exportDbc(db, filename, **options):
 
             startbit = signal.getMsbStartbit()
 
-            f.write((" : %d|%d@%d%c" % (startbit, signal._signalsize,signal._byteorder, signal._valuetype)).encode(dbcExportEncoding))
-            f.write((" (%s,%s)" % (signal._factor, signal._offset)).encode(dbcExportEncoding))
-            f.write((" [%s|%s]" % (signal._min, signal._max)).encode(dbcExportEncoding))
+            if signal._is_signed:            
+                sign = '-'
+            else:
+                sign = '+'             
+            f.write((" : %d|%d@%d%c" % (startbit, signal._signalsize,signal._is_little_endian, sign)).encode(dbcExportEncoding))
+            f.write((" (%g,%g)" % (signal._factor, signal._offset)).encode(dbcExportEncoding))
+            f.write((" [%g|%g]" % (signal._min, signal._max)).encode(dbcExportEncoding))
             f.write(' "'.encode(dbcExportEncoding))
 
             f.write(signal._unit.encode(dbcExportEncoding))

canmatrix/exportdbf.py

@@ -73,11 +73,11 @@ def exportDbf(db, filename, **options):
             whichbyte = int(math.floor(signal.getLsbStartbit() / 8) +1 )
             sign = 'S'
 
-            if signal._valuetype == '+':
+            if not signal._is_signed:
                 sign = 'U'
-            outstr += "[START_SIGNALS] " + signal._name + ",%d,%d,%d,%c,%s,%s" % (signal._signalsize,whichbyte,int(signal.getLsbStartbit())%8,sign,float(signal._max)/float(signal._factor),float(signal._min)/float(signal._factor))
+            outstr += "[START_SIGNALS] " + signal._name + ",%d,%d,%d,%c,%g,%g" % (signal._signalsize,whichbyte,int(signal.getLsbStartbit())%8,sign,float(signal._max)/float(signal._factor),float(signal._min)/float(signal._factor))
 
-            outstr += ",%d,%s,%s" % (signal._byteorder, signal._offset, signal._factor)
+            outstr += ",%d,%s,%s" % (signal._is_little_endian, signal._offset, signal._factor)
             multiplex = ""
             if signal._multiplex is not None:
                 if signal._multiplex == 'Multiplexor':

canmatrix/exportjson.py

@@ -62,8 +62,8 @@ def exportJson(db, filename, **options):
                     "bit_length" : signal._signalsize,
                     "factor":float(signal._factor),
                     "offset":float(signal._offset),
-                    "is_big_endian":signal._byteorder == 0,
-                    "is_signed":signal._valuetype == "-"
+                    "is_big_endian":signal._is_little_endian == 0,
+                    "is_signed":signal._is_signed
                 })
             exportArray.append({"name" : frame._name, "id" : int(frame._Id), "is_extended_frame": frame._extended == 1,"signals": signals })
 

canmatrix/exportkcd.py

@@ -34,7 +34,7 @@ def createSignal(signal, nodeList):
     sig = etree.Element('Signal', name=signal._name, offset=str(signal.getLsbStartbit()))
     if signal._signalsize > 1:
         sig.set("length", str(signal._signalsize))
-    if signal._byteorder == 0:
+    if signal._is_little_endian == 0:
         sig.set('endianess',"little")
 
     notes = etree.Element('Notes')
@@ -43,14 +43,19 @@ def createSignal(signal, nodeList):
     sig.append(notes)
 
     value = etree.Element('Value')
+    if signal._is_signed:
+        value.set('type',"signed")
+    else:
+        value.set('type',"unsigned")
+
     if float(signal._factor) != 1:
-        value.set('slope',str(signal._factor))
+        value.set('slope',str("%g" % signal._factor))
     if float(signal._offset) != 0:
-        value.set('intercept',str(signal._offset))
+        value.set('intercept',str("%g" % signal._offset))
     if float(signal._min) != 0:
-        value.set('min',str(signal._min))
+        value.set('min',str("%g" % signal._min))
     if float(signal._max) != 1:
-        value.set('max',str(signal._max))
+        value.set('max',str("%g" % signal._max))
     if len(signal._unit) > 0:
         value.set('unit',signal._unit)
     sig.append(value)
@@ -142,9 +147,9 @@ def exportKcd(db, filename):
                 multiplexor = etree.Element('Multiplex', name=signal._name, offset=str(signal.getLsbStartbit()), length=str(int(signal._signalsize)))
                 value = etree.Element('Value')
                 if float(signal._min) != 0:
-                    value.set('min',str(signal._min))
+                    value.set('min', "%g" % signal._min)
                 if float(signal._max) != 1:
-                    value.set('max',str(signal._max))
+                    value.set('max', "%g" % signal._max)
                 multiplexor.append(value)
                 labelset = etree.Element('LabelSet')
                 for valueVal,valName in sorted(signal._values.items(), key=lambda x: int(x[0])):