armodel 1.7.6__py3-none-any.whl → 1.7.7__py3-none-any.whl

armodel/parser/arxml_parser.py

@@ -2,6 +2,10 @@ from typing import List
 import xml.etree.ElementTree as ET
 import os
 
+from armodel.models.M2.AUTOSARTemplates.SystemTemplate.SWmapping import SwcToImplMapping
+
+
+
 from ..models.M2.MSR.AsamHdo.AdminData import AdminData
 from ..models.M2.MSR.AsamHdo.BaseTypes import BaseTypeDirectDefinition, SwBaseType
 from ..models.M2.MSR.AsamHdo.Constraints.GlobalConstraints import DataConstrRule, InternalConstrs, PhysConstrs, DataConstr
@@ -25,7 +29,7 @@ from ..models.M2.MSR.Documentation.TextModel.LanguageDataModel import LLongName,
 from ..models.M2.MSR.Documentation.TextModel.MultilanguageData import MultiLanguageOverviewParagraph, MultiLanguageParagraph, MultiLanguagePlainText, MultilanguageLongName
 
 from ..models.M2.AUTOSARTemplates.AutosarTopLevelStructure import AUTOSAR
-from ..models.M2.AUTOSARTemplates.BswModuleTemplate.BswBehavior import BswCalledEntity, BswDataReceivedEvent, BswInternalBehavior, BswInternalTriggerOccurredEvent, BswInterruptEntity, BswModeSwitchEvent, BswModuleEntity, BswSchedulableEntity, BswScheduleEvent, BswModeSenderPolicy, BswTimingEvent
+from ..models.M2.AUTOSARTemplates.BswModuleTemplate.BswBehavior import BswBackgroundEvent, BswCalledEntity, BswDataReceivedEvent, BswExternalTriggerOccurredEvent, BswInternalBehavior, BswInternalTriggerOccurredEvent, BswInterruptEntity, BswModeSwitchEvent, BswModuleEntity, BswSchedulableEntity, BswScheduleEvent, BswModeSenderPolicy, BswTimingEvent
 from ..models.M2.AUTOSARTemplates.BswModuleTemplate.BswInterfaces import BswModuleEntry
 from ..models.M2.AUTOSARTemplates.BswModuleTemplate.BswImplementation import BswImplementation
 from ..models.M2.AUTOSARTemplates.BswModuleTemplate.BswOverview import BswModuleDescription
@@ -47,19 +51,19 @@ from ..models.M2.AUTOSARTemplates.CommonStructure.Timing.TimingConstraint.Timing
 from ..models.M2.AUTOSARTemplates.DiagnosticExtract.DiagnosticContribution import DiagnosticServiceTable
 from ..models.M2.AUTOSARTemplates.ECUCDescriptionTemplate import EcucAbstractReferenceValue, EcucContainerValue, EcucInstanceReferenceValue, EcucModuleConfigurationValues, EcucNumericalParamValue, EcucParameterValue, EcucReferenceValue, EcucTextualParamValue, EcucValueCollection
 from ..models.M2.AUTOSARTemplates.GenericStructure.AbstractStructure import AnyInstanceRef
-from ..models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import Identifiable, MultilanguageReferrable
+from ..models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import Identifiable, MultilanguageReferrable, Referrable
 from ..models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.EngineeringObject import AutosarEngineeringObject, EngineeringObject
 from ..models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ARPackage import ARPackage, ReferenceBase
 from ..models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import Ip6AddressString, RefType, ARLiteral
 from ..models.M2.AUTOSARTemplates.GenericStructure.LifeCycles import LifeCycleInfoSet
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.PortAPIOptions import PortAPIOption, PortDefinedArgumentValue
-from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.RTEEvents import DataReceivedEvent, OperationInvokedEvent, RTEEvent, SwcModeSwitchEvent
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.RTEEvents import AsynchronousServerCallReturnsEvent, BackgroundEvent, DataReceivedEvent, InitEvent, InternalTriggerOccurredEvent, ModeSwitchedAckEvent, OperationInvokedEvent, RTEEvent, SwcModeSwitchEvent, TimingEvent
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Datatype.Datatypes import ApplicationPrimitiveDataType, ApplicationRecordDataType, ApplicationArrayDataType, ApplicationCompositeDataType, ApplicationDataType, AutosarDataType, DataTypeMap, DataTypeMappingSet
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.EndToEndProtection import EndToEndProtectionSet, EndToEndDescription, EndToEndProtection, EndToEndProtectionVariablePrototype
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Composition.InstanceRefs import POperationInAtomicSwcInstanceRef, PPortInCompositionInstanceRef, ROperationInAtomicSwcInstanceRef, RPortInCompositionInstanceRef
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.PortInterface.InstanceRefs import ApplicationCompositeElementInPortInterfaceInstanceRef
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.InstanceRefsUsage import AutosarParameterRef, VariableInAtomicSWCTypeInstanceRef
-from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Communication import CompositeNetworkRepresentation, TransmissionAcknowledgementRequest
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Communication import CompositeNetworkRepresentation, ModeSwitchedAckRequest, TransmissionAcknowledgementRequest
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.IncludedDataTypes import IncludedDataTypeSet
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Components import AbstractProvidedPortPrototype, AbstractRequiredPortPrototype, ApplicationSwComponentType, ComplexDeviceDriverSwComponentType, CompositionSwComponentType, EcuAbstractionSwComponentType, PortGroup, SensorActuatorSwComponentType, ServiceSwComponentType, SwComponentType, SymbolProps, PPortPrototype, RPortPrototype
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Components.InstanceRefs import InnerPortGroupInCompositionInstanceRef, PModeGroupInAtomicSwcInstanceRef, RModeGroupInAtomicSWCInstanceRef, RModeInAtomicSwcInstanceRef, RVariableInAtomicSwcInstanceRef
@@ -78,12 +82,13 @@ from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Datatype.DataPrototypes im
 from ..models.M2.AUTOSARTemplates.SystemTemplate import SwcToEcuMapping , System, SystemMapping
 from ..models.M2.AUTOSARTemplates.SystemTemplate.DataMapping import SenderReceiverToSignalGroupMapping, SenderReceiverToSignalMapping
 from ..models.M2.AUTOSARTemplates.SystemTemplate.DiagnosticConnection import DiagnosticConnection
-from ..models.M2.AUTOSARTemplates.SystemTemplate.NetworkManagement import CanNmCluster, CanNmClusterCoupling, CanNmNode, NmCluster, NmConfig, NmNode, UdpNmCluster, UdpNmClusterCoupling, UdpNmNode
+from ..models.M2.AUTOSARTemplates.SystemTemplate.ECUResourceMapping import ECUMapping
+from ..models.M2.AUTOSARTemplates.SystemTemplate.NetworkManagement import CanNmCluster, CanNmClusterCoupling, CanNmNode, NmCluster, NmConfig, NmEcu, NmNode, UdpNmCluster, UdpNmClusterCoupling, UdpNmEcu, UdpNmNode
 from ..models.M2.AUTOSARTemplates.SystemTemplate.InstanceRefs import ComponentInSystemInstanceRef, VariableDataPrototypeInSystemInstanceRef
 from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Lin.LinCommunication import ApplicationEntry, LinFrameTriggering, LinScheduleTable, LinUnconditionalFrame, ScheduleTableEntry
 from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Lin.LinTopology import LinCommunicationConnector, LinCommunicationController, LinMaster
 from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.CoreTopology import AbstractCanCluster, CanCluster, CanClusterBusOffRecovery, CanPhysicalChannel, CommConnectorPort, CommunicationCluster, CommunicationConnector, CommunicationController, EthernetPhysicalChannel, FramePort, IPduPort, ISignalPort, LinCluster, LinPhysicalChannel, PhysicalChannel
-from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.CoreCommunication import DcmIPdu, Frame, FrameTriggering, GeneralPurposeIPdu, GeneralPurposePdu, IPdu, IPduTiming, ISignal, ISignalGroup, ISignalIPdu, ISignalIPduGroup, ISignalTriggering, MultiplexedIPdu, NPdu, NmPdu, PduTriggering, SecureCommunicationPropsSet, SecuredIPdu, SystemSignal, SystemSignalGroup, UserDefinedIPdu, UserDefinedPdu
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.CoreCommunication import DcmIPdu, DynamicPart, DynamicPartAlternative, Frame, FrameTriggering, GeneralPurposeIPdu, GeneralPurposePdu, IPdu, IPduTiming, ISignal, ISignalGroup, ISignalIPdu, ISignalIPduGroup, ISignalToIPduMapping, ISignalTriggering, MultiplexedIPdu, MultiplexedPart, NPdu, NmPdu, Pdu, PduTriggering, SecureCommunicationAuthenticationProps, SecureCommunicationFreshnessProps, SecureCommunicationProps, SecureCommunicationPropsSet, SecuredIPdu, SegmentPosition, StaticPart, SystemSignal, SystemSignalGroup, UserDefinedIPdu, UserDefinedPdu
 from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.Timing import CyclicTiming, EventControlledTiming, TimeRangeType, TransmissionModeCondition, TransmissionModeDeclaration, TransmissionModeTiming
 from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.EcuInstance import EcuInstance
 from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Can.CanCommunication import CanFrame, CanFrameTriggering, RxIdentifierRange
@@ -94,7 +99,7 @@ from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Ethernet.NetworkEnd
 from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Ethernet.ServiceInstances import ApplicationEndpoint, ConsumedEventGroup, ConsumedServiceInstance, EventHandler, GenericTp, ProvidedServiceInstance, SdServerConfig, SoAdConfig, SocketAddress, TcpTp, TpPort, TransportProtocolConfiguration, UdpTp
 from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Ethernet.EthernetTopology import CouplingPort, CouplingPortDetails, CouplingPortFifo, CouplingPortScheduler, CouplingPortStructuralElement, EthernetCluster, EthernetCommunicationConnector, EthernetCommunicationController, EthernetPriorityRegeneration, InitialSdDelayConfig, MacMulticastGroup, RequestResponseDelay, SdClientConfig, VlanMembership
 from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Multiplatform import Gateway, IPduMapping, ISignalMapping, TargetIPduRef
-from ..models.M2.AUTOSARTemplates.SystemTemplate.TransportProtocols import CanTpConfig, DoIpTpConfig, LinTpConfig
+from ..models.M2.AUTOSARTemplates.SystemTemplate.TransportProtocols import CanTpAddress, CanTpChannel, CanTpConfig, CanTpConnection, CanTpEcu, CanTpNode, DoIpLogicAddress, DoIpTpConfig, DoIpTpConnection, LinTpConfig, LinTpConnection, LinTpNode, TpAddress, TpConfig, TpConnection
 
 from .abstract_arxml_parser import AbstractARXMLParser
 
@@ -119,13 +124,24 @@ class ARXMLParser(AbstractARXMLParser):
             sd.setValue(child_element.text)
             sdg.addSd(sd)
 
