from configparser import ConfigParser import json import xml.etree.ElementTree as ET import time # root = ET.parse("FRNEW.arxml").getroot() DB_MASK_CAN = 1 DB_MASK_FLEXRAY = 2 DB_MASK_LIN = 4 DB_MASK_ETHERNET = 8 def detect_arxml_type(ArxmlName:str)->int: arxml_type = 0 root = ET.parse(ArxmlName).getroot() startidx = root.tag.find('{') endidx = root.tag.find('}') ns = root.tag[startidx:endidx+1] for CCAN in root.iter(ns+'CAN-CLUSTER'): arxml_type |= DB_MASK_CAN break for CLIN in root.iter(ns+'LIN-CLUSTER'): arxml_type |= DB_MASK_LIN break for CFR in root.iter(ns+'FLEXRAY-CLUSTER'): arxml_type |= DB_MASK_FLEXRAY break for CETH in root.iter(ns+'ETHERNET-CLUSTER'): arxml_type |= DB_MASK_ETHERNET break return arxml_type def calc_real_startbit(startbit:int, bitlen:int): startbit ^= 7 startbit += bitlen - 1 startbit ^= 7 return startbit class TSArxml: def __init__(self, arxmlname,outputPath): self.arxmlname = arxmlname self.outputPath = outputPath self.root = ET.parse(self.arxmlname).getroot() startidx = self.root.tag.find('{') endidx = self.root.tag.find('}') self.ns = self.root.tag[startidx:endidx+1] self.PACKAGES = f'{self.ns}AR-PACKAGES/{self.ns}AR-PACKAGE' self.ELEMENTS = f'{self.ns}ELEMENTS' self.UNIT = f'{self.ns}UNIT' self.SW_BASE_TYPE = f'{self.ns}SW-BASE-TYPE' self.IMPLEMENTATION_DATA_TYPE = f'{self.ns}IMPLEMENTATION-DATA-TYPE' self.COMPU_METHOD = f'{self.ns}COMPU-METHOD' self.DATA_CONSTR = f'{self.ns}DATA-CONSTR' self.APPLICATION_PRIMITIVE_DATA_TYPE = f'{self.ns}APPLICATION-PRIMITIVE-DATA-TYPE' self.DATA_TYPE_MAPPING_SET = f'{self.ns}DATA-TYPE-MAPPING-SET' self.SYSTEM_SIGNAL = f'{self.ns}SYSTEM-SIGNAL' self.SYSTEM_SIGNAL_GROUP = f'{self.ns}SYSTEM-SIGNAL-GROUP' self.ECU_INSTANCE = f'{self.ns}ECU-INSTANCE' self.I_SIGNAL_I_PDU = f'{self.ns}I-SIGNAL-I-PDU' self.I_SIGNAL = f'{self.ns}I-SIGNAL' self.DATA_TRANSFORMATION_SET = f'{self.ns}DATA-TRANSFORMATION-SET' self.I_SIGNAL_GROUP = f'{self.ns}I-SIGNAL-GROUP' self.FLEXRAY_FRAME = f'{self.ns}FLEXRAY-FRAME' self.FLEXRAY_CLUSTER = f'{self.ns}FLEXRAY-CLUSTER' self.NM_CONFIG = f'{self.ns}NM-CONFIG' self.I_SIGNAL_I_PDU_GROUP = f'{self.ns}I-SIGNAL-I-PDU-GROUP' self.FLEXRAY_TP_CONFIG = f'{self.ns}FLEXRAY-TP-CONFIG' self.DIAGNOSTIC_CONNECTION = f'{self.ns}DIAGNOSTIC-CONNECTION' self.GLOBAL_TIME_DOMAIN = f'{self.ns}GLOBAL-TIME-DOMAIN' self.SYSTEM = f'{self.ns}SYSTEM' self.CONTAINER_I_PDU = f'{self.ns}CONTAINER-I-PDU' self.arxml_dict = { f'{self.ns}UNIT':[], f'{self.ns}SW-BASE-TYPE':[], f'{self.ns}IMPLEMENTATION-DATA-TYPE':[], f'{self.ns}COMPU-METHOD':[], f'{self.ns}DATA-CONSTR':[], f'{self.ns}APPLICATION-PRIMITIVE-DATA-TYPE':[], f'{self.ns}APPLICATION-ARRAY-DATA-TYPE':[], f'{self.ns}DATA-TYPE-MAPPING-SET':[], f'{self.ns}SYSTEM-SIGNAL':[], f'{self.ns}SYSTEM-SIGNAL-GROUP':[], f'{self.ns}I-SIGNAL-I-PDU':[], f'{self.ns}N-PDU':[], f'{self.ns}GENERAL-PURPOSE-PDU':[], f'{self.ns}NM-PDU':[], f'{self.ns}GENERAL-PURPOSE-I-PDU':[], f'{self.ns}MULTIPLEXED-I-PDU':[], f'{self.ns}SECURED-I-PDU':[], f'{self.ns}DCM-I-PDU':[], f'{self.ns}CONTAINER-I-PDU':[], f'{self.ns}I-SIGNAL':[], f'{self.ns}FLEXRAY-FRAME':[], f'{self.ns}DATA-TRANSFORMATION-SET':[], f'{self.ns}I-SIGNAL-GROUP':[], f'{self.ns}ECU-INSTANCE':[], f'{self.ns}FLEXRAY-CLUSTER':[], f'{self.ns}NM-CONFIG':[], f'{self.ns}I-SIGNAL-I-PDU-GROUP':[], f'{self.ns}FLEXRAY-TP-CONFIG':[], f'{self.ns}DIAGNOSTIC-CONNECTION':[], f'{self.ns}GLOBAL-TIME-DOMAIN':[], f'{self.ns}SYSTEM':[], } self.unit_Table = {} self.sw_base_type_Table = {} self.implementation_data_type_Table = {} self.compu_method_Table = {} self.data_constr_Table = {} self.application_primitive_data_type_Table = {} self.application_array_data_type_Table = {} self.data_type_mapping_set_Table = {} self.system_signal_Table = {} self.system_signal_group_Table = {} self.ecu_instance_Table = {} self.i_signal_i_pdu_Table = {} self.n_pdu_Table = {} self.general_purpose_pdu_Table = {} self.nm_pdu_Table = {} self.general_purpose_i_pdu_Table = {} self.multiplexed_i_pdu_Table = {} self.secured_i_pdu_Table = {} self.dcm_i_pdu_Table = {} self.container_i_pdu_Table = {} self.i_signal_Table = {} self.data_transformation_set_Table = {} self.i_signal_group_Table = {} self.flexray_frame_Table = {} self.FRFrameTable = {} self.FRPDUTable = {} self.FRSignalTable = {} self.flexray_cluster_Table = {} self.nm_config_Table = {} self.i_signal_i_pdu_group_Table = {} self.flexray_tp_config_Table = {} self.diagnostic_connection_Table = {} self.global_time_domain_Table = {} self.system_Table = {} self.container_i_pdu_Table = {} self.NodelistMsg = {} self.channelList = [] self.CONNECTORS = {} self.INFO = {} self.DBCount = 0 self.get_package(self.root) self.parse_db() def get_package(self,root): for packs_root in root: for package in packs_root.iter(self.ELEMENTS): for idx in range(len(package)): if package[idx].tag in self.arxml_dict: self.arxml_dict[package[idx].tag].append(package[idx]) def parse_db(self): # signal for key in self.arxml_dict: if key == self.I_SIGNAL: for Signal in self.arxml_dict[key]: SignalName = Signal.find(f"{self.ns}SHORT-NAME").text self.i_signal_Table[SignalName] = {} self.i_signal_Table[SignalName]["id"] = SignalName self.i_signal_Table[SignalName]["short_name"] = SignalName if SysSignal.find(f"{self.ns}DESC") != None and len(SysSignal.find(f"{self.ns}DESC"))!=0: self.i_signal_Table[SignalName]['description'] = SysSignal.find(f"{self.ns}DESC")[0].text else: self.i_signal_Table[SignalName]['description'] = None self.i_signal_Table[SignalName]["signaltype"] = Signal.find(f"{self.ns}DATA-TYPE-POLICY").text self.i_signal_Table[SignalName]["bit_length"] = int(Signal.find(f"{self.ns}LENGTH").text) self.i_signal_Table[SignalName]["defaultvalue"] = int(Signal.find(f"{self.ns}INIT-VALUE/{self.ns}NUMERICAL-VALUE-SPECIFICATION/{self.ns}VALUE").text) if Signal.find(f"{self.ns}INIT-VALUE/{self.ns}NUMERICAL-VALUE-SPECIFICATION/{self.ns}VALUE") != None else 0 self.i_signal_Table[SignalName]["BASE-TYPE-REF"] = Signal.find(f"{self.ns}NETWORK-REPRESENTATION-PROPS/{self.ns}SW-DATA-DEF-PROPS-VARIANTS/{self.ns}SW-DATA-DEF-PROPS-CONDITIONAL/{self.ns}BASE-TYPE-REF").text.split('/')[-1] if Signal.find(f"{self.ns}NETWORK-REPRESENTATION-PROPS/{self.ns}SW-DATA-DEF-PROPS-VARIANTS/{self.ns}SW-DATA-DEF-PROPS-CONDITIONAL/{self.ns}BASE-TYPE-REF")!=None else '' self.i_signal_Table[SignalName]["coded_type"] = self.i_signal_Table[SignalName]["BASE-TYPE-REF"] # self.i_signal_Table[SignalName]["BASE-TYPE-REF"] = Signal.find(f"{self.ns}NETWORK-REPRESENTATION-PROPS/{self.ns}SW-DATA-DEF-PROPS-VARIANTS/{self.ns}SW-DATA-DEF-PROPS-CONDITIONAL/{self.ns}BASE-TYPE-REF").text if Signal.find(f"{self.ns}NETWORK-REPRESENTATION-PROPS/{self.ns}SW-DATA-DEF-PROPS-VARIANTS/{self.ns}SW-DATA-DEF-PROPS-CONDITIONAL/{self.ns}BASE-TYPE-REF")!=None else '' self.i_signal_Table[SignalName]["BASE-TYPE-REF-DEST"] = Signal.find(f"{self.ns}NETWORK-REPRESENTATION-PROPS/{self.ns}SW-DATA-DEF-PROPS-VARIANTS/{self.ns}SW-DATA-DEF-PROPS-CONDITIONAL/{self.ns}BASE-TYPE-REF").attrib['DEST'] if (Signal.find(f"{self.ns}NETWORK-REPRESENTATION-PROPS/{self.ns}SW-DATA-DEF-PROPS-VARIANTS/{self.ns}SW-DATA-DEF-PROPS-CONDITIONAL/{self.ns}BASE-TYPE-REF")!=None and 'DEST' in Signal.find(f"{self.ns}NETWORK-REPRESENTATION-PROPS/{self.ns}SW-DATA-DEF-PROPS-VARIANTS/{self.ns}SW-DATA-DEF-PROPS-CONDITIONAL/{self.ns}BASE-TYPE-REF").attrib['DEST']) else '' self.i_signal_Table[SignalName]['attributes'] = '' self.i_signal_Table[SignalName]['encoding'] = "UNSIGNED" self.i_signal_Table[SignalName]['category'] = '' self.i_signal_Table[SignalName]["texttable"] = [] self.i_signal_Table[SignalName]["SYSTEM-SIGNAL-REF"] = Signal.find(f"{self.ns}SYSTEM-SIGNAL-REF").text.split("/")[-1] if Signal.find(f"{self.ns}SYSTEM-SIGNAL-REF")!=None else None if self.i_signal_Table[SignalName]["SYSTEM-SIGNAL-REF"] in self.system_signal_Table and 'COMPU-METHOD-REF' in self.system_signal_Table[self.i_signal_Table[SignalName]["SYSTEM-SIGNAL-REF"]]: self.i_signal_Table[SignalName]['offset'] = self.compu_method_Table[self.system_signal_Table[self.i_signal_Table[SignalName]["SYSTEM-SIGNAL-REF"]]['COMPU-METHOD-REF']]['offset'] self.i_signal_Table[SignalName]['factor'] = self.compu_method_Table[self.system_signal_Table[self.i_signal_Table[SignalName]["SYSTEM-SIGNAL-REF"]]['COMPU-METHOD-REF']]['factor'] self.i_signal_Table[SignalName]['compu_category'] = self.compu_method_Table[self.system_signal_Table[self.i_signal_Table[SignalName]["SYSTEM-SIGNAL-REF"]]['COMPU-METHOD-REF']]['CATEGORY'] self.i_signal_Table[SignalName]['compu_category2'] = '' if self.i_signal_Table[SignalName]['compu_category']!=None and self.i_signal_Table[SignalName]['compu_category'].find("TEXTTABLE") != -1: self.i_signal_Table[SignalName]["texttable"] = self.compu_method_Table[self.system_signal_Table[self.i_signal_Table[SignalName]["SYSTEM-SIGNAL-REF"]]['COMPU-METHOD-REF']]['TextTable'] if self.compu_method_Table[self.system_signal_Table[self.i_signal_Table[SignalName]["SYSTEM-SIGNAL-REF"]]['COMPU-METHOD-REF']]['UNIT-REF'] in self.unit_Table: self.i_signal_Table[SignalName]['unit'] = self.unit_Table[self.compu_method_Table[self.system_signal_Table[self.i_signal_Table[SignalName]["SYSTEM-SIGNAL-REF"]]['COMPU-METHOD-REF']]['UNIT-REF']]['DisPaly'] else: self.i_signal_Table[SignalName]['unit'] = '' else: self.i_signal_Table[SignalName]['offset'] = 0.0 self.i_signal_Table[SignalName]['factor'] = 1.0 self.i_signal_Table[SignalName]['unit'] = '' self.i_signal_Table[SignalName]['compu_category'] = 'LINEAR' self.i_signal_Table[SignalName]['compu_category2'] = '' self.i_signal_Table[SignalName]['lowerlimit'] = self.i_signal_Table[SignalName]['offset'] self.i_signal_Table[SignalName]['upperlimit'] = ((1 << self.i_signal_Table[SignalName]['bit_length']) - 1) * self.i_signal_Table[SignalName]['factor'] + self.i_signal_Table[SignalName]['offset'] self.i_signal_Table[SignalName]['method'] = '' elif key == self.SYSTEM_SIGNAL: for SysSignal in self.arxml_dict[key]: SysSignalName = SysSignal.find(f"{self.ns}SHORT-NAME").text self.system_signal_Table[SysSignalName] = {} self.system_signal_Table[SysSignalName]['id'] = SysSignalName if SysSignal.find(f"{self.ns}DESC") != None and len(SysSignal.find(f"{self.ns}DESC"))!=0: self.system_signal_Table[SysSignalName]['description'] = SysSignal.find(f"{self.ns}DESC")[0].text else: self.system_signal_Table[SysSignalName]['description'] = None self.system_signal_Table[SysSignalName]['DYNAMIC-LENGTH'] = SysSignal.find(f"{self.ns}DYNAMIC-LENGTH").text if SysSignal.find(f"{self.ns}DYNAMIC-LENGTH")!=None else '' for DataPROPS in SysSignal.iter(f'{self.ns}SW-DATA-DEF-PROPS-CONDITIONAL'): for DataPROPidx in range(len(DataPROPS)): self.system_signal_Table[SysSignalName][DataPROPS[DataPROPidx].tag.split("}")[1]] = DataPROPS[DataPROPidx].text.split("/")[-1] self.system_signal_Table[SysSignalName][DataPROPS[DataPROPidx].tag.split("}")[1] + "-DEST"] = DataPROPS[DataPROPidx].attrib['DEST'] elif key == self.I_SIGNAL_I_PDU: for pdu in self.arxml_dict[key]: PDUName = pdu.find(f"{self.ns}SHORT-NAME").text self.i_signal_i_pdu_Table[PDUName] = {} self.i_signal_i_pdu_Table[PDUName]["id"] = PDUName self.i_signal_i_pdu_Table[PDUName]["short_name"] = PDUName self.i_signal_i_pdu_Table[PDUName]["byte_length"] = int(pdu.find(f"{self.ns}LENGTH").text) self.i_signal_i_pdu_Table[PDUName]["pdu_type"] = '' self.i_signal_i_pdu_Table[PDUName]["I-SIGNAL-GROUPS"] = [] for ISignalGroup in pdu.iter(f"{self.ns}I-SIGNAL-GROUP-REF"): Sig_Group = {} Sig_Group["I-SIGNAL-GROUP-REF"] = ISignalGroup.text.split("/")[-1] Sig_Group["I-SIGNAL-GROUP-REF-DEST"] = ISignalGroup.attrib['DEST'] self.i_signal_i_pdu_Table[PDUName]["I-SIGNAL-GROUPS"].append(Sig_Group) del Sig_Group for ISignalGroup in pdu.iter(f"{self.ns}SYSTEM-SIGNAL-GROUP-REF"): self.i_signal_i_pdu_Table[PDUName]["SYSTEM-SIGNAL-GROUP-REF"] = ISignalGroup.text self.i_signal_i_pdu_Table[PDUName]["SYSTEM-SIGNAL-GROUP-REF-DEST"] = ISignalGroup.attrib['DEST'] else: self.i_signal_i_pdu_Table[PDUName]["SYSTEM-SIGNAL-GROUP-REF"] = None self.i_signal_i_pdu_Table[PDUName]["SYSTEM-SIGNAL-GROUP-REF-DEST"] = None if pdu.find(f"{self.ns}DESC") != None and len(pdu.find(f"{self.ns}DESC"))!=0: self.i_signal_i_pdu_Table[PDUName]['description'] = pdu.find(f"{self.ns}DESC")[0].text else: self.i_signal_i_pdu_Table[PDUName]['description'] = None self.i_signal_i_pdu_Table[PDUName]["signals"] = [] I_PDU_MAPPINGs = pdu.findall(f"{self.ns}I-SIGNAL-TO-PDU-MAPPINGS/{self.ns}I-SIGNAL-TO-I-PDU-MAPPING") for I_PDU_MAPPING in I_PDU_MAPPINGs: i_pdu = {} SignalName = I_PDU_MAPPING.find(f"{self.ns}SHORT-NAME").text i_pdu["id"] = SignalName if I_PDU_MAPPING.find(f"{self.ns}I-SIGNAL-REF")!=None: i_pdu["I-SIGNAL-REF"] = I_PDU_MAPPING.find(f"{self.ns}I-SIGNAL-REF").text i_pdu["reference_signal_id"] = i_pdu["I-SIGNAL-REF"].split('/')[-1] i_pdu["I-SIGNAL-REF-DEST"] = I_PDU_MAPPING.find(f"{self.ns}I-SIGNAL-REF").attrib['DEST'] else: continue i_pdu["is_motorola"] = True if I_PDU_MAPPING.find(f"{self.ns}PACKING-BYTE-ORDER").text == 'MOST-SIGNIFICANT-BYTE-FIRST' else False i_pdu["start_bit"] = int(I_PDU_MAPPING.find(f"{self.ns}START-POSITION").text) if I_PDU_MAPPING.find(f"{self.ns}START-POSITION")!=None else None i_pdu["update_bit_position"] = -1 self.i_signal_i_pdu_Table[PDUName]["signals"].append(i_pdu) del i_pdu elif key == self.FLEXRAY_FRAME: for FRFrame in self.arxml_dict[key]: FRName = FRFrame.find(f"{self.ns}SHORT-NAME").text self.flexray_frame_Table[FRName] = {} self.flexray_frame_Table[FRName]["id"] = FRName self.flexray_frame_Table[FRName]["short_name"] = FRName # if FRName not in channelListFrame: # continue if FRFrame.find(f"{self.ns}DESC") != None and len(FRFrame.find(f"{self.ns}DESC"))!=0: self.flexray_frame_Table[FRName]['description'] = FRFrame.find(f"{self.ns}DESC")[0].text else: self.flexray_frame_Table[FRName]['description'] = None self.flexray_frame_Table[FRName]["byte_length"] = int(FRFrame.find(f"{self.ns}FRAME-LENGTH").text) if self.flexray_frame_Table[FRName]["byte_length"] % 2 == 1: self.flexray_frame_Table[FRName]["byte_length"] += 1 PDUMaps = FRFrame.findall(f"{self.ns}PDU-TO-FRAME-MAPPINGS/{self.ns}PDU-TO-FRAME-MAPPING") self.flexray_frame_Table[FRName]["frame_type"] = '' self.flexray_frame_Table[FRName]["pdus"] = [] self.flexray_frame_Table[FRName]["signals"] = [] for PDUMap in PDUMaps: pdu_frame = {} PDUName = PDUMap.find(f"{self.ns}SHORT-NAME").text pdu_frame["id"] = PDUName pdu_frame["short_name"] = PDUName pdu_frame['bit_position'] = int(PDUMap.find(f"{self.ns}START-POSITION").text) if PDUMap.find(f"{self.ns}START-POSITION") != None else None pdu_frame["is_motorola"] = True if PDUMap.find(f"{self.ns}PACKING-BYTE-ORDER").text == 'MOST-SIGNIFICANT-BYTE-FIRST' else False if PDUMap.find(f"{self.ns}PDU-REF")!=None: pdu_frame['reference_pdu_id'] = PDUMap.find(f"{self.ns}PDU-REF").text.split('/')[-1] pdu_frame['reference_pdu_id-DEST'] = PDUMap.find(f"{self.ns}PDU-REF").attrib['DEST'] if pdu_frame['is_motorola']: if pdu_frame['reference_pdu_id'] in self.i_signal_i_pdu_Table: pdu_frame['bit_position'] = calc_real_startbit(pdu_frame['bit_position'],self.i_signal_i_pdu_Table[pdu_frame['reference_pdu_id']]["byte_length"]*8) if pdu_frame['reference_pdu_id-DEST'] == 'I-SIGNAL-I-PDU': self.flexray_frame_Table[FRName]["pdus"].append(pdu_frame) del pdu_frame elif key == self.I_SIGNAL_GROUP: for Sig_Group in self.arxml_dict[key]: SigGroupName = Sig_Group.find(f"{self.ns}SHORT-NAME").text self.i_signal_group_Table[SigGroupName] = {} self.i_signal_group_Table[SigGroupName]["id"] = SigGroupName if Sig_Group.find(f"{self.ns}DESC") != None and len(Sig_Group.find(f"{self.ns}DESC"))!=0: self.i_signal_group_Table[SigGroupName]['description'] = Sig_Group.find(f"{self.ns}DESC")[0].text else: self.i_signal_group_Table[SigGroupName]['description'] = None self.i_signal_group_Table[SigGroupName]['ISignals'] = [] self.i_signal_group_Table[SigGroupName]['SysSignalGroup'] = [] self.i_signal_group_Table[SigGroupName]['TRANSFORMER-REF'] = [] self.i_signal_group_Table[SigGroupName]['DataID'] = [] self.i_signal_group_Table[SigGroupName]['TRANSFORMATION-REF'] = {} for TRANSFORMATION_REF in Sig_Group.iter(f"{self.ns}DATA-TRANSFORMATION-REF"): for Formatidx in TRANSFORMATION_REF: self.i_signal_group_Table[SigGroupName]['TRANSFORMATION-REF'][Formatidx.tag.split("}")[1]] = Formatidx.text self.i_signal_group_Table[SigGroupName]['TRANSFORMATION-REF'][Formatidx.tag.split("}")[1]+"-DEST"] = Formatidx.attrib['DEST'] for Signal_ref in Sig_Group.iter(f"{self.ns}I-SIGNAL-REF"): self.i_signal_group_Table[SigGroupName]['ISignals'].append(Signal_ref.text.split('/')[-1]) for SignalGroup_ref in Sig_Group.iter(f"{self.ns}SYSTEM-SIGNAL-GROUP-REF"): self.i_signal_group_Table[SigGroupName]['SysSignalGroup'].append(SignalGroup_ref.text.split('/')[-1]) for TRANSFORMER_ref in Sig_Group.iter(f"{self.ns}TRANSFORMER-REF"): self.i_signal_group_Table[SigGroupName]['TRANSFORMER-REF'].append(TRANSFORMER_ref.text.split('/')[-1]) for DataID in Sig_Group.iter(f"{self.ns}DATA-ID"): self.i_signal_group_Table[SigGroupName]['DataID'].append(DataID.text) elif key == self.SYSTEM_SIGNAL_GROUP: for SysSigGroup in self.arxml_dict[key]: SysSigGroupName = SysSigGroup.find(f"{self.ns}SHORT-NAME").text self.system_signal_group_Table[SysSigGroupName] = {} self.system_signal_group_Table[SysSigGroupName]["id"] = SysSigGroupName if SysSigGroup.find(f"{self.ns}DESC") != None and len(SysSigGroup.find(f"{self.ns}DESC"))!=0: self.system_signal_group_Table[SysSigGroupName]['description'] = SysSigGroup.find(f"{self.ns}DESC")[0].text else: self.system_signal_group_Table[SysSigGroupName]['description'] = None self.system_signal_group_Table[SysSigGroupName]['SysSignals'] = [] for SysSignal_ref in SysSigGroup.iter(f"{self.ns}SYSTEM-SIGNAL-REF"): self.system_signal_group_Table[SysSigGroupName]['SysSignals'].append(SysSignal_ref.text.split('/')[-1]) elif key == self.CONTAINER_I_PDU: for CONPDU in self.arxml_dict[key]: CONPDUName = CONPDU.find(f"{self.ns}SHORT-NAME").text self.container_i_pdu_Table[CONPDUName] = {} self.container_i_pdu_Table[CONPDUName]["id"] = CONPDUName self.container_i_pdu_Table[CONPDUName]["byte_length"] = int(CONPDU.find(f"{self.ns}LENGTH").text) if CONPDU.find(f"{self.ns}DESC") != None and len(CONPDU.find(f"{self.ns}DESC"))!=0: self.container_i_pdu_Table[CONPDUName]['description'] = CONPDU.find(f"{self.ns}DESC")[0].text else: self.container_i_pdu_Table[CONPDUName]['description'] = None self.container_i_pdu_Table[CONPDUName]['PduTriggerRef'] = [] for PduTriggerRef in CONPDU.iter(f"{self.ns}CONTAINED-PDU-TRIGGERING-REF"): self.container_i_pdu_Table[CONPDUName]['PduTriggerRef'].append(PduTriggerRef.text.split('/')[-1]) elif key == self.UNIT: for unit in self.arxml_dict[key]: unitName = unit.find(f"{self.ns}SHORT-NAME").text self.unit_Table[unitName] = {} self.unit_Table[unitName]['id'] = unitName if unit.find(f"{self.ns}DESC") != None and len(unit.find(f"{self.ns}DESC"))!=0: self.unit_Table[unitName]['description'] = unit.find(f"{self.ns}DESC")[0].text else: self.unit_Table[unitName]['description'] = None self.unit_Table[unitName]['DisPaly'] = unit.find(f"{self.ns}DISPLAY-NAME").text if unit.find(f"{self.ns}DISPLAY-NAME") != None else None elif key == self.SW_BASE_TYPE: for BaseType in self.arxml_dict[key]: BaseTypeName = BaseType.find(f"{self.ns}SHORT-NAME").text self.sw_base_type_Table[BaseTypeName] = {} self.sw_base_type_Table[BaseTypeName]['id'] = BaseTypeName if BaseType.find(f"{self.ns}DESC") != None and len(BaseType.find(f"{self.ns}DESC"))!=0: self.sw_base_type_Table[BaseTypeName]['description'] = BaseType.find(f"{self.ns}DESC")[0].text else: self.sw_base_type_Table[BaseTypeName]['description'] = None self.sw_base_type_Table[BaseTypeName]['CATEGORY'] = BaseType.find(f"{self.ns}CATEGORY").text if BaseType.find(f"{self.ns}CATEGORY") != None else None self.sw_base_type_Table[BaseTypeName]['BASE-TYPE-ENCODING'] = BaseType.find(f"{self.ns}BASE-TYPE-ENCODING").text if BaseType.find(f"{self.ns}BASE-TYPE-ENCODING") != None else None elif key == self.COMPU_METHOD: for ComMethod in self.arxml_dict[key]: ComMethodName = ComMethod.find(f"{self.ns}SHORT-NAME").text self.compu_method_Table[ComMethodName] = {} self.compu_method_Table[ComMethodName]['id'] = BaseTypeName if ComMethod.find(f"{self.ns}DESC") != None and len(ComMethod.find(f"{self.ns}DESC"))!=0: self.compu_method_Table[ComMethodName]['description'] = ComMethod.find(f"{self.ns}DESC")[0].text else: self.compu_method_Table[ComMethodName]['description'] = None self.compu_method_Table[ComMethodName]['UNIT-REF'] = ComMethod.find(f"{self.ns}UNIT-REF").text.split("/")[-1] if ComMethod.find(f"{self.ns}UNIT-REF") != None else None self.compu_method_Table[ComMethodName]['CATEGORY'] = ComMethod.find(f"{self.ns}CATEGORY").text if ComMethod.find(f"{self.ns}CATEGORY") != None else None self.compu_method_Table[ComMethodName]['factor'] = 1.0 self.compu_method_Table[ComMethodName]['offset'] = 0.0 self.compu_method_Table[ComMethodName]['denominator'] = 1.0 for calcfactor in ComMethod.iter(f'{self.ns}COMPU-NUMERATOR'): self.compu_method_Table[ComMethodName]['factor'] = float(calcfactor[1].text) self.compu_method_Table[ComMethodName]['offset'] = float(calcfactor[0].text) for calcfactor in ComMethod.iter(f'{self.ns}COMPU-DENOMINATOR'): self.compu_method_Table[ComMethodName]['denominator'] = float(calcfactor[0].text) self.compu_method_Table[ComMethodName]['TextTable'] = [] for COMPU_SCALE in ComMethod.iter(f"{self.ns}COMPU-SCALE"): textTable = {} textTable['textvalue'] = COMPU_SCALE.find(f"{self.ns}SHORT-LABEL").text if COMPU_SCALE.find(f"{self.ns}SHORT-LABEL") != None else None textTable['SYMBOL'] = COMPU_SCALE.find(f"{self.ns}SYMBOL").text if COMPU_SCALE.find(f"{self.ns}SYMBOL") != None else None if COMPU_SCALE.find(f"{self.ns}DESC") != None and len(COMPU_SCALE.find(f"{self.ns}DESC"))!=0: textTable['description'] = COMPU_SCALE.find(f"{self.ns}DESC")[0].text else: textTable['description'] = None LOWER_LIMIT = (COMPU_SCALE.find(f"{self.ns}LOWER-LIMIT").text if COMPU_SCALE.find(f"{self.ns}LOWER-LIMIT") != None else "0") UPPER_LIMIT = (COMPU_SCALE.find(f"{self.ns}UPPER-LIMIT").text if COMPU_SCALE.find(f"{self.ns}UPPER-LIMIT") != None else "0") if LOWER_LIMIT.startswith("0b") or LOWER_LIMIT.startswith("0B") : LOWER_LIMIT = int(LOWER_LIMIT,2) elif LOWER_LIMIT.startswith("0x") or LOWER_LIMIT.startswith("0X") : LOWER_LIMIT = int(LOWER_LIMIT,16) else: LOWER_LIMIT = int(LOWER_LIMIT) if UPPER_LIMIT.startswith("0b") or UPPER_LIMIT.startswith("0B") : UPPER_LIMIT = int(UPPER_LIMIT,2) elif UPPER_LIMIT.startswith("0x") or UPPER_LIMIT.startswith("0X") : UPPER_LIMIT = int(UPPER_LIMIT,16) else: UPPER_LIMIT = int(UPPER_LIMIT) textTable['value_lower'] = LOWER_LIMIT textTable['value_upper'] = UPPER_LIMIT self.compu_method_Table[ComMethodName]['TextTable'].append(textTable) del textTable elif key == self.IMPLEMENTATION_DATA_TYPE: for IMDataType in self.arxml_dict[key]: IMDataTypeName = IMDataType.find(f"{self.ns}SHORT-NAME").text self.implementation_data_type_Table[IMDataTypeName] = {} self.implementation_data_type_Table[IMDataTypeName]['id'] = IMDataTypeName if IMDataType.find(f"{self.ns}DESC") != None and len(IMDataType.find(f"{self.ns}DESC"))!=0: self.implementation_data_type_Table[IMDataTypeName]['description'] = IMDataType.find(f"{self.ns}DESC")[0].text else: self.implementation_data_type_Table[IMDataTypeName]['description'] = None elif key == self.DATA_CONSTR: for DataConstr in self.arxml_dict[key]: DataConstrName = DataConstr.find(f"{self.ns}SHORT-NAME").text self.data_constr_Table[DataConstrName] = {} self.data_constr_Table[DataConstrName]['id'] = DataConstrName if DataConstr.find(f"{self.ns}DESC") != None and len(DataConstr.find(f"{self.ns}DESC"))!=0: self.data_constr_Table[DataConstrName]['description'] = DataConstr.find(f"{self.ns}DESC")[0].text else: self.data_constr_Table[DataConstrName]['description'] = None elif key == self.ECU_INSTANCE: for ECU in self.arxml_dict[key]: ECUName = ECU.find(f"{self.ns}SHORT-NAME").text self.ecu_instance_Table[ECUName] = {} self.ecu_instance_Table[ECUName]['id'] = ECUName self.ecu_instance_Table[ECUName]['short_name'] = ECUName if ECU.find(f"{self.ns}DESC") != None and len(ECU.find(f"{self.ns}DESC"))!=0: self.ecu_instance_Table[ECUName]['description'] = ECU.find(f"{self.ns}DESC")[0].text else: self.ecu_instance_Table[ECUName]['description'] = None self.ecu_instance_Table[ECUName]['controllerconfiguration'] = {} for ECUConfig in ECU.iter(f"{self.ns}FLEXRAY-COMMUNICATION-CONTROLLER-CONDITIONAL"): self.ecu_instance_Table[ECUName]['controllerconfiguration']['accepted_startup_range'] = int(ECUConfig.find(f'{self.ns}ACCEPTED-STARTUP-RANGE').text) self.ecu_instance_Table[ECUName]['controllerconfiguration']['allow_halt_due_to_clock'] = ECUConfig.find(f'{self.ns}ALLOW-HALT-DUE-TO-CLOCK').text self.ecu_instance_Table[ECUName]['controllerconfiguration']['allow_passive_to_active'] = int(ECUConfig.find(f'{self.ns}ALLOW-PASSIVE-TO-ACTIVE').text) self.ecu_instance_Table[ECUName]['controllerconfiguration']['cluster_drift_damping'] = int(ECUConfig.find(f'{self.ns}CLUSTER-DRIFT-DAMPING').text) self.ecu_instance_Table[ECUName]['controllerconfiguration']['decoding_correction'] = int(ECUConfig.find(f'{self.ns}DECODING-CORRECTION').text) self.ecu_instance_Table[ECUName]['controllerconfiguration']['delay_compensation_a'] = int(ECUConfig.find(f'{self.ns}DELAY-COMPENSATION-A').text) self.ecu_instance_Table[ECUName]['controllerconfiguration']['delay_compensation_b'] = int(ECUConfig.find(f'{self.ns}DELAY-COMPENSATION-B').text) self.ecu_instance_Table[ECUName]['controllerconfiguration']['extern_offset_correction'] = int(ECUConfig.find(f'{self.ns}EXTERN-OFFSET-CORRECTION').text) self.ecu_instance_Table[ECUName]['controllerconfiguration']['extern_rate_correction'] = int(ECUConfig.find(f'{self.ns}EXTERN-RATE-CORRECTION').text) self.ecu_instance_Table[ECUName]['controllerconfiguration']['single_slot_enabled'] = ECUConfig.find(f'{self.ns}KEY-SLOT-ONLY-ENABLED').text slotId = ECUConfig.find(f'{self.ns}KEY-SLOT-ID') if slotId is not None and int(slotId.text)!=0: self.ecu_instance_Table[ECUName]['controllerconfiguration']['key_slot_usage'] = 'STARTUP_SYNC' self.ecu_instance_Table[ECUName]['controllerconfiguration']['key_slot_id'] = int(slotId.text) else: self.ecu_instance_Table[ECUName]['controllerconfiguration']['key_slot_usage'] = 'NONE' self.ecu_instance_Table[ECUName]['controllerconfiguration']['key_slot_id'] = -1 self.ecu_instance_Table[ECUName]['controllerconfiguration']['latest_tx'] = int(ECUConfig.find(f'{self.ns}LATEST-TX').text) self.ecu_instance_Table[ECUName]['controllerconfiguration']['listen_timeout'] = int(ECUConfig.find(f'{self.ns}LISTEN-TIMEOUT').text) self.ecu_instance_Table[ECUName]['controllerconfiguration']['macro_initial_offset_a'] = int(ECUConfig.find(f'{self.ns}MACRO-INITIAL-OFFSET-A').text) self.ecu_instance_Table[ECUName]['controllerconfiguration']['macro_initial_offset_b'] = int(ECUConfig.find(f'{self.ns}MACRO-INITIAL-OFFSET-B').text) self.ecu_instance_Table[ECUName]['controllerconfiguration']['max_dynamic_payload_length'] = int(ECUConfig.find(f'{self.ns}MAXIMUM-DYNAMIC-PAYLOAD-LENGTH').text) self.ecu_instance_Table[ECUName]['controllerconfiguration']['micro_initial_offset_a'] = int(ECUConfig.find(f'{self.ns}MICRO-INITIAL-OFFSET-A').text) self.ecu_instance_Table[ECUName]['controllerconfiguration']['micro_initial_offset_b'] = int(ECUConfig.find(f'{self.ns}MICRO-INITIAL-OFFSET-B').text) self.ecu_instance_Table[ECUName]['controllerconfiguration']['micro_per_cycle'] = int(ECUConfig.find(f'{self.ns}MICRO-PER-CYCLE').text) self.ecu_instance_Table[ECUName]['controllerconfiguration']['micro_per_macro_nom'] = int(ECUConfig.find(f'{self.ns}MICRO-PER-CYCLE').text) self.ecu_instance_Table[ECUName]['controllerconfiguration']['microtick'] = float(ECUConfig.find(f'{self.ns}MICROTICK-DURATION').text)*100000000/100 self.ecu_instance_Table[ECUName]['controllerconfiguration']['offset_correction_out'] = int(ECUConfig.find(f'{self.ns}OFFSET-CORRECTION-OUT').text) self.ecu_instance_Table[ECUName]['controllerconfiguration']['rate_correction_out'] = int(ECUConfig.find(f'{self.ns}RATE-CORRECTION-OUT').text) self.ecu_instance_Table[ECUName]['controllerconfiguration']['max_drift'] = self.ecu_instance_Table[ECUName]['controllerconfiguration']['rate_correction_out'] self.ecu_instance_Table[ECUName]['controllerconfiguration']['samples_per_microtick'] = int(ECUConfig.find(f'{self.ns}SAMPLES-PER-MICROTICK').text) self.ecu_instance_Table[ECUName]['controllerconfiguration']['wakeup_pattern'] = int(ECUConfig.find(f'{self.ns}WAKE-UP-PATTERN').text) self.ecu_instance_Table[ECUName]['controllerconfiguration']['wake_up_channel_A'] = False self.ecu_instance_Table[ECUName]['controllerconfiguration']['wake_up_channel_B'] = False for COMMUNICATION_CONNECTOR in ECU.iter(f"{self.ns}FLEXRAY-COMMUNICATION-CONNECTOR"): COMMUNICATION_CONNECTOR_Name = COMMUNICATION_CONNECTOR.find(f'{self.ns}SHORT-NAME').text self.CONNECTORS[COMMUNICATION_CONNECTOR_Name] = {} FRAME_PORTS = COMMUNICATION_CONNECTOR.findall(f'{self.ns}ECU-COMM-PORT-INSTANCES/{self.ns}FRAME-PORT') for FRAME_PORT in FRAME_PORTS: self.CONNECTORS[COMMUNICATION_CONNECTOR_Name][FRAME_PORT.find(f'{self.ns}SHORT-NAME').text] = 1 if FRAME_PORT.find(f'{self.ns}COMMUNICATION-DIRECTION').text == 'OUT' else 0 elif key == self.FLEXRAY_CLUSTER: for FRCIdx,FRCLUSTER in enumerate(self.arxml_dict[key]): self.outputName = self.outputPath + r'\Fibex' + str(FRCIdx)+'.json' FRCLUSTERName = FRCLUSTER.find(f"{self.ns}SHORT-NAME").text self.flexray_cluster_Table = {} self.flexray_cluster_Table['id'] = FRCLUSTERName self.flexray_cluster_Table['short_name'] = FRCLUSTERName if FRCLUSTER.find(f"{self.ns}DESC") != None and len(FRCLUSTER.find(f"{self.ns}DESC"))!=0: self.flexray_cluster_Table['description'] = FRCLUSTER.find(f"{self.ns}DESC")[0].text else: self.flexray_cluster_Table['description'] = None self.flexray_cluster_Table['short_name'] = FRCLUSTER.find(f'{self.ns}SHORT-NAME').text self.flexray_cluster_Table['long_name'] = '' self.flexray_cluster_Table['description'] = '' FLEXRAY_CLUSTER_VARIANTS = FRCLUSTER.find(f'{self.ns}FLEXRAY-CLUSTER-VARIANTS/{self.ns}FLEXRAY-CLUSTER-CONDITIONAL') self.flexray_cluster_Table['speed'] = int(FLEXRAY_CLUSTER_VARIANTS.find(f'{self.ns}BAUDRATE').text) self.flexray_cluster_Table['is_high_bit_order'] = 'true' self.flexray_cluster_Table['bit_counting_policy'] = 'SAWTOOTH' self.flexray_cluster_Table['protocol'] = FLEXRAY_CLUSTER_VARIANTS.find(f'{self.ns}PROTOCOL-NAME').text self.flexray_cluster_Table['version'] = '2.1' self.flexray_cluster_Table['max_frame_length'] = 254 self.flexray_cluster_Table['medium'] = '' self.flexray_cluster_Table['number_of_cycles'] = 0 self.flexray_cluster_Table['cycle'] = float(FLEXRAY_CLUSTER_VARIANTS.find(f'{self.ns}CYCLE').text)*1000000 self.flexray_cluster_Table['bit'] = float(FLEXRAY_CLUSTER_VARIANTS.find(f'{self.ns}BIT').text)*10000000/10 self.flexray_cluster_Table['sample_clock_period'] = float(FLEXRAY_CLUSTER_VARIANTS.find(f'{self.ns}SAMPLE-CLOCK-PERIOD').text)*10000000/10 self.flexray_cluster_Table['macro_tick'] = float(FLEXRAY_CLUSTER_VARIANTS.find(f'{self.ns}MACROTICK-DURATION').text)*1000000 self.flexray_cluster_Table['macro_per_cycle'] = int(FLEXRAY_CLUSTER_VARIANTS.find(f'{self.ns}MACRO-PER-CYCLE').text) self.flexray_cluster_Table['number_of_static_slots'] = int(FLEXRAY_CLUSTER_VARIANTS.find(f'{self.ns}NUMBER-OF-STATIC-SLOTS').text) self.flexray_cluster_Table['static_slot'] = int(FLEXRAY_CLUSTER_VARIANTS.find(f'{self.ns}STATIC-SLOT-DURATION').text) self.flexray_cluster_Table['action_point_offset'] = int(FLEXRAY_CLUSTER_VARIANTS.find(f'{self.ns}ACTION-POINT-OFFSET').text) self.flexray_cluster_Table['t_s_s_transmitter'] = int(FLEXRAY_CLUSTER_VARIANTS.find(f'{self.ns}TRANSMISSION-START-SEQUENCE-DURATION').text) self.flexray_cluster_Table['payload_length_static'] = int(FLEXRAY_CLUSTER_VARIANTS.find(f'{self.ns}PAYLOAD-LENGTH-STATIC').text) self.flexray_cluster_Table['number_of_mini_slots'] = int(FLEXRAY_CLUSTER_VARIANTS.find(f'{self.ns}NUMBER-OF-MINISLOTS').text) self.flexray_cluster_Table['mini_slot'] = int(FLEXRAY_CLUSTER_VARIANTS.find(f'{self.ns}MINISLOT-DURATION').text) self.flexray_cluster_Table['mini_slot_action_point_offset'] = int(FLEXRAY_CLUSTER_VARIANTS.find(f'{self.ns}MINISLOT-ACTION-POINT-OFFSET').text) self.flexray_cluster_Table['dynamic_slot_idle_phase'] = int(FLEXRAY_CLUSTER_VARIANTS.find(f'{self.ns}DYNAMIC-SLOT-IDLE-PHASE').text) self.flexray_cluster_Table['symbol_window'] = int(FLEXRAY_CLUSTER_VARIANTS.find(f'{self.ns}SYMBOL-WINDOW').text) self.flexray_cluster_Table['NIT'] = int(FLEXRAY_CLUSTER_VARIANTS.find(f'{self.ns}NETWORK-IDLE-TIME').text) self.flexray_cluster_Table['sync_node_max'] = int(FLEXRAY_CLUSTER_VARIANTS.find(f'{self.ns}SYNC-FRAME-ID-COUNT-MAX').text) self.flexray_cluster_Table['network_management_vector_length'] = int(FLEXRAY_CLUSTER_VARIANTS.find(f'{self.ns}NETWORK-MANAGEMENT-VECTOR-LENGTH').text) self.flexray_cluster_Table['listen_noise'] = int(FLEXRAY_CLUSTER_VARIANTS.find(f'{self.ns}LISTEN-NOISE').text) self.flexray_cluster_Table['cold_start_attempts'] = int(FLEXRAY_CLUSTER_VARIANTS.find(f'{self.ns}COLD-START-ATTEMPTS').text) self.flexray_cluster_Table['cas_rx_low_max'] = int(FLEXRAY_CLUSTER_VARIANTS.find(f'{self.ns}CAS-RX-LOW-MAX').text) self.flexray_cluster_Table['wake_up_symbol_rx_idle'] = int(FLEXRAY_CLUSTER_VARIANTS.find(f'{self.ns}WAKEUP-RX-IDLE').text) self.flexray_cluster_Table['wake_up_symbol_rx_low'] = int(FLEXRAY_CLUSTER_VARIANTS.find(f'{self.ns}WAKEUP-RX-LOW').text) self.flexray_cluster_Table['wake_up_symbol_rx_window'] = int(FLEXRAY_CLUSTER_VARIANTS.find(f'{self.ns}WAKEUP-RX-WINDOW').text) self.flexray_cluster_Table['wake_up_symbol_tx_idle'] = int(FLEXRAY_CLUSTER_VARIANTS.find(f'{self.ns}WAKEUP-TX-IDLE').text) self.flexray_cluster_Table['wake_up_symbol_tx_low'] = int(FLEXRAY_CLUSTER_VARIANTS.find(f'{self.ns}WAKEUP-TX-ACTIVE').text) self.flexray_cluster_Table['max_initialization_error'] = 0.175 self.flexray_cluster_Table['cluster_drift_damping'] = 2 self.flexray_cluster_Table['offset_correction_start'] = int(FLEXRAY_CLUSTER_VARIANTS.find(f'{self.ns}OFFSET-CORRECTION-START').text) self.flexray_cluster_Table['max_without_clock_correction_fatal'] = int(FLEXRAY_CLUSTER_VARIANTS.find(f'{self.ns}MAX-WITHOUT-CLOCK-CORRECTION-FATAL').text) self.flexray_cluster_Table['max_without_clock_correction_passive'] = int(FLEXRAY_CLUSTER_VARIANTS.find(f'{self.ns}MAX-WITHOUT-CLOCK-CORRECTION-PASSIVE').text) PHYSICAL_CHANNELS = FLEXRAY_CLUSTER_VARIANTS.findall(f'{self.ns}PHYSICAL-CHANNELS/{self.ns}FLEXRAY-PHYSICAL-CHANNEL') for PHYSICAL_CHANNEL in PHYSICAL_CHANNELS: Flexray_ShortName = PHYSICAL_CHANNEL.find(f'{self.ns}SHORT-NAME').text channel = {} channel['short_name'] = Flexray_ShortName channel['flexray_channel_name'] = Flexray_ShortName[-1] self.NodelistMsg[Flexray_ShortName[-1]]= {} channel['ref_ecu_list'] = [] CONNECTOR_REFS = PHYSICAL_CHANNEL.findall(f'{self.ns}COMM-CONNECTORS/{self.ns}COMMUNICATION-CONNECTOR-REF-CONDITIONAL/{self.ns}COMMUNICATION-CONNECTOR-REF') for CONNECTOR_REF in CONNECTOR_REFS: nodeName = CONNECTOR_REF.text.split('/')[-2] # if not nodeName in NodelistMsg: self.NodelistMsg[Flexray_ShortName[-1]][nodeName] = {} self.NodelistMsg[Flexray_ShortName[-1]][nodeName]['TxFrames'] = [] self.NodelistMsg[Flexray_ShortName[-1]][nodeName]['RxFrames'] = [] FRAME_TRIGGERINGS = PHYSICAL_CHANNEL.findall(f'{self.ns}FRAME-TRIGGERINGS/{self.ns}FLEXRAY-FRAME-TRIGGERING') channelListFrame = {} for FRAME_TRIGGERING in FRAME_TRIGGERINGS: FRAME_PORT_REFS = FRAME_TRIGGERING.findall(f'{self.ns}FRAME-PORT-REFS/{self.ns}FRAME-PORT-REF') FrName = FRAME_TRIGGERING.find(f'{self.ns}FRAME-REF').text.split('/')[-1] FRMsgInfo = FRAME_TRIGGERING.find(f'{self.ns}ABSOLUTELY-SCHEDULED-TIMINGS/{self.ns}FLEXRAY-ABSOLUTELY-SCHEDULED-TIMING') FRSlotid = int(FRMsgInfo.find(f'{self.ns}SLOT-ID').text) FRbaseCycle = int(FRMsgInfo.find(f'{self.ns}COMMUNICATION-CYCLE/{self.ns}CYCLE-REPETITION/{self.ns}BASE-CYCLE').text) FRrepCycle = int(FRMsgInfo.find(f'{self.ns}COMMUNICATION-CYCLE/{self.ns}CYCLE-REPETITION/{self.ns}CYCLE-REPETITION').text.split('-')[-1]) FRMsg = {} FRMsg['slot'] = [FRSlotid] FRMsg['basecycle'] = FRbaseCycle FRMsg['repetition_cycle'] = FRrepCycle FRMsg['reference_frame_id'] = FrName channelListFrame[FrName] = FrName for FRAME_PORT_REF in FRAME_PORT_REFS: nodename = FRAME_PORT_REF.text.split('/')[-3] Connector = FRAME_PORT_REF.text.split('/')[-2] is_tx = FRAME_PORT_REF.text.split('/')[-1] if self.CONNECTORS[Connector][is_tx] == 1: self.NodelistMsg[Flexray_ShortName[-1]][nodename]['TxFrames'].append(FRMsg) else: self.NodelistMsg[Flexray_ShortName[-1]][nodename]['RxFrames'].append(FRMsg) self.channelList.append(channel) for Framekey in channelListFrame: self.FRFrameTable[Framekey] = self.flexray_frame_Table[Framekey] channelListPdu = {} for Framekey in self.FRFrameTable: for onepdu in self.FRFrameTable[Framekey]["pdus"]: if onepdu['reference_pdu_id'] in self.i_signal_i_pdu_Table: channelListPdu[onepdu['reference_pdu_id']] = onepdu['reference_pdu_id'] else: self.FRFrameTable[Framekey]["pdus"].remove(onepdu) for pdukey in channelListPdu: self.FRPDUTable[pdukey] = self.i_signal_i_pdu_Table[pdukey] channelListSignal = {} for Pdukey in self.FRPDUTable: for oneSignal in self.FRPDUTable[Pdukey]["signals"]: channelListSignal[oneSignal['reference_signal_id']] = oneSignal['reference_signal_id'] for signalkey in channelListSignal: self.FRSignalTable[signalkey] = self.i_signal_Table[signalkey] for idx in range(len(self.channelList)): flexray_channel_name = self.channelList[idx]['flexray_channel_name'] for Msgkey in self.NodelistMsg[self.channelList[idx]['flexray_channel_name']]: if Msgkey in self.ecu_instance_Table: self.ecu_instance_Table[Msgkey]['controllerconfiguration']['wake_up_channel_' + flexray_channel_name] = True ecu = {} ecu['reference_ecu_id'] = Msgkey ecu['TxFrames'] = self.NodelistMsg[self.channelList[idx]['flexray_channel_name']][Msgkey]['TxFrames'] ecu['RxFrames'] = self.NodelistMsg[self.channelList[idx]['flexray_channel_name']][Msgkey]['RxFrames'] self.channelList[idx]['ref_ecu_list'].append(ecu) with open(self.outputName, "w",encoding='utf8') as f: jsoninfo = {} jsoninfo['cluster'] = self.flexray_cluster_Table jsoninfo['channelList'] = self.channelList jsoninfo['ecuTable'] = list(self.ecu_instance_Table.values()) jsoninfo['frameTable'] = list(self.FRFrameTable.values()) jsoninfo['pduTable'] = list(self.FRPDUTable.values()) jsoninfo['signalTable'] = list(self.FRSignalTable.values()) # jsoninfo['signalGroupTable'] = list(self.i_signal_group_Table.values()) json.dump(jsoninfo, f, indent=4, ensure_ascii=False) self.DBCount = len(self.arxml_dict[key]) ini_file_path = self.outputPath+r'\FlexRayFibexParser.ini' dbini = ConfigParser() dbini.add_section('Results') dbini.set('Results', 'DBCount', str(self.DBCount)) if self.DBCount == 0: dbini.add_section('db'+str(self.DBCount)) dbini.set('db'+str(idx), 'FileName', self.arxmlname) dbini.set('db'+str(idx), 'BusType', '5') dbini.set('db'+str(idx), 'ProtocolType', 'FlexRay') dbini.set('db'+str(idx), 'JsonPath', self.outputName) dbini.set('db'+str(idx), 'ParseOK', '3') else: for idx in range(self.DBCount): dbini.add_section('db'+str(idx)) dbini.set('db'+str(idx), 'FileName', self.arxmlname) dbini.set('db'+str(idx), 'BusType', '5') dbini.set('db'+str(idx), 'ProtocolType', 'FlexRay') dbini.set('db'+str(idx), 'JsonPath', self.outputName) dbini.set('db'+str(idx), 'ParseOK', '1') dbini.write(open(ini_file_path, 'w'))