make SOME/IP at least work a bixt #283

Author: ebroecker

src/canmatrix/canmatrix.py

@@ -836,7 +836,8 @@ class Frame(object):
     # ('sendType', '_sendType', str, None),
 
     pdus = attr.ib(factory=list)  # type: typing.MutableSequence[Pdu]
-
+    header_id = attr.ib(default=None)  #type: int
+    # header_id
 
     @property
     def is_multiplexed(self):  # type: () -> bool
@@ -1501,6 +1502,12 @@ def update(self):  # type: () -> None
             return
         self.definition = 'ENUM "' + '","' .join(self.values) +'"'
 
+import enum
+
+class matrix_class(enum.Enum):
+    CAN = 1
+    FLEXRAY = 2
+    SOMEIP = 3
 
 @attr.s(cmp=False)
 class CanMatrix(object):
@@ -1516,6 +1523,7 @@ class CanMatrix(object):
     value_tables (global defined values)
     """
 
+    type = attr.ib(default=matrix_class.CAN)  #type: matrix_class
     attributes = attr.ib(factory=dict)  # type: typing.MutableMapping[str, typing.Any]
     ecus = attr.ib(factory=list)  # type: typing.MutableSequence[Ecu]
     frames = attr.ib(factory=list)  # type: typing.MutableSequence[Frame]

src/canmatrix/formats/arxml.py

@@ -1107,7 +1107,7 @@ def get_signals(signal_array, frame, ea, multiplex_id, float_factory, bit_offset
         if compu_method is None and datdefprops is not None:
             compu_method = ea.follow_ref(datdefprops, "COMPU-METHOD-REF")
         if compu_method is None:  # AR4
-            compu_method = ea.get_child(isignal, "COMPU-METHOD")
+            compu_method = ea.follow_ref(isignal, "COMPU-METHOD-REF")
             base_type = ea.follow_ref(isignal, "BASE-TYPE-REF")
             encoding = ea.get_child(base_type, "BASE-TYPE-ENCODING")
             if encoding is not None and encoding.text == "IEEE754":
@@ -1128,7 +1128,7 @@ def get_signals(signal_array, frame, ea, multiplex_id, float_factory, bit_offset
         #####################################################################################################
         if compu_method is None:
             logger.debug('No Compmethod found!! - fuzzy search in syssignal.')
-            compu_method = ea.get_child(system_signal, "COMPU-METHOD")
+            compu_method = ea.follow_ref(system_signal, "COMPU-METHOD-REF")
 
         # decode compuMethod:
         (values, factor, offset, unit_elem, const) = decode_compu_method(compu_method, ea, float_factory)
@@ -1664,25 +1664,51 @@ def extract_cm_from_ecuc(com_module, ea):
 
 def decode_ethernet_helper(ea, float_factory):
     found_matrixes = {}
+
+    socket_connetions = ea.findall("SOCKET-CONNECTION-IPDU-IDENTIFIER")
+    pdu_triggering_header_id_map = {}
+    # network_endpoints = pc.findall('.//' + ns + "NETWORK-ENDPOINT")
+    for socket_connetion in socket_connetions:
+        header_id = ea.get_child(socket_connetion, "HEADER-ID")
+        ipdu_triggering = ea.follow_ref(socket_connetion, "PDU-TRIGGERING-REF")
+        try:
+            pdu_triggering_header_id_map[ipdu_triggering] = header_id.text
+        except:
+            pass
+
+
     ecs = ea.findall('ETHERNET-CLUSTER')
     for ec in ecs:
         baudrate_elem = ea.find("BAUDRATE", ec)
         physical_channels = ea.findall("ETHERNET-PHYSICAL-CHANNEL", ec)
         for pc in physical_channels:
-            db = canmatrix.CanMatrix()
+            db = canmatrix.CanMatrix(type=canmatrix.matrix_class.SOMEIP)
             db.baudrate = baudrate_elem.text if baudrate_elem is not None else 0
             db.add_signal_defines("LongName", 'STRING')
             channel_name = ea.get_element_name(pc)
             found_matrixes[channel_name] = db
-            ipdu_triggerings = ea.findall("PDU-TRIGGERING", pc)
 
-            #network_endpoints = pc.findall('.//' + ns + "NETWORK-ENDPOINT")
-            for ipdu_triggering in ipdu_triggerings:
+            for socket_connetion in ea.findall("SOCKET-CONNECTION-IPDU-IDENTIFIER", pc):
+                header_id = ea.get_child(socket_connetion, "HEADER-ID")
+                ipdu_triggering = ea.follow_ref(socket_connetion, "PDU-TRIGGERING-REF")
+#            for ipdu_triggering in ea.findall("PDU-TRIGGERING", pc):
                 ipdu = ea.follow_ref(ipdu_triggering, "I-PDU-REF")
+                if ipdu is not None and 'SECURED-I-PDU' in ipdu.tag:
+                    payload = ea.follow_ref(ipdu, "PAYLOAD-REF")
+                    ipdu = ea.follow_ref(payload, "I-PDU-REF")
+
                 ipdu_name = ea.get_element_name(ipdu)
                 logger.info("ETH PDU " + ipdu_name + " found")
                 target_frame = canmatrix.Frame(name = ipdu_name)
-                pdu_sig_mapping = ea.follow_all_ref(ipdu, "I-SIGNAL-TO-I-PDU-MAPPING-REF")
+                try:
+                    target_frame.header_id = int(header_id.text)
+                except:
+                    try:
+                        target_frame.header_id = int(pdu_triggering_header_id_map[ipdu_triggering])
+                    except:
+                        target_frame.header_id = 0
+#                    continue
+                pdu_sig_mapping = ea.findall("I-SIGNAL-TO-I-PDU-MAPPING", ipdu)
                 get_signals(pdu_sig_mapping, target_frame, ea, None, float_factory)
                 db.add_frame(target_frame)
     return found_matrixes

src/canmatrix/formats/xls.py

@@ -172,16 +172,22 @@ def dump(db, file, **options):
     worksheet.col(head_start + 1).width = 5555
 
     frame_hash = {}
-    logger.debug("Length of db.frames is %d", len(db.frames))
-    for frame in db.frames:
-        if frame.is_complex_multiplexed:
-            logger.error("export complex multiplexers is not supported - ignoring frame %s", frame.name)
-            continue
-        frame_hash[int(frame.arbitration_id.id)] = frame
+    if db.type == canmatrix.matrix_class.CAN:
+        logger.debug("Length of db.frames is %d", len(db.frames))
+        for frame in db.frames:
+            if frame.is_complex_multiplexed:
+                logger.error("export complex multiplexers is not supported - ignoring frame %s", frame.name)
+                continue
+            frame_hash[int(frame.arbitration_id.id)] = frame
+    else:
+        frame_hash = {a.name:a for a in db.frames}
+
 
     # set row to first Frame (row = 0 is header)
     row = 1
 
+
+
     # iterate over the frames
     for idx in sorted(frame_hash.keys()):
 

src/canmatrix/formats/xls_common.py

@@ -30,11 +30,18 @@
 def get_frame_info(db, frame):
     # type: (canmatrix.CanMatrix, canmatrix.Frame) -> typing.List[str]
     ret_array = []  # type: typing.List[str]
-    # frame-id
-    if frame.arbitration_id.extended:
-        ret_array.append("%3Xxh" % frame.arbitration_id.id)
-    else:
-        ret_array.append("%3Xh" % frame.arbitration_id.id)
+
+    if db.type == canmatrix.matrix_class.CAN:
+        # frame-id
+        if frame.arbitration_id.extended:
+            ret_array.append("%3Xxh" % frame.arbitration_id.id)
+        else:
+            ret_array.append("%3Xh" % frame.arbitration_id.id)
+    elif db.type == canmatrix.matrix_class.FLEXRAY:
+        ret_array.append("TODO")
+    elif db.type == canmatrix.matrix_class.SOMEIP:
+        ret_array.append("%3Xh" % frame.header_id)
+
     # frame-Name
     ret_array.append(frame.name)
 

src/canmatrix/formats/xlsx.py

@@ -195,12 +195,15 @@ def dump(db, filename, **options):
 
     write_excel_line(worksheet, 0, 0, row_array, sty_header)
 
-    frame_hash = {}
-    logger.debug("DEBUG: Length of db.frames is %d", len(db.frames))
-    for frame in db.frames:
-        if frame.is_complex_multiplexed:
-            logger.error("Export complex multiplexers is not supported - frame %s might be uncomplete", frame.name)
-        frame_hash[int(frame.arbitration_id.id)] = frame
+    if db.type == canmatrix.matrix_class.CAN:
+        frame_hash = {}
+        logger.debug("DEBUG: Length of db.frames is %d", len(db.frames))
+        for frame in db.frames:
+            if frame.is_complex_multiplexed:
+                logger.error("Export complex multiplexers is not supported - frame %s might be uncomplete", frame.name)
+            frame_hash[int(frame.arbitration_id.id)] = frame
+    else:
+        frame_hash = {a.name:a for a in db.frames}
 
     # set row to first Frame (row = 0 is header)
     row = 1