+    def readSdgCaption(self, element: ET.Element, sdg:Sdg):
+        child_element = self.find(element, "SDG-CAPTION")
+        if child_element is not None:
+            sdg.createSdgCaption(self.getShortName(child_element))
+
+    def readSdgSdxRefs(self, element: ET.SubElement, sdg:Sdg):
+        for ref in self.getChildElementRefTypeList(element, "SDX-REF"):
+            sdg.addSdxRef(ref)
+
     def getSdg(self, element: ET.Element) -> Sdg:
         sdg = Sdg()
         if 'GID' in element.attrib:
             sdg.setGID(element.attrib["GID"])
+        self.readSdgCaption(element, sdg)
         self.readSd(element, sdg)
         for child_element in self.findall(element, "SDG"):
             sdg.addSdgContentsType(self.getSdg(child_element))
+        self.readSdgSdxRefs(element, sdg)
         return sdg
     
     def readSdgs(self, element: ET.Element, admin_data: AdminData):
@@ -143,9 +159,12 @@ class ARXMLParser(AbstractARXMLParser):
 
             self.readSdgs(child_element, admin_data)
         return admin_data
+    
+    def readReferrable(self, element: ET.Element, referrable: Referrable):
+        self.readARObjectAttributes(element, referrable)
 
     def readMultilanguageReferrable(self, element: ET.Element, referrable: MultilanguageReferrable):
-        self.readARObjectAttributes(element, referrable)
+        self.readReferrable(element, referrable)
         referrable.setLongName(self.getMultilanguageLongName(element, "LONG-NAME"))
     
     def readIdentifiable(self, element: ET.Element, identifiable: Identifiable):
@@ -315,12 +334,12 @@ class ARXMLParser(AbstractARXMLParser):
         self.readBswEvent(element, event)
 
     def readBswModeSwitchEvent(self, element: ET.Element, event: BswModeSwitchEvent):
-        self.logger.debug("read BswModeSwitchEvent %s" % event.getShortName())
+        self.logger.debug("Read BswModeSwitchEvent <%s>" % event.getShortName())
         # Read the Inherit BswScheduleEvent
         self.readBswScheduleEvent(element, event)
 
     def readBswTimingEvent(self, element: ET.Element, event: BswTimingEvent):
-        self.logger.debug("read BswTimingEvent %s" % event.getShortName())
+        self.logger.debug("Read BswTimingEvent <%s>" % event.getShortName())
         # Read the Inherit BswScheduleEvent
         self.readBswScheduleEvent(element, event)
         event.setPeriod(self.getChildElementOptionalTimeValue(element, "PERIOD"))
@@ -330,13 +349,13 @@ class ARXMLParser(AbstractARXMLParser):
             self.logger.debug(" Period: <%f, %s>" % (event.getPeriod().getValue(), event.getPeriod().getText()))
 
     def readBswDataReceivedEvent(self, element: ET.Element, event: BswDataReceivedEvent):
-        self.logger.debug("read BswTimingEvent %s" % event.getShortName())
+        self.logger.debug("Read BswDataReceivedEvent <%s>" % event.getShortName())
         # Read the Inherit BswScheduleEvent
         self.readBswScheduleEvent(element, event)
         event.setDataRef(self.getChildElementOptionalRefType(element, "DATA-REF"))
 
     def readBswInternalTriggerOccurredEvent(self, element: ET.Element, event: BswInternalTriggerOccurredEvent):
-        self.logger.debug("read BswTimingEvent %s" % event.getShortName())
+        self.logger.debug("Read BswInternalTriggerOccurredEvent <%s>" % event.getShortName())
         # Read the Inherit BswScheduleEvent
         self.readBswScheduleEvent(element, event)
         event.setEventSourceRef(self.getChildElementOptionalRefType(element, "EVENT-SOURCE-REF"))
@@ -639,6 +658,13 @@ class ARXMLParser(AbstractARXMLParser):
             else:
                 self.notImplemented("Unsupported BswModuleEntity <%s>" % tag_name)
 
+    def readBswBackgroundEvent(self, element: ET.Element, event: BswBackgroundEvent):
+        self.readBswScheduleEvent(element, event)
+
+    def readBswExternalTriggerOccurredEvent(self, element: ET.Element, event: BswExternalTriggerOccurredEvent):
+        self.readBswScheduleEvent(element, event)
+        event.setTriggerRef(self.getChildElementOptionalRefType(element, "TRIGGER-REF"))
+
     def readBswInternalBehaviorEvents(self, element: ET.Element, behavior: BswInternalBehavior):
         for child_element in self.findall(element, "EVENTS/*"):
             tag_name = self.getTagName(child_element)
@@ -654,6 +680,12 @@ class ARXMLParser(AbstractARXMLParser):
             elif tag_name == "BSW-INTERNAL-TRIGGER-OCCURRED-EVENT":
                 event = behavior.createBswInternalTriggerOccurredEvent(self.getShortName(child_element))
                 self.readBswInternalTriggerOccurredEvent(child_element, event)
+            elif tag_name == "BSW-BACKGROUND-EVENT":
+                event = behavior.createBswBackgroundEvent(self.getShortName(child_element))
+                self.readBswBackgroundEvent(child_element, event)
+            elif tag_name == "BSW-EXTERNAL-TRIGGER-OCCURRED-EVENT":
+                event = behavior.createBswExternalTriggerOccurredEvent(self.getShortName(child_element))
+                self.readBswExternalTriggerOccurredEvent(child_element, event)
             else:
                 self.notImplemented("Unsupported BswModuleEntity <%s>" % tag_name)
 
@@ -800,11 +832,13 @@ class ARXMLParser(AbstractARXMLParser):
         impl.setArReleaseVersion(self.getChildElementOptionalLiteral(element, "AR-RELEASE-VERSION")) \
             .setBehaviorRef(self.getChildElementOptionalRefType(element, "BEHAVIOR-REF"))
         self.readBswImplementationVendorSpecificModuleDefRefs(element, impl)
+        AUTOSAR.getInstance().addImplementationBehaviorMap(impl.getFullName(), impl.getBehaviorRef().getValue())
 
     def readSwcImplementation(self, element: ET.Element, impl: SwcImplementation):
         self.logger.debug("Read SwcImplementation <%s>" % impl.getShortName())
         self.readImplementation(element, impl)
         impl.setBehaviorRef(self.getChildElementOptionalRefType(element, "BEHAVIOR-REF"))
+        AUTOSAR.getInstance().addImplementationBehaviorMap(impl.getFullName(), impl.getBehaviorRef().getValue())
 
     def readDataReceivePointByArguments(self, element, parent: RunnableEntity):
         self._readVariableAccesses(element, parent, "DATA-RECEIVE-POINT-BY-ARGUMENTS")
@@ -1008,9 +1042,8 @@ class ARXMLParser(AbstractARXMLParser):
                           .setTargetProvidedOperationRef(self.getChildElementRefType(parent.getShortName(), child_element, "TARGET-PROVIDED-OPERATION-REF"))
             parent.setOperationIRef(operation_iref)
 
-    def readOperationInvokedEvent(self, element: ET.Element, parent: SwcInternalBehavior):
-        short_name = self.getShortName(element)
-        event = parent.createOperationInvokedEvent(short_name)
+    def readOperationInvokedEvent(self, element: ET.Element, event: OperationInvokedEvent):
+        self.logger.debug("Read OperationInvokedEvent <%s>" % event.getShortName())
         self.readPOperationIRef(element, "OPERATION-IREF", event)
         self.readRTEEvent(element, event)
 
@@ -1068,60 +1101,76 @@ class ARXMLParser(AbstractARXMLParser):
                 option.addPortArgValue(self.readPortDefinedArgumentValue(argument_value_tag))
             behavior.addPortAPIOption(option)
             
-    def readTimingEvent(self, element: ET.Element, parent: SwcInternalBehavior):
-        short_name = self.getShortName(element)
-        event = parent.createTimingEvent(short_name)
+    def readTimingEvent(self, element: ET.Element, event: TimingEvent):
+        self.logger.debug("Read TimingEvent <%s>" % event.getShortName())
         self.readRTEEvent(element, event)
         event.setOffset(self.getChildElementOptionalTimeValue(element, "OFFSET")) \
              .setPeriod(self.getChildElementOptionalTimeValue(element, "PERIOD"))
 
-    def readDataReceivedEvent(self, element: ET.Element, parent: SwcInternalBehavior):
-        short_name = self.getShortName(element)
-        event = parent.createDataReceivedEvent(short_name)
+    def readDataReceivedEvent(self, element: ET.Element, event: DataReceivedEvent):
+        self.logger.debug("Read DataReceivedEvent <%s>" % event.getShortName())
         self.readRTEEvent(element, event)
         self.readRVariableInAtomicSwcInstanceRef(element, event)
 
-    def readSwcModeSwitchEvent(self, element: ET.Element, parent: SwcInternalBehavior):
-        short_name = self.getShortName(element)
-        event = parent.createSwcModeSwitchEvent(short_name)
+    def readSwcModeSwitchEvent(self, element: ET.Element, event: SwcModeSwitchEvent):
+        self.logger.debug("Read SwcModeSwitchEvent <%s>" % event.getShortName())
         self.readRTEEvent(element, event)
         event.setActivation(self.getChildElementOptionalLiteral(element, "ACTIVATION"))
         self.readRModeInAtomicSwcInstanceRef(element, event)
 
-    def readInternalTriggerOccurredEvent(self, element: ET.Element, parent: SwcInternalBehavior):
-        short_name = self.getShortName(element)
-        event = parent.createInternalTriggerOccurredEvent(short_name)
+    def readInternalTriggerOccurredEvent(self, element: ET.Element, event: InternalTriggerOccurredEvent):
+        self.logger.debug("Read InternalTriggerOccurredEvent <%s>" % event.getShortName())
         self.readRTEEvent(element, event)
         event.setEventSourceRef(self.getChildElementOptionalRefType(element, "EVENT-SOURCE-REF"))
 
-    def readInitEvent(self, element, parent: SwcInternalBehavior):
-        short_name = self.getShortName(element)
-        event = parent.createInitEvent(short_name)
+    def readInitEvent(self, element, event: InitEvent):
+        self.logger.debug("Read InitEvent <%s>" % event.getShortName())
         self.readRTEEvent(element, event)
 
-    def readAsynchronousServerCallReturnsEvent(self, element, parent: SwcInternalBehavior):
-        short_name = self.getShortName(element)
-        event = parent.createAsynchronousServerCallReturnsEvent(short_name)
+    def readAsynchronousServerCallReturnsEvent(self, element, event: AsynchronousServerCallReturnsEvent):
+        self.logger.debug("Read AsynchronousServerCallReturnsEvent <%s>" % event.getShortName())
         self.readRTEEvent(element, event)
         event.setActivationReasonRepresentationRef(self.getChildElementOptionalRefType(element, "EVENT-SOURCE-REF"))
 
+    def readModeSwitchedAckEvent(self, element, event: ModeSwitchedAckEvent):
+        self.logger.debug("Read ModeSwitchedAckEvent <%s>" % event.getShortName())
+        self.readRTEEvent(element, event)
+        event.setEventSourceRef(self.getChildElementOptionalRefType(element, "EVENT-SOURCE-REF"))
+
+    def readBackgroundEvent(self, element, event: BackgroundEvent):
+        self.logger.debug("Read BackgroundEvent <%s>" % event.getShortName())
+        self.readRTEEvent(element, event)
+
     def readSwcInternalBehaviorEvents(self, element: ET.Element, parent: SwcInternalBehavior):
         for child_element in self.findall(element, "EVENTS/*"):
             tag_name = self.getTagName(child_element)
             if tag_name == "TIMING-EVENT":
-                self.readTimingEvent(child_element, parent)
+                event = parent.createTimingEvent(self.getShortName(child_element))
+                self.readTimingEvent(child_element, event)
             elif tag_name == "SWC-MODE-SWITCH-EVENT":
-                self.readSwcModeSwitchEvent(child_element, parent)
+                event = parent.createSwcModeSwitchEvent(self.getShortName(child_element))
+                self.readSwcModeSwitchEvent(child_element, event)
             elif tag_name == "OPERATION-INVOKED-EVENT":
-                self.readOperationInvokedEvent(child_element, parent)
+                event = parent.createOperationInvokedEvent(self.getShortName(child_element))
+                self.readOperationInvokedEvent(child_element, event)
             elif tag_name == "DATA-RECEIVED-EVENT":
-                self.readDataReceivedEvent(child_element, parent)
+                event = parent.createDataReceivedEvent(self.getShortName(child_element))
+                self.readDataReceivedEvent(child_element, event)
             elif tag_name == "INTERNAL-TRIGGER-OCCURRED-EVENT":
-                self.readInternalTriggerOccurredEvent(child_element, parent)
+                event = parent.createInternalTriggerOccurredEvent(self.getShortName(child_element))
+                self.readInternalTriggerOccurredEvent(child_element, event)
             elif tag_name == "INIT-EVENT":
-                self.readInitEvent(child_element, parent)
+                event = parent.createInitEvent(self.getShortName(child_element))
+                self.readInitEvent(child_element, event)
             elif tag_name == "ASYNCHRONOUS-SERVER-CALL-RETURNS-EVENT":
-                self.readAsynchronousServerCallReturnsEvent(child_element, parent)
+                event = parent.createAsynchronousServerCallReturnsEvent(self.getShortName(child_element))
+                self.readAsynchronousServerCallReturnsEvent(child_element, event)
+            elif tag_name == "MODE-SWITCHED-ACK-EVENT":
+                event = parent.createModeSwitchedAckEvent(self.getShortName(child_element))
+                self.readModeSwitchedAckEvent(child_element, event)
+            elif tag_name == "BACKGROUND-EVENT":
+                event = parent.createBackgroundEvent(self.getShortName(child_element))
+                self.readBackgroundEvent(child_element, event)
             else:
                 self.notImplemented("Unsupported SwcInternalBehavior Event <%s>" % tag_name)
 
@@ -1553,27 +1602,36 @@ class ARXMLParser(AbstractARXMLParser):
                 .setTransmissionAcknowledge(self.readTransmissionAcknowledgementRequest(element)) \
                 .setUsesEndToEndProtection(self.getChildElementOptionalBooleanValue(element, "USES-END-TO-END-PROTECTION"))
 
-    def getNonqueuedSenderComSpec(self, element) -> NonqueuedSenderComSpec:
+    def getNonqueuedSenderComSpec(self, element:ET.Element) -> NonqueuedSenderComSpec:
         com_spec = NonqueuedSenderComSpec()
         self.readSenderComSpec(element, com_spec)
         com_spec.setInitValue(self.getInitValue(element))
         return com_spec
     
-    def getServerComSpec(self, element) -> ServerComSpec:
+    def getServerComSpec(self, element:ET.Element) -> ServerComSpec:
         com_spec = ServerComSpec()
         self.readARObjectAttributes(element, com_spec)
         com_spec.setOperationRef(self.getChildElementOptionalRefType(element, "OPERATION-REF")) \
                 .setQueueLength(self.getChildElementOptionalNumericalValue(element, "QUEUE-LENGTH"))
         return com_spec
     
-    def getQueuedSenderComSpec(self, element) -> QueuedSenderComSpec:
+    def getQueuedSenderComSpec(self, element:ET.Element) -> QueuedSenderComSpec:
         com_spec = QueuedSenderComSpec()
         self.readSenderComSpec(element, com_spec)
         return com_spec
     
+    def getModeSwitchedAckRequest(self, element: ET.Element, key: str) -> ModeSwitchedAckRequest:
+        request = None
+        child_element = self.find(element, key)
+        if child_element is not None:
+            request = ModeSwitchedAckRequest()
+            request.setTimeout(self.getChildElementOptionalTimeValue(child_element, "TIMEOUT"))
+        return request
+    
     def getModeSwitchSenderComSpec(self, element) -> ModeSwitchSenderComSpec:
         com_spec = ModeSwitchSenderComSpec()
         com_spec.setModeGroupRef(self.getChildElementOptionalRefType(element, "MODE-GROUP-REF")) \
+                .setModeSwitchedAck(self.getModeSwitchedAckRequest(element, "MODE-SWITCHED-ACK")) \
                 .setQueueLength(self.getChildElementOptionalNumericalValue(element, "QUEUE-LENGTH"))
         return com_spec
 
@@ -1931,6 +1989,7 @@ class ARXMLParser(AbstractARXMLParser):
                 self.readARObjectAttributes(child_element, compu_scale)
                 compu_scale.setLowerLimit(self.getChildLimitElement(child_element, "LOWER-LIMIT")) \
                            .setShortLabel(self.getChildElementOptionalLiteral(child_element, "SHORT-LABEL")) \
+                           .setDesc(self.getMultiLanguageOverviewParagraph(child_element, "DESC")) \
                            .setSymbol(self.getChildElementOptionalLiteral(child_element, "SYMBOL")) \
                            .setUpperLimit(self.getChildLimitElement(child_element, "UPPER-LIMIT"))
                 self.readCompuScaleContents(child_element, compu_scale)
@@ -2144,7 +2203,7 @@ class ARXMLParser(AbstractARXMLParser):
         self.readEndToEndProtectionVariablePrototypes(element, protection)
 
     def readEndToEndProtections(self, element: ET.Element, parent: EndToEndProtectionSet):
-        for child_element in self.findall(element, "END-TO-END-PROTECTIONS/*", self.nsmap):
+        for child_element in self.findall(element, "END-TO-END-PROTECTIONS/*"):
             tag_name = self.getTagName(child_element)
             if tag_name == "END-TO-END-PROTECTION":
                 self.readEndToEndProtection(child_element, parent)
@@ -2193,12 +2252,14 @@ class ARXMLParser(AbstractARXMLParser):
             self.logger.debug("readApplicationArrayElement %s" % short_name)
             array_element = parent.createApplicationArrayElement(short_name)
             self.readApplicationCompositeElementDataPrototype(child_element, array_element)
+            array_element.setArraySizeHandling(self.getChildElementOptionalLiteral(child_element, "ARRAY-SIZE-HANDLING"))
             array_element.setArraySizeSemantics(self.getChildElementOptionalLiteral(child_element, "ARRAY-SIZE-SEMANTICS"))
             array_element.setMaxNumberOfElements(self.getChildElementOptionalNumericalValue(child_element, "MAX-NUMBER-OF-ELEMENTS"))
 
     def readApplicationArrayDataType(self, element: ET.Element, data_type: ApplicationArrayDataType):
         self.logger.debug("Read ApplicationArrayDataType <%s>" % data_type)
         self.readApplicationCompositeDataType(element, data_type)
+        data_type.setDynamicArraySizeProfile(self.getChildElementOptionalLiteral(element, "DYNAMIC-ARRAY-SIZE-PROFILE"))
         self.readApplicationArrayElement(element, data_type)
 
     def getSwRecordLayoutV(self, element: ET.Element, key: str) -> SwRecordLayoutV:
@@ -2211,7 +2272,14 @@ class ARXMLParser(AbstractARXMLParser):
                     .setSwRecordLayoutVAxis(self.getChildElementOptionalLiteral(child_element, "SW-RECORD-LAYOUT-V-AXIS")) \
                     .setSwRecordLayoutVProp(self.getChildElementOptionalLiteral(child_element, "SW-RECORD-LAYOUT-V-PROP")) \
                     .setSwRecordLayoutVIndex(self.getChildElementOptionalLiteral(child_element, "SW-RECORD-LAYOUT-V-INDEX"))
+            #print(layout_v.getShortLabel())
         return layout_v
+    
+    def readSwRecordLayoutGroupSwRecordLayoutGroupContentType(self, element: ET.Element, group: SwRecordLayoutGroup):
+        content = SwRecordLayoutGroupContent()
+        content.setSwRecordLayoutGroup(self.getSwRecordLayoutGroup(element, "SW-RECORD-LAYOUT-GROUP")) \
+               .setSwRecordLayoutV(self.getSwRecordLayoutV(element, "SW-RECORD-LAYOUT-V"))
+        group.setSwRecordLayoutGroupContentType(content)
 
     def getSwRecordLayoutGroup(self, element: ET.Element, key: str) -> SwRecordLayoutGroup:
         child_element = element.find("./xmlns:%s" % key, self.nsmap)
@@ -2219,22 +2287,14 @@ class ARXMLParser(AbstractARXMLParser):
         if child_element is not None:
             group = SwRecordLayoutGroup()
             group.setShortLabel(self.getChildElementOptionalLiteral(child_element, "SHORT-LABEL")) \
-                 .setCategory(self.getChildElementOptionalLiteral(child_element, "CATEGORY")) \
-                 .setSwRecordLayoutGroupAxis(self.getChildElementOptionalLiteral(child_element, "SW-RECORD-LAYOUT-GROUP-AXIS")) \
+                 .setCategory(self.getChildElementOptionalLiteral(child_element, "CATEGORY")) 
+            self.readSwRecordLayoutGroupSwRecordLayoutGroupContentType(child_element, group)
+            group.setSwRecordLayoutGroupAxis(self.getChildElementOptionalLiteral(child_element, "SW-RECORD-LAYOUT-GROUP-AXIS")) \
                  .setSwRecordLayoutGroupIndex(self.getChildElementOptionalLiteral(child_element, "SW-RECORD-LAYOUT-GROUP-INDEX")) \
                  .setSwRecordLayoutGroupFrom(self.getChildElementOptionalLiteral(child_element, "SW-RECORD-LAYOUT-GROUP-FROM")) \
                  .setSwRecordLayoutGroupStep(self.getChildElementOptionalIntegerValue(child_element, "SW-RECORD-LAYOUT-GROUP-STEP")) \
-                 .setSwRecordLayoutGroupTo(self.getChildElementOptionalLiteral(child_element, "SW-RECORD-LAYOUT-GROUP-TO")) \
-            
-            group_content = SwRecordLayoutGroupContent()
-            group_content.swRecordLayoutGroup = self.getSwRecordLayoutGroup(child_element, "SW-RECORD-LAYOUT-GROUP")
-            group_content.swRecordLayoutV = self.getSwRecordLayoutV(child_element, "SW-RECORD-LAYOUT-V")
-
-            if group_content.swRecordLayoutGroup is not None:
-                group.setSwRecordLayoutGroupContentType(group_content)
-            elif group_content.swRecordLayoutV is not None:
-                group.setSwRecordLayoutGroupContentType(group_content)
-
+                 .setSwRecordLayoutGroupTo(self.getChildElementOptionalLiteral(child_element, "SW-RECORD-LAYOUT-GROUP-TO"))
+            #print(group.getShortLabel())
         return group
 
     def readSwRecordLayout(self, element: ET.Element, layout: SwRecordLayout):
@@ -2858,37 +2918,169 @@ class ARXMLParser(AbstractARXMLParser):
         self.readDiagnosticServiceTableDiagnosticConnectionRefs(element, table)
         table.setEcuInstanceRef(self.getChildElementOptionalRefType(element, "ECU-INSTANCE-REF"))
 
-    def readMultiplexedIPdu(self, element: ET.Element, i_pdu: MultiplexedIPdu):
-        self.logger.debug("Read MultiplexedIPdu <%s>" % i_pdu.getShortName())
-        self.readIdentifiable(element, i_pdu)
+    def readSegmentPosition(self, element: ET.Element, position: SegmentPosition):
+        position.setSegmentByteOrder(self.getChildElementOptionalLiteral(element, "SEGMENT-BYTE-ORDER")) \
+                .setSegmentLength(self.getChildElementOptionalIntegerValue(element, "SEGMENT-LENGTH")) \
+                .setSegmentPosition(self.getChildElementOptionalIntegerValue(element, "SEGMENT-POSITION"))
+
+    def readMultiplexedPartSegmentPositions(self, element: ET.Element, part: MultiplexedPart):
+        for child_element in self.findall(element, "SEGMENT-POSITIONS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "SEGMENT-POSITION":
+                position = SegmentPosition()
+                self.readSegmentPosition(child_element, position)
+                part.addSegmentPosition(position)
+            else:
+                self.notImplemented("Unsupported DynamicPart <%s>" % tag_name)
+
+    def readMultiplexedPart(self, element: ET.Element, part: MultiplexedPart):
+        self.readMultiplexedPartSegmentPositions(element, part)
+
+    def readDynamicPartAlternative(self, element: ET.Element, alternative: DynamicPartAlternative):
+        alternative.setIPduRef(self.getChildElementOptionalRefType(element, "I-PDU-REF")) \
+                   .setInitialDynamicPart(self.getChildElementOptionalBooleanValue(element, "INITIAL-DYNAMIC-PART")) \
+                   .setSelectorFieldCode(self.getChildElementOptionalIntegerValue(element, "SELECTOR-FIELD-CODE"))
+
+    def readDynamicPartDynamicPartAlternatives(self, element: ET.Element, part: DynamicPart):
+        for child_element in self.findall(element, "DYNAMIC-PART-ALTERNATIVES/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "DYNAMIC-PART-ALTERNATIVE":
+                alternative = DynamicPartAlternative()
+                self.readDynamicPartAlternative(child_element, alternative)
+                part.addDynamicPartAlternative(alternative)
+            else:
+                self.notImplemented("Unsupported DynamicPartAlternative <%s>" % tag_name)
+
+    def readDynamicPart(self, element: ET.Element, part: DynamicPart):
+        self.readMultiplexedPart(element, part)
+        self.readDynamicPartDynamicPartAlternatives(element, part)
+
+    def readMultiplexedIPduDynamicParts(self, element: ET.Element, ipdu: MultiplexedIPdu):
+        for child_element in self.findall(element, "DYNAMIC-PARTS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "DYNAMIC-PART":
+                part = DynamicPart()
+                self.readDynamicPart(child_element, part)
+                ipdu.setDynamicPart(part)
+            else:
+                self.notImplemented("Unsupported DynamicPart <%s>" % tag_name)
 
-    def readUserDefinedIPdu(self, element: ET.Element, i_pdu: UserDefinedIPdu):
-        self.logger.debug("Read UserDefinedIPdu <%s>" % i_pdu.getShortName())
-        self.readIdentifiable(element, i_pdu)
+    def readStaticPart(self, element: ET.Element, part: StaticPart):
+        self.readMultiplexedPart(element, part)
+        part.setIPduRef(self.getChildElementOptionalRefType(element, "I-PDU-REF"))
+
+    def readMultiplexedIPduStaticParts(self, element: ET.Element, ipdu: MultiplexedIPdu):
+        for child_element in self.findall(element, "STATIC-PARTS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "STATIC-PART":
+                part = StaticPart()
+                self.readStaticPart(child_element, part)
+                ipdu.setStaticPart(part)
+            else:
+                self.notImplemented("Unsupported StaticPart <%s>" % tag_name)
+
+    def readMultiplexedIPdu(self, element: ET.Element, ipdu: MultiplexedIPdu):
+        self.logger.debug("Read MultiplexedIPdu <%s>" % ipdu.getShortName())
+        self.readIPdu(element, ipdu)
+        self.readMultiplexedIPduDynamicParts(element, ipdu)
+        ipdu.setSelectorFieldByteOrder(self.getChildElementOptionalLiteral(element, "SELECTOR-FIELD-BYTE-ORDER")) \
+            .setSelectorFieldLength(self.getChildElementOptionalIntegerValue(element, "SELECTOR-FIELD-LENGTH")) \
+            .setSelectorFieldStartPosition(self.getChildElementOptionalIntegerValue(element, "SELECTOR-FIELD-START-POSITION"))
+        self.readMultiplexedIPduStaticParts(element, ipdu)
+        ipdu.setTriggerMode(self.getChildElementOptionalLiteral(element, "TRIGGER-MODE")) \
+            .setUnusedBitPattern(self.getChildElementOptionalIntegerValue(element, "UNUSED-BIT-PATTERN"))
+
+    def readUserDefinedIPdu(self, element: ET.Element, ipdu: UserDefinedIPdu):
+        self.logger.debug("Read UserDefinedIPdu <%s>" % ipdu.getShortName())
+        self.readIPdu(element, ipdu)
+        ipdu.setCddType(self.getChildElementOptionalLiteral(element, "CDD-TYPE"))
 
     def readUserDefinedPdu(self, element: ET.Element, pdu: UserDefinedPdu):
         self.logger.debug("Read UserDefinedPdu <%s>" % pdu.getShortName())
-        self.readIdentifiable(element, pdu)
+        self.readPdu(element, pdu)
+        pdu.setCddType(self.getChildElementOptionalLiteral(element, "CDD-TYPE"))
 
     def readGeneralPurposePdu(self, element: ET.Element, pdu: GeneralPurposePdu):
         self.logger.debug("Read GeneralPurposePdu <%s>" % pdu.getShortName())
-        self.readIdentifiable(element, pdu)
+        self.readPdu(element, pdu)
 
     def readGeneralPurposeIPdu(self, element: ET.Element, i_pdu: GeneralPurposeIPdu):
         self.logger.debug("Read GeneralPurposeIPdu <%s>" % i_pdu.getShortName())
-        self.readIdentifiable(element, i_pdu)
+        self.readIPdu(element, i_pdu)
+
+    def readSecureCommunicationAuthenticationProps(self, element: ET.Element, props: SecureCommunicationAuthenticationProps):
+        self.readIdentifiable(element, props)
+        props.setAuthAlgorithm(self.getChildElementOptionalLiteral(element, "AUTH-ALGORITHM")) \
+             .setAuthInfoTxLength(self.getChildElementOptionalPositiveInteger(element, "AUTH-INFO-TX-LENGTH"))
+
+    def readSecureCommunicationPropsSetAuthenticationProps(self, element: ET.Element, props_set: SecureCommunicationPropsSet):
+        for child_element in self.findall(element, "AUTHENTICATION-PROPSS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "SECURE-COMMUNICATION-AUTHENTICATION-PROPS":
+                props = props_set.createSecureCommunicationAuthenticationProps(self.getShortName(child_element))
+                self.readSecureCommunicationAuthenticationProps(child_element, props)
+            else:
+                self.notImplemented("Unsupported AuthenticationProps <%s>" % tag_name)
+
+    def readSecureCommunicationFreshnessProps(self, element: ET.Element, props: SecureCommunicationFreshnessProps):
+        self.readIdentifiable(element, props)
+        props.setFreshnessValueLength(self.getChildElementOptionalLiteral(element, "FRESHNESS-VALUE-LENGTH")) \
+             .setFreshnessValueTxLength(self.getChildElementOptionalPositiveInteger(element, "FRESHNESS-VALUE-TX-LENGTH"))
+
+    def readSecureCommunicationPropsSetFreshnessProps(self, element: ET.Element, props_set: SecureCommunicationPropsSet):
+        for child_element in self.findall(element, "FRESHNESS-PROPSS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "SECURE-COMMUNICATION-FRESHNESS-PROPS":
+                props = props_set.createSecureCommunicationFreshnessProps(self.getShortName(child_element))
+                self.readSecureCommunicationFreshnessProps(child_element, props)
+            else:
+                self.notImplemented("Unsupported FreshnessProps <%s>" % tag_name)
 
     def readSecureCommunicationPropsSet(self, element: ET.Element, props_set: SecureCommunicationPropsSet):
         self.logger.debug("Read SecureCommunicationPropsSet <%s>" % props_set.getShortName())
         self.readIdentifiable(element, props_set)
-
+        self.readSecureCommunicationPropsSetAuthenticationProps(element, props_set)
+        self.readSecureCommunicationPropsSetFreshnessProps(element, props_set)
+    
     def readSoAdRoutingGroup(self, element: ET.Element, group: SoAdRoutingGroup):
         self.logger.debug("Read SoAdRoutingGroup <%s>" % group.getShortName())
         self.readIdentifiable(element, group)
+        group.setEventGroupControlType(self.getChildElementOptionalLiteral(element, "EVENT-GROUP-CONTROL-TYPE"))
+
+    def readDoIpLogicAddress(self, element: ET.Element, address: DoIpLogicAddress):
+        self.readIdentifiable(element, address)
+        address.setAddress(self.getChildElementOptionalIntegerValue(element, "ADDRESS"))
+
+    def readDoIpTpConfigDoIpLogicAddresses(self, element: ET.Element, config: DoIpTpConfig):
+        for child_element in self.findall(element, "DO-IP-LOGIC-ADDRESSS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "DO-IP-LOGIC-ADDRESS":
+                address = config.createDoIpLogicAddress(self.getShortName(child_element))
+                self.readDoIpLogicAddress(child_element, address)
+            else:
+                self.notImplemented("Unsupported DoIpLogicAddress <%s>" % tag_name)
+
+    def readDoIpTpConnection(self, element: ET.Element, connection: DoIpTpConnection):
+        self.readTpConnection(element, connection)
+        connection.setDoIpSourceAddressRef(self.getChildElementOptionalRefType(element, "DO-IP-SOURCE-ADDRESS-REF")) \
+                  .setDoIpTargetAddressRef(self.getChildElementOptionalRefType(element, "DO-IP-TARGET-ADDRESS-REF")) \
+                  .setTpSduRef(self.getChildElementOptionalRefType(element, "TP-SDU-REF"))
+
+    def readDoIpTpConfigTpConnections(self, element: ET.Element, config: DoIpTpConfig):
+        for child_element in self.findall(element, "TP-CONNECTIONS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "DO-IP-TP-CONNECTION":
+                connection = DoIpTpConnection()
+                self.readDoIpTpConnection(child_element, connection)
+                config.addTpConnection(connection)
+            else:
+                self.notImplemented("Unsupported TpConnection <%s>" % tag_name)
 
     def readDoIpTpConfig(self, element: ET.Element, config: DoIpTpConfig):
         self.logger.debug("Read DoIpTpConfig <%s>" % config.getShortName())
-        self.readIdentifiable(element, config)
+        self.readTpConfig(element, config)
+        self.readDoIpTpConfigDoIpLogicAddresses(element, config)
+        self.readDoIpTpConfigTpConnections(element, config)
 
     def readPduToFrameMappings(self, element: ET.Element, parent: Frame):
         for child_element in self.findall(element, "PDU-TO-FRAME-MAPPINGS/PDU-TO-FRAME-MAPPING"):
@@ -2909,82 +3101,125 @@ class ARXMLParser(AbstractARXMLParser):
         self.logger.debug("Read LinUnconditionalFrame <%s>" % frame.getShortName())
         self.readFrame(element, frame)
 
+    def readPdu(self, element: ET.Element, pdu: Pdu):
+        self.readIdentifiable(element, pdu)
+        pdu.setHasDynamicLength(self.getChildElementOptionalBooleanValue(element, "HAS-DYNAMIC-LENGTH")) \
+           .setLength(self.getChildElementOptionalNumericalValue(element, "LENGTH"))
+        
+    def readISignalToIPduMapping(self, element: ET.Element, mapping: ISignalToIPduMapping):
+        self.readIdentifiable(element, mapping)
+        mapping.setISignalRef(self.getChildElementOptionalRefType(element, "I-SIGNAL-REF")) \
+               .setPackingByteOrder(self.getChildElementOptionalLiteral(element, "PACKING-BYTE-ORDER")) \
+               .setStartPosition(self.getChildElementOptionalIntegerValue(element, "START-POSITION")) \
+               .setTransferProperty(self.getChildElementOptionalLiteral(element, "TRANSFER-PROPERTY"))
+        
+    def readNmPduISignalToIPduMappings(self, element: ET.Element, pdu: NmPdu):
+        for child_element in self.findall(element, "I-SIGNAL-TO-I-PDU-MAPPINGS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "I-SIGNAL-TO-I-PDU-MAPPING":
+                mapping = pdu.createISignalToIPduMapping(self.getShortName(child_element))
+                self.readISignalToIPduMapping(child_element, mapping)
+            else:
+                self.notImplemented("Unsupported ISignalToIPduMapping <%s>" % tag_name)
+
     def readNmPdu(self, element: ET.Element, pdu: NmPdu):
         self.logger.debug("Read NmPdu <%s>" % pdu.getShortName())
-        self.readIPdu(element, pdu)
+        self.readPdu(element, pdu)
+        self.readNmPduISignalToIPduMappings(element, pdu)
+        pdu.setUnusedBitPattern(self.getChildElementOptionalIntegerValue(element, "UNUSED-BIT-PATTERN"))
+
+    def readIPdu(self, element: ET.Element, pdu: IPdu):
+        self.readPdu(element, pdu)
 
     def readNPdu(self, element: ET.Element, pdu: NPdu):
         self.logger.debug("Read NPdu <%s>" % pdu.getShortName())
         self.readIPdu(element, pdu)
 
-    def readIPdu(self, element: ET.Element, pdu: IPdu):
-        self.readIdentifiable(element, pdu)
-        pdu.setLength(self.getChildElementOptionalNumericalValue(element, "LENGTH"))
-        
     def readDcmIPdu(self, element: ET.Element, i_pdu: DcmIPdu):
         self.logger.debug("Read DcmIPdu <%s>" % i_pdu.getShortName())
         self.readIPdu(element, i_pdu)
         i_pdu.setDiagPduType(self.getChildElementOptionalLiteral(element, "DIAG-PDU-TYPE"))
 
+    def getSecureCommunicationProps(self, element: ET.Element, key: str) -> SecureCommunicationProps:
+        props = None
+        child_element = self.find(element, key)
+        if child_element is not None:
+            props = SecureCommunicationProps()
+            props.setAuthDataFreshnessLength(self.getChildElementOptionalPositiveInteger(child_element, "AUTH-DATA-FRESHNESS-LENGTH")) \
+                 .setAuthDataFreshnessStartPosition(self.getChildElementOptionalPositiveInteger(child_element, "AUTH-DATA-FRESHNESS-START-POSITION")) \
+                 .setAuthInfoTxLength(self.getChildElementOptionalPositiveInteger(child_element, "AUTH-INFO-TX-LENGTH")) \
+                 .setAuthenticationBuildAttempts(self.getChildElementOptionalPositiveInteger(child_element, "AUTHENTICATION-BUILD-ATTEMPTS")) \
+                 .setAuthenticationRetries(self.getChildElementOptionalPositiveInteger(child_element, "AUTHENTICATION-RETRIES")) \
+                 .setDataId(self.getChildElementOptionalPositiveInteger(child_element, "DATA-ID")) \
+                 .setFreshnessValueId(self.getChildElementOptionalPositiveInteger(child_element, "FRESHNESS-VALUE-ID")) \
+                 .setFreshnessValueLength(self.getChildElementOptionalPositiveInteger(child_element, "FRESHNESS-VALUE-LENGTH")) \
+                 .setFreshnessValueTxLength(self.getChildElementOptionalPositiveInteger(child_element, "FRESHNESS-VALUE-TX-LENGTH"))
+        return props
+
     def readSecuredIPdu(self, element: ET.Element, i_pdu: SecuredIPdu):
         self.logger.debug("Read SecuredIPdu <%s>" % i_pdu.getShortName())
         self.readIPdu(element, i_pdu)
+        i_pdu.setAuthenticationPropsRef(self.getChildElementOptionalRefType(element, "AUTHENTICATION-PROPS-REF")) \
+             .setFreshnessPropsRef(self.getChildElementOptionalRefType(element, "FRESHNESS-PROPS-REF")) \
+             .setPayloadRef(self.getChildElementOptionalRefType(element, "PAYLOAD-REF")) \
+             .setSecureCommunicationProps(self.getSecureCommunicationProps(element, "SECURE-COMMUNICATION-PROPS")) \
+             .setUseAsCryptographicIPdu(self.getChildElementOptionalBooleanValue(element, "USE-AS-CRYPTOGRAPHIC-I-PDU"))
 
     def readNmNode(self, element: ET.Element, nm_node: NmNode):
         self.readIdentifiable(element, nm_node)
 
         nm_node.setControllerRef(self.getChildElementOptionalRefType(element, "CONTROLLER-REF")) \
-            .setNmIfEcuRef(self.getChildElementOptionalRefType(element, "NM-IF-ECU-REF")) \
-            .setNmNodeId(self.getChildElementOptionalNumericalValue(element, "NM-NODE-ID"))
+               .setNmIfEcuRef(self.getChildElementOptionalRefType(element, "NM-IF-ECU-REF")) \
+               .setNmPassiveModeEnabled(self.getChildElementOptionalBooleanValue(element, "NM-PASSIVE-MODE-ENABLED")) \
+               .setNmNodeId(self.getChildElementOptionalNumericalValue(element, "NM-NODE-ID"))
         for ref in self.getChildElementRefTypeList(element, "RX-NM-PDU-REFS/RX-NM-PDU-REF"):
             nm_node.addRxNmPduRef(ref)
         for ref in self.getChildElementRefTypeList(element, "TX-NM-PDU-REFS/TX-NM-PDU-REF"):
             nm_node.addTxNmPduRefs(ref)
+        
 
     def readCanNmNode(self, element: ET.Element, nm_node: CanNmNode):
-        self.logger.debug("Read CanNmNode %s" % nm_node.getShortName())
-        
+        self.logger.debug("Read CanNmNode <%s>" % nm_node.getShortName())
         self.readNmNode(element, nm_node)
-
-        nm_node.setNmMsgCycleOffset(self.getChildElementOptionalFloatValue(element, "NM-MSG-CYCLE-OFFSET")) \
+        nm_node.setNmCarWakeUpRxEnabled(self.getChildElementOptionalBooleanValue(element, "NM-CAR-WAKE-UP-RX-ENABLED")) \
+               .setNmMsgCycleOffset(self.getChildElementOptionalFloatValue(element, "NM-MSG-CYCLE-OFFSET")) \
                .setNmMsgReducedTime(self.getChildElementOptionalFloatValue(element, "NM-MSG-REDUCED-TIME")) \
                .setNmRangeConfig(self.getChildElementRxIdentifierRange(element, "NM-RANGE-CONFIG"))
         
     def readUdpNmNode(self, element: ET.Element, nm_node: UdpNmNode):
-        self.logger.debug("Read UdpNmNode %s" % nm_node.getShortName())
-        
+        self.logger.debug("Read UdpNmNode <%s>" % nm_node.getShortName())
         self.readNmNode(element, nm_node)
+        nm_node.setNmMsgCycleOffset(self.getChildElementOptionalTimeValue(element, "NM-MSG-CYCLE-OFFSET"))
 
-    def readNmClusterNmNodes(self, element: ET.Element, parent: NmCluster):
-        self.logger.debug("readNmConfigNmNodes %s" % parent.getShortName())
+    def readNmClusterNmNodes(self, element: ET.Element, cluster: NmCluster):
+        self.logger.debug("readNmConfigNmNodes %s" % cluster.getShortName())
         for child_element in self.findall(element, "NM-NODES/*"):
             tag_name = self.getTagName(child_element)
             if tag_name == "CAN-NM-NODE":
-                nm_node = parent.createCanNmNode(self.getShortName(child_element))
+                nm_node = cluster.createCanNmNode(self.getShortName(child_element))
                 self.readCanNmNode(child_element, nm_node)
             elif tag_name == "UDP-NM-NODE":
-                nm_node = parent.readUdpNmNode(self.getShortName(child_element))
+                nm_node = cluster.readUdpNmNode(self.getShortName(child_element))
                 self.readUdpNmNode(child_element, nm_node)
             else:
-                self.raiseError("Unsupported Nm Node <%s>" % tag_name)
+                self.notImplemented("Unsupported Nm Node <%s>" % tag_name)
 
     def getCanNmClusterCoupling(self, element: ET.Element) -> CanNmClusterCoupling:
         coupling  = CanNmClusterCoupling()
-        
         for ref in self.getChildElementRefTypeList(element, "COUPLED-CLUSTER-REFS/COUPLED-CLUSTER-REF"):
             coupling.addCoupledClusterRef(ref)
-
         coupling.setNmBusloadReductionEnabled(self.getChildElementOptionalBooleanValue(element, "NM-BUSLOAD-REDUCTION-ENABLED")) \
                 .setNmImmediateRestartEnabled(self.getChildElementOptionalBooleanValue(element, "NM-IMMEDIATE-RESTART-ENABLED"))
-    
         return coupling
     
     def getUdpNmClusterCoupling(self, element: ET.Element) -> UdpNmClusterCoupling:
         coupling = UdpNmClusterCoupling()
+        for ref in self.getChildElementRefTypeList(element, "COUPLED-CLUSTER-REFS/COUPLED-CLUSTER-REF"):
+            coupling.addCoupledClusterRef(ref)
+        coupling.setNmImmediateRestartEnabled(self.getChildElementOptionalBooleanValue(element, "NM-IMMEDIATE-RESTART-ENABLED"))
         return coupling
 
     def readNmConfigNmClusterCouplings(self, element: ET.Element, nm_config: NmConfig):
-        self.logger.debug("readNmClusterNmClusterCouplings %s" % nm_config.getShortName())
         for child_element in self.findall(element, "NM-CLUSTER-COUPLINGS/*"):
             tag_name = self.getTagName(child_element)
             if tag_name == "CAN-NM-CLUSTER-COUPLING":
@@ -2995,6 +3230,7 @@ class ARXMLParser(AbstractARXMLParser):
                 self.notImplemented("Unsupported Nm Node <%s>" % tag_name)
 
     def readNmCluster(self, element: ET.Element, cluster: NmCluster):
+        self.logger.debug("read NmCluster %s" % cluster.getShortName())
         self.readIdentifiable(element, cluster)
         cluster.setCommunicationClusterRef(self.getChildElementOptionalRefType(element, "COMMUNICATION-CLUSTER-REF")) \
                .setNmChannelId(self.getChildElementOptionalNumericalValue(element, "NM-CHANNEL-ID")) \
@@ -3002,12 +3238,9 @@ class ARXMLParser(AbstractARXMLParser):
         self.readNmClusterNmNodes(element, cluster)
         cluster.setNmSynchronizingNetwork(self.getChildElementOptionalBooleanValue(element, "NM-SYNCHRONIZING-NETWORK"))
 
-    def readCanNmCluster(self, element: ET.Element, parent: NmConfig):
-        short_name = self.getShortName(element)
-        self.logger.debug("readCanNmCluster %s" % short_name)
-        cluster = parent.createCanNmCluster(short_name)         # type: CanNmCluster
+    def readCanNmCluster(self, element: ET.Element, cluster: CanNmCluster):
+        self.logger.debug("Read CanNmCluster <%s>" % cluster.getShortName())
         self.readNmCluster(element, cluster)
-
         cluster.setNmBusloadReductionActive(self.getChildElementOptionalBooleanValue(element, "NM-BUSLOAD-REDUCTION-ACTIVE")) \
                .setNmCarWakeUpRxEnabled(self.getChildElementOptionalBooleanValue(element, "NM-CAR-WAKE-UP-RX-ENABLED")) \
                .setNmCbvPosition(self.getChildElementOptionalNumericalValue(element, "NM-CBV-POSITION")) \
@@ -3023,35 +3256,247 @@ class ARXMLParser(AbstractARXMLParser):
                .setNmUserDataLength(self. getChildElementOptionalNumericalValue(element, "NM-USER-DATA-LENGTH")) \
                .setNmWaitBusSleepTime(self.getChildElementOptionalFloatValue(element, "NM-WAIT-BUS-SLEEP-TIME"))
         
-    def readUdpNmCluster(self, element: ET.Element, parent: NmConfig):
-        short_name = self.getShortName(element)
-        self.logger.debug("readCanNmCluster %s" % short_name)
-        cluster = parent.createUdpNmCluster(short_name)         # type: CanNmCluster
+    def readUdpNmCluster(self, element: ET.Element, cluster: UdpNmCluster):
+        self.logger.debug("Read UdpNmCluster %s" % cluster.getShortName())
         self.readNmCluster(element, cluster)
+        cluster.setNmCbvPosition(self.getChildElementOptionalIntegerValue(element, "NM-CBV-POSITION")) \
+               .setNmChannelActive(self.getChildElementOptionalBooleanValue(element, "NM-CHANNEL-ACTIVE")) \
+               .setNmImmediateNmCycleTime(self.getChildElementOptionalTimeValue(element, "NM-IMMEDIATE-NM-CYCLE-TIME")) \
+               .setNmImmediateNmTransmissions(self.getChildElementOptionalPositiveInteger(element, "NM-IMMEDIATE-NM-TRANSMISSIONS")) \
+               .setNmMessageTimeoutTime(self.getChildElementOptionalTimeValue(element, "NM-MESSAGE-TIMEOUT-TIME")) \
+               .setNmMsgCycleTime(self.getChildElementOptionalTimeValue(element, "NM-MSG-CYCLE-TIME")) \
+               .setNmNetworkTimeout(self.getChildElementOptionalTimeValue(element, "NM-NETWORK-TIMEOUT")) \
+               .setNmNidPosition(self.getChildElementOptionalIntegerValue(element, "NM-NID-POSITION")) \
+               .setNmRemoteSleepIndicationTime(self.getChildElementOptionalTimeValue(element, "NM-REMOTE-SLEEP-INDICATION-TIME")) \
+               .setNmRepeatMessageTime(self.getChildElementOptionalTimeValue(element, "NM-REPEAT-MESSAGE-TIME")) \
+               .setNmWaitBusSleepTime(self.getChildElementOptionalTimeValue(element, "NM-WAIT-BUS-SLEEP-TIME")) \
+               .setVlanRef(self.getChildElementOptionalRefType(element, "VLAN-REF"))
         
-    def readNmConfigNmClusters(self, element: ET.Element, parent: NmConfig):
+    def readNmConfigNmClusters(self, element: ET.Element, nm_config: NmConfig):
         for child_element in self.findall(element, "NM-CLUSTERS/*"):
             tag_name = self.getTagName(child_element)
             if tag_name == "CAN-NM-CLUSTER":
-                self.readCanNmCluster(child_element, parent)
+                cluster = nm_config.createCanNmCluster(self.getShortName(child_element))
+                self.readCanNmCluster(child_element, cluster)
             elif tag_name == "UDP-NM-CLUSTER":
-                self.readUdpNmCluster(child_element, parent)
+                cluster = nm_config.createUdpNmCluster(self.getShortName(child_element))
+                self.readUdpNmCluster(child_element, cluster)
             else:
                 self.raiseError("Unsupported Nm Cluster <%s>" % tag_name)
+
+    def readUdpNmEcu(self, element: ET.Element, ecu: UdpNmEcu):
+        ecu.setNmSynchronizationPointEnabled(self.getChildElementOptionalBooleanValue(element, "NM-SYNCHRONIZATION-POINT-ENABLED"))
+
+    def readBusDependentNmEcus(self, element: ET.Element, nm_ecu: NmEcu):
+        for child_element in self.findall(element, "BUS-DEPENDENT-NM-ECUS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "UDP-NM-ECU":
+                udp_nm_ecu = UdpNmEcu()
+                self.readUdpNmEcu(child_element, udp_nm_ecu)
+                nm_ecu.addBusDependentNmEcu(udp_nm_ecu)
+            else:
+                self.notImplemented("Unsupported BusDependentNmEcu <%s>" % tag_name)
+
+    def readNmEcu(self, element: ET.Element, nm_ecu: NmEcu):
+        self.readIdentifiable(element, nm_ecu)
+        self.readBusDependentNmEcus(element, nm_ecu)
+        nm_ecu.setEcuInstanceRef(self.getChildElementOptionalRefType(element, "ECU-INSTANCE-REF")) \
+              .setNmBusSynchronizationEnabled(self.getChildElementOptionalBooleanValue(element, "NM-BUS-SYNCHRONIZATION-ENABLED")) \
+              .setNmComControlEnabled(self.getChildElementOptionalBooleanValue(element, "NM-COM-CONTROL-ENABLED")) \
+              .setNmNodeDetectionEnabled(self.getChildElementOptionalBooleanValue(element, "NM-NODE-DETECTION-ENABLED")) \
+              .setNmNodeIdEnabled(self.getChildElementOptionalBooleanValue(element, "NM-NODE-ID-ENABLED")) \
+              .setNmPduRxIndicationEnabled(self.getChildElementOptionalBooleanValue(element, "NM-PDU-RX-INDICATION-ENABLED")) \
+              .setNmRemoteSleepIndEnabled(self.getChildElementOptionalBooleanValue(element, "NM-REMOTE-SLEEP-IND-ENABLED")) \
+              .setNmRepeatMsgIndEnabled(self.getChildElementOptionalBooleanValue(element, "NM-REPEAT-MSG-IND-ENABLED")) \
+              .setNmStateChangeIndEnabled(self.getChildElementOptionalBooleanValue(element, "NM-STATE-CHANGE-IND-ENABLED")) \
+              .setNmUserDataEnabled(self.getChildElementOptionalBooleanValue(element, "NM-USER-DATA-ENABLED"))
+
+    def readNmConfigNmIfEcus(self, element: ET.Element, nm_config: NmConfig):
+        for child_element in self.findall(element, "NM-IF-ECUS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "NM-ECU":
+                ecu = nm_config.createNmEcu(self.getShortName(child_element))
+                self.readNmEcu(child_element, ecu)
+            else:
+                self.notImplemented("Unsupported NmIfEcus <%s>" % tag_name)
     
     def readNmConfig(self, element: ET.Element, config: NmConfig):
         self.logger.debug("Read NmConfig <%s>" % config.getShortName())
         self.readIdentifiable(element, config)
         self.readNmConfigNmClusters(element, config)
         self.readNmConfigNmClusterCouplings(element, config)
+        self.readNmConfigNmIfEcus(element, config)
+
+    def readTpConfig(self, element: ET.Element, config: TpConfig):
+        self.readIdentifiable(element, config)
+        config.setCommunicationClusterRef(self.getChildElementOptionalRefType(element, "COMMUNICATION-CLUSTER-REF"))
+
+    def readCanTpAddress(self, element: ET.Element, address: CanTpAddress):
+        self.readIdentifiable(element, address)
+        address.setTpAddress(self.getChildElementOptionalIntegerValue(element, "TP-ADDRESS")) \
+               .setTpAddressExtensionValue(self.getChildElementOptionalIntegerValue(element, "TP-ADDRESS-EXTENSION-VALUE"))
+
+    def readCanTpConfigTpAddresses(self, element: ET.Element, config: CanTpConfig):
+        for child_element in self.findall(element, "TP-ADDRESSS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "CAN-TP-ADDRESS":
+                address = config.createCanTpAddress(self.getShortName(child_element))
+                self.readCanTpAddress(child_element, address)
+            else:
+                self.notImplemented("Unsupported TpAddress <%s>" % tag_name)
+
+    def readCanTpChannel(self, element: ET.Element, channel: CanTpChannel):
+        self.readIdentifiable(element, channel)
+        channel.setChannelId(self.getChildElementOptionalPositiveInteger(element, "CHANNEL-ID")) \
+               .setChannelMode(self.getChildElementOptionalLiteral(element, "CHANNEL-MODE"))
+
+    def readCanTpConfigTpChannels(self, element: ET.Element, config: CanTpConfig):
+        for child_element in self.findall(element, "TP-CHANNELS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "CAN-TP-CHANNEL":
+                channel = config.createCanTpChannel(self.getShortName(child_element))
+                self.readCanTpChannel(child_element, channel)
+            else:
+                self.notImplemented("Unsupported TpChannel <%s>" % tag_name)
+
+    def readTpConnection(self, element: ET.Element, connection: TpConnection):
+        self.readARObjectAttributes(element, connection)
+        child_element = self.find(element, "IDENT")
+        if child_element is not None:
+            ident = connection.createTpConnectionIdent(self.getShortName(child_element))
+            self.readReferrable(child_element, ident)
+
+    def readTpConnectionReceiverRefs(self, element: ET.Element, connection: CanTpConnection):
+        for ref in self.getChildElementRefTypeList(element, "RECEIVER-REFS/RECEIVER-REF"):
+            connection.addReceiverRef(ref)
+
+    def readCanTpConnection(self, element: ET.Element, connection: CanTpConnection):
+        self.readTpConnection(element, connection)
+        connection.setAddressingFormat(self.getChildElementOptionalLiteral(element, "ADDRESSING-FORMAT")) \
+                  .setCanTpChannelRef(self.getChildElementOptionalRefType(element, "CAN-TP-CHANNEL-REF")) \
+                  .setCancellation(self.getChildElementOptionalBooleanValue(element, "CANCELLATION")) \
+                  .setDataPduRef(self.getChildElementOptionalRefType(element, "DATA-PDU-REF")) \
+                  .setFlowControlPduRef(self.getChildElementOptionalRefType(element, "FLOW-CONTROL-PDU-REF")) \
+                  .setMaxBlockSize(self.getChildElementOptionalIntegerValue(element, "MAX-BLOCK-SIZE")) \
+                  .setMulticastRef(self.getChildElementOptionalRefType(element, "MULTICAST-REF")) \
+                  .setPaddingActivation(self.getChildElementOptionalBooleanValue(element, "PADDING-ACTIVATION"))
+        self.readTpConnectionReceiverRefs(element, connection)
+        connection.setTaType(self.getChildElementOptionalLiteral(element, "TA-TYPE")) \
+                  .setTimeoutBr(self.getChildElementOptionalTimeValue(element, "TIMEOUT-BR")) \
+                  .setTimeoutBs(self.getChildElementOptionalTimeValue(element, "TIMEOUT-BS")) \
+                  .setTimeoutCr(self.getChildElementOptionalTimeValue(element, "TIMEOUT-CR")) \
+                  .setTimeoutCs(self.getChildElementOptionalTimeValue(element, "TIMEOUT-CS")) \
+                  .setTpSduRef(self.getChildElementOptionalRefType(element, "TP-SDU-REF")) \
+                  .setTransmitterRef(self.getChildElementOptionalRefType(element, "TRANSMITTER-REF"))
+
+    def readCanTpConfigTpConnections(self, element: ET.Element, config: CanTpConfig):
+        for child_element in self.findall(element, "TP-CONNECTIONS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "CAN-TP-CONNECTION":
+                connection = CanTpConnection()
+                self.readCanTpConnection(child_element, connection)
+                config.addTpConnection(connection)
+            else:
+                self.notImplemented("Unsupported TpConnection <%s>" % tag_name)
+
+    def readCanTpEcu(self, element: ET.Element, tp_ecu: CanTpEcu):
+        tp_ecu.setCycleTimeMainFunction(self.getChildElementOptionalTimeValue(element, "CYCLE-TIME-MAIN-FUNCTION")) \
+              .setEcuInstanceRef(self.getChildElementOptionalRefType(element, "ECU-INSTANCE-REF")) 
+
+    def readCanTpConfigTpEcus(self, element: ET.Element, config: CanTpConfig):
+        for child_element in self.findall(element, "TP-ECUS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "CAN-TP-ECU":
+                tp_ecu = CanTpEcu()
+                self.readCanTpEcu(child_element, tp_ecu)
+                config.addTpEcu(tp_ecu)
+            else:
+                self.notImplemented("Unsupported TpEcu <%s>" % tag_name)
+
+    def readCanTpNode(self, element: ET.Element, tp_node: CanTpNode):
+        self.readIdentifiable(element, tp_node)
+        tp_node.setConnectorRef(self.getChildElementOptionalRefType(element, "CONNECTOR-REF")) \
+               .setMaxFcWait(self.getChildElementOptionalIntegerValue(element, "MAX-FC-WAIT")) \
+               .setStMin(self.getChildElementOptionalTimeValue(element, "ST-MIN")) \
+               .setTimeoutAr(self.getChildElementOptionalTimeValue(element, "TIMEOUT-AR")) \
+               .setTimeoutAs(self.getChildElementOptionalTimeValue(element, "TIMEOUT-AS")) \
+               .setTpAddressRef(self.getChildElementOptionalRefType(element, "TP-ADDRESS-REF"))
+
+    def readCanTpConfigTpNodes(self, element: ET.Element, config: CanTpConfig):
+        for child_element in self.findall(element, "TP-NODES/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "CAN-TP-NODE":
+                tp_node = config.createCanTpNode(self.getShortName(child_element))
+                self.readCanTpNode(child_element, tp_node)
+            else:
+                self.notImplemented("Unsupported TpNode <%s>" % tag_name)
 
     def readCanTpConfig(self, element: ET.Element, config: CanTpConfig):
         self.logger.debug("Read CanTpConfig <%s>" % config.getShortName())
-        self.readIdentifiable(element, config)
+        self.readTpConfig(element, config)
+        self.readCanTpConfigTpAddresses(element, config)
+        self.readCanTpConfigTpChannels(element, config)
+        self.readCanTpConfigTpConnections(element, config)
+        self.readCanTpConfigTpEcus(element, config)
+        self.readCanTpConfigTpNodes(element, config)
+
+    def readTpAddress(self, element: ET.Element, address: TpAddress):
+        self.readIdentifiable(element, address)
+        address.setTpAddress(self.getChildElementOptionalIntegerValue(element, "TP-ADDRESS"))
+
+    def readLinTpConfigTpAddresses(self, element: ET.Element, config: LinTpConfig):
+        for child_element in self.findall(element, "TP-ADDRESSS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "TP-ADDRESS":
+                address = config.createTpAddress(self.getShortName(child_element))
+                self.readTpAddress(child_element, address)
+            else:
+                self.notImplemented("Unsupported TpAddress <%s>" % tag_name)
+
+    def readLinTpConnection(self, element: ET.Element, connection: LinTpConnection):
+        self.readTpConnection(element, connection)
+        connection.setDataPduRef(self.getChildElementOptionalRefType(element, "DATA-PDU-REF")) \
+                  .setFlowControlRef(self.getChildElementOptionalRefType(element, "FLOW-CONTROL-REF")) \
+                  .setLinTpNSduRef(self.getChildElementOptionalRefType(element, "LIN-TP-N-SDU-REF")) 
+        self.readTpConnectionReceiverRefs(element, connection)
+        connection.setTimeoutAs(self.getChildElementOptionalTimeValue(element, "TIMEOUT-AS")) \
+                  .setTimeoutCr(self.getChildElementOptionalTimeValue(element, "TIMEOUT-CR")) \
+                  .setTimeoutCs(self.getChildElementOptionalTimeValue(element, "TIMEOUT-CS")) \
+                  .setTransmitterRef(self.getChildElementOptionalRefType(element, "TRANSMITTER-REF"))
+
+    def readLinTpConfigTpConnections(self, element: ET.Element, config: LinTpConfig):
+        for child_element in self.findall(element, "TP-CONNECTIONS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "LIN-TP-CONNECTION":
+                connection = LinTpConnection()
+                self.readLinTpConnection(child_element, connection)
+                config.addTpConnection(connection)
+            else:
+                self.notImplemented("Unsupported TpConnection <%s>" % tag_name)
+
+    def readLinTpNode(self, element: ET.Element, tp_node: LinTpNode):
+        self.readIdentifiable(element, tp_node)
+        tp_node.setConnectorRef(self.getChildElementOptionalRefType(element, "CONNECTOR-REF")) \
+               .setDropNotRequestedNad(self.getChildElementOptionalBooleanValue(element, "DROP-NOT-REQUESTED-NAD")) \
+               .setP2Max(self.getChildElementOptionalTimeValue(element, "P-2-MAX")) \
+               .setP2Timing(self.getChildElementOptionalTimeValue(element, "P-2-TIMING")) \
+               .setTpAddressRef(self.getChildElementOptionalRefType(element, "TP-ADDRESS-REF"))
+
+    def readLinTpConfigTpNodes(self, element: ET.Element, config: LinTpConfig):
+        for child_element in self.findall(element, "TP-NODES/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "LIN-TP-NODE":
+                tp_node = config.createLinTpNode(self.getShortName(child_element))
+                self.readLinTpNode(child_element, tp_node)
+            else:
+                self.notImplemented("Unsupported TpNode <%s>" % tag_name)
 
     def readLinTpConfig(self, element: ET.Element, config: LinTpConfig):
         self.logger.debug("Read LinTpConfig <%s>" % config.getShortName())
-        self.readIdentifiable(element, config)
+        self.readTpConfig(element, config)
+        self.readLinTpConfigTpAddresses(element, config)
+        self.readLinTpConfigTpConnections(element, config)
+        self.readLinTpConfigTpNodes(element, config)
 
     def readCanFrame(self, element: ET.Element, frame: CanFrame):
         self.logger.debug("Read CanFrame <%s>" % frame.getShortName())
@@ -3272,9 +3717,14 @@ class ARXMLParser(AbstractARXMLParser):
     def readCanCommunicationConnector(self, element: ET.Element, connector: CanCommunicationConnector):
         self.readCommunicationConnector(element, connector)
 
+    def readEthernetCommunicationConnectorNetworkEndpointRefs(self, element: ET.Element, connector: EthernetCommunicationConnector):
+        for ref in self.getChildElementRefTypeList(element, "NETWORK-ENDPOINT-REFS/NETWORK-ENDPOINT-REF"):
+            connector.addNetworkEndpointRef(ref)
+
     def readEthernetCommunicationConnector(self, element: ET.Element, connector: EthernetCommunicationConnector):
         self.readCommunicationConnector(element, connector)
         connector.setMaximumTransmissionUnit(self.getChildElementOptionalPositiveInteger(element, "MAXIMUM-TRANSMISSION-UNIT"))
+        self.readEthernetCommunicationConnectorNetworkEndpointRefs(element, connector)
 
     def readLinCommunicationConnector(self, element: ET.Element, connector: LinCommunicationConnector):
         self.readCommunicationConnector(element, connector)
@@ -3309,7 +3759,8 @@ class ARXMLParser(AbstractARXMLParser):
                 .setComEnableMDTForCyclicTransmission(self.getChildElementOptionalBooleanValue(element, "COM-ENABLE-MDT-FOR-CYCLIC-TRANSMISSION"))
         self.readEcuInstanceCommControllers(element, instance)
         self.readEcuInstanceConnectors(element, instance)
-        instance.setSleepModeSupported(self.getChildElementOptionalBooleanValue(element, "SLEEP-MODE-SUPPORTED")) \
+        instance.setDiagnosticAddress(self.getChildElementOptionalIntegerValue(element, "DIAGNOSTIC-ADDRESS")) \
+                .setSleepModeSupported(self.getChildElementOptionalBooleanValue(element, "SLEEP-MODE-SUPPORTED")) \
                 .setWakeUpOverBusSupported(self.getChildElementOptionalBooleanValue(element, "WAKE-UP-OVER-BUS-SUPPORTED"))
 
     '''
@@ -3492,9 +3943,12 @@ class ARXMLParser(AbstractARXMLParser):
     def readPhysicalDimension(self, element: ET.Element, dimension: PhysicalDimension):
         self.logger.debug("Read PhysicalDimension <%s>" % dimension.getShortName())
         self.readIdentifiable(element, dimension)
-        dimension.setCurrentExp(self.getChildElementOptionalNumericalValue(element, "CURRENT-EXP")) \
-                 .setLengthExp(self.getChildElementOptionalNumericalValue(element, "LENGTH-EXP")) \
-                 .setTimeExp(self.getChildElementOptionalNumericalValue(element, "TIME-EXP"))
+        dimension.setLengthExp(self.getChildElementOptionalNumericalValue(element, "LENGTH-EXP")) \
+                 .setLuminousIntensityExp(self.getChildElementOptionalNumericalValue(element, "LUMINOUS-INTENSITY-EXP")) \
+                 .setMassExp(self.getChildElementOptionalNumericalValue(element, "MASS-EXP")) \
+                 .setTemperatureExp(self.getChildElementOptionalNumericalValue(element, "TEMPERATURE-EXP")) \
+                 .setTimeExp(self.getChildElementOptionalNumericalValue(element, "TIME-EXP")) \
+                 .setCurrentExp(self.getChildElementOptionalNumericalValue(element, "CURRENT-EXP")) \
 
     '''
     def getIPduMappings(self, element: ET.Element) -> List[IPduMapping]:
@@ -3543,7 +3997,10 @@ class ARXMLParser(AbstractARXMLParser):
         child_element = self.find(element, key)
         if child_element is not None:
             filter = DataFilter()
-            filter.setDataFilterType(self.getChildElementOptionalLiteral(child_element, "DATA-FILTER-TYPE"))
+            filter.setDataFilterType(self.getChildElementOptionalLiteral(child_element, "DATA-FILTER-TYPE")) \
+                  .setMask(self.getChildElementOptionalIntegerValue(child_element, "MASK")) \
+                  .setX(self.getChildElementOptionalIntegerValue(child_element, "X")) 
+
         return filter
             
     def getTransmissionModeConditions(self, element: ET.Element, key: str) -> List[TransmissionModeCondition]:
@@ -3599,7 +4056,8 @@ class ARXMLParser(AbstractARXMLParser):
             decl = TransmissionModeDeclaration()
             for condition in self.getTransmissionModeConditions(child_element, "TRANSMISSION-MODE-CONDITIONS/TRANSMISSION-MODE-CONDITION"):
                 decl.addTransmissionModeCondition(condition)
-            decl.setTransmissionModeTrueTiming(self.getTransmissionModeTiming(child_element, "TRANSMISSION-MODE-TRUE-TIMING"))
+            decl.setTransmissionModeFalseTiming(self.getTransmissionModeTiming(child_element, "TRANSMISSION-MODE-FALSE-TIMING")) \
+                .setTransmissionModeTrueTiming(self.getTransmissionModeTiming(child_element, "TRANSMISSION-MODE-TRUE-TIMING"))
         return decl
 
     def getISignalIPduIPduTimingSpecification(self, element: ET.Element) -> IPduTiming:
@@ -3611,13 +4069,13 @@ class ARXMLParser(AbstractARXMLParser):
                   .setTransmissionModeDeclaration(self.getTransmissionModeDeclaration(child_element, "TRANSMISSION-MODE-DECLARATION"))
         return timing
 
-    def readISignalIPdu(self, element: ET.Element, i_pdu: ISignalIPdu):
-        self.logger.debug("Read ISignalIPdu <%s>" % i_pdu.getShortName())
-        self.readIdentifiable(element, i_pdu)
-        i_pdu.setLength(self.getChildElementOptionalNumericalValue(element, "LENGTH")) \
+    def readISignalIPdu(self, element: ET.Element, ipdu: ISignalIPdu):
+        self.logger.debug("Read ISignalIPdu <%s>" % ipdu.getShortName())
+        self.readIdentifiable(element, ipdu)
+        ipdu.setLength(self.getChildElementOptionalNumericalValue(element, "LENGTH")) \
             .setIPduTimingSpecification(self.getISignalIPduIPduTimingSpecification(element))
-        self.readISignalToPduMappings(element, i_pdu)
-        i_pdu.setUnusedBitPattern(self.getChildElementOptionalLiteral(element, "UNUSED-BIT-PATTERN"))
+        self.readISignalToPduMappings(element, ipdu)
+        ipdu.setUnusedBitPattern(self.getChildElementOptionalIntegerValue(element, "UNUSED-BIT-PATTERN"))
 
     def getISignalIPduRefs(self, element: ET.Element) -> List[RefType]:
         ref_types = [] 
@@ -3669,23 +4127,54 @@ class ARXMLParser(AbstractARXMLParser):
         for child_element in self.findall(element, "SW-MAPPINGS/*"):
             tag_name = self.getTagName(child_element)
             if tag_name == "SWC-TO-ECU-MAPPING":
-                self.readSwcToEcuMapping(child_element, mapping.createSwcToEcuMapping(self.getShortName(child_element)))
+                swc_to_ecu_mapping = mapping.createSwcToEcuMapping(self.getShortName(child_element))
+                self.readSwcToEcuMapping(child_element, swc_to_ecu_mapping)
             else:
                 self.notImplemented("Unsupported Sw Mapping %s" % tag_name)
 
-    def readSystemMapping(self, element: ET.Element, parent: System):
-        short_name = self.getShortName(element)
-        self.logger.debug("SystemMapping %s" % short_name)
-        mapping = parent.createSystemMapping(short_name)
+    def readEcuMapping(self, element: ET.Element, mapping: ECUMapping):
+        self.readIdentifiable(element, mapping)
+        mapping.setEcuInstanceRef(self.getChildElementOptionalRefType(element, "ECU-INSTANCE-REF")) \
+               .setEcuRef(self.getChildElementOptionalRefType(element, "ECU-REF")) 
+
+    def readSystemMappingEcuResourceMappings(self, element: ET.Element, mapping: SystemMapping):
+        for child_element in self.findall(element, "ECU-RESOURCE-MAPPINGS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "ECU-MAPPING":
+                ecu_mapping = mapping.createECUMapping(self.getShortName(child_element))
+                self.readEcuMapping(child_element, ecu_mapping)
+            else:
+                self.notImplemented("Unsupported EcuResourceMapping <%s>" % tag_name)
+
+    def readSwcToImplMapping(self, element: ET.Element, mapping: SwcToImplMapping):
+        self.readIdentifiable(element, mapping)
+        mapping.setComponentImplementationRef(self.getChildElementOptionalRefType(element, "COMPONENT-IMPLEMENTATION-REF"))
+        for child_element in self.findall(element, "COMPONENT-IREFS/COMPONENT-IREF"):
+            mapping.addComponentIRef(self.getComponentInSystemInstanceRef(child_element))
+
+    def readSystemMappingSwImplMappings(self, element: ET.Element, mapping: SystemMapping):
+        for child_element in self.findall(element, "SW-IMPL-MAPPINGS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "SWC-TO-IMPL-MAPPING":
+                sw_impl_mapping = mapping.createSwcToImplMapping(self.getShortName(child_element))
+                self.readSwcToImplMapping(child_element, sw_impl_mapping)
+            else:
+                self.notImplemented("Unsupported SwImplMapping <%s>" % tag_name)
+
+    def readSystemMapping(self, element: ET.Element, mapping: SystemMapping):
+        self.logger.debug("SystemMapping %s" % mapping.getShortName())
         self.readIdentifiable(element, mapping)
         self.readSystemMappingDataMappings(element, mapping)
+        self.readSystemMappingEcuResourceMappings(element, mapping)
+        self.readSystemMappingSwImplMappings(element, mapping)
         self.readSystemMappingSwMappings(element, mapping)
 
     def readSystemMappings(self, element: ET.Element, system: System):
         for child_element in self.findall(element, "MAPPINGS/*"):
             tag_name = self.getTagName(child_element)
             if tag_name == "SYSTEM-MAPPING":
-                self.readSystemMapping(child_element, system)
+                mapping = system.createSystemMapping(self.getShortName(child_element))
+                self.readSystemMapping(child_element, mapping)
             else:
                 self.notImplemented("Unsupported Mapping %s" % tag_name)
             
@@ -3698,6 +4187,7 @@ class ARXMLParser(AbstractARXMLParser):
             self.readIdentifiable(child_element, prototype)
             prototype.setFlatMapRef(self.getChildElementOptionalRefType(child_element, "FLAT-MAP-REF")) \
                      .setSoftwareCompositionTRef(self.getChildElementOptionalRefType(child_element, "SOFTWARE-COMPOSITION-TREF"))
+            AUTOSAR.getInstance().setRootSwCompositionPrototype(prototype)
             
     def readSystemFibexElementRefs(self, element: ET.Element, system: System):
         for ref in self.getChildElementRefTypeList(element, "FIBEX-ELEMENTS/FIBEX-ELEMENT-REF-CONDITIONAL/FIBEX-ELEMENT-REF"):
@@ -3711,6 +4201,7 @@ class ARXMLParser(AbstractARXMLParser):
         self.readSystemMappings(element, system)
         self.readRootSwCompositionPrototype(element, system)
         system.setSystemVersion(self.getChildElementOptionalRevisionLabelString(element, "SYSTEM-VERSION"))
+        AUTOSAR.getInstance().addSystem(system)
 
     def readGenericEthernetFrame(self, element: ET.Element, frame: GenericEthernetFrame):
         self.logger.debug("Read GenericEthernetFrame <%s>" % frame.getShortName())
@@ -4006,7 +4497,7 @@ class ARXMLParser(AbstractARXMLParser):
             self.readReferenceBases(child_element, ar_package)
 
     def load(self, filename, document: AUTOSAR):
-        self.logger.info("Load %s ..." % os.path.realpath(filename))
+        self.logger.info("Loading %s ..." % os.path.realpath(filename))
 
         tree = ET.parse(filename)
         root = tree.getroot()