armodel 1.7.4__py3-none-any.whl → 1.7.5__py3-none-any.whl

armodel/parser/arxml_parser.py

@@ -72,19 +72,21 @@ 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.NetworkManagement import CanNmCluster, CanNmClusterCoupling, CanNmNode, NmCluster, NmConfig, NmNode
+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.InstanceRefs import ComponentInSystemInstanceRef, VariableDataPrototypeInSystemInstanceRef
-from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Lin.LinCommunication import LinFrameTriggering
-from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.CoreTopology import AbstractCanCluster, CanPhysicalChannel, CommConnectorPort, CommunicationCluster, CommunicationConnector, EthernetPhysicalChannel, FramePort, IPduPort, ISignalPort, LinPhysicalChannel, PhysicalChannel
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Lin.LinCommunication import ApplicationEntry, LinFrameTriggering, LinScheduleTable, ScheduleTableEntry
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Lin.LinTopology import LinCommunicationConnector, LinMaster
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.CoreTopology import AbstractCanCluster, CanClusterBusOffRecovery, CanPhysicalChannel, CommConnectorPort, CommunicationCluster, CommunicationConnector, EthernetPhysicalChannel, FramePort, IPduPort, ISignalPort, LinPhysicalChannel, PhysicalChannel
 from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.CoreCommunication import Frame, FrameTriggering, IPdu, IPduTiming, ISignalIPdu, ISignalTriggering, PduTriggering
 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 CanFrameTriggering, RxIdentifierRange
 from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Can.CanTopology import CanCommunicationConnector, CanCommunicationController
-from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Ethernet.EthernetTopology import EthernetCommunicationController
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Ethernet.EthernetTopology import EthernetCommunicationConnector, EthernetCommunicationController, InitialSdDelayConfig, RequestResponseDelay, SdClientConfig
 from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Ethernet.EthernetCommunication import SocketConnection, SocketConnectionBundle, SocketConnectionIpduIdentifier
-from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Ethernet.NetworkEndpoint import Ipv6Configuration, NetworkEndpoint
-from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Ethernet.ServiceInstances import SoAdConfig, SocketAddress
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Ethernet.NetworkEndpoint import DoIpEntity, InfrastructureServices, Ipv6Configuration, NetworkEndpoint
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Ethernet.ServiceInstances import ApplicationEndpoint, ConsumedEventGroup, ConsumedServiceInstance, GenericTp, SoAdConfig, SocketAddress, TcpTp, TpPort, TransportProtocolConfiguration, UdpTp
 from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Multiplatform import ISignalMapping
 
 from .abstract_arxml_parser import AbstractARXMLParser
@@ -299,8 +301,6 @@ class ARXMLParser(AbstractARXMLParser):
             if ref_type is not None:
                 entity.addManagedModeGroupRef(ref_type)
 
-    
-
     def readBswEvent(self, element: ET.Element, event: BswScheduleEvent):
         event.startsOnEventRef = self.getChildElementOptionalRefType(element, "STARTS-ON-EVENT-REF")
 
@@ -2272,7 +2272,7 @@ class ARXMLParser(AbstractARXMLParser):
             layout_v = SwRecordLayoutV()
             layout_v.setShortLabel(self.getChildElementOptionalLiteral(child_element, "SHORT-LABEL")) \
                     .setBaseTypeRef(self.getChildElementOptionalRefType(child_element, "BASE-TYPE-REF")) \
-                    .setSwRecordLayoutVAxis(self.getChildElementOptionalNumericalValue(child_element, "SW-RECORD-LAYOUT-V-AXIS")) \
+                    .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"))
         return layout_v
@@ -2284,7 +2284,7 @@ class ARXMLParser(AbstractARXMLParser):
             group = SwRecordLayoutGroup()
             group.setShortLabel(self.getChildElementOptionalLiteral(child_element, "SHORT-LABEL")) \
                  .setCategory(self.getChildElementOptionalLiteral(child_element, "CATEGORY")) \
-                 .setSwRecordLayoutGroupAxis(self.getChildElementOptionalNumericalValue(child_element, "SW-RECORD-LAYOUT-GROUP-AXIS")) \
+                 .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")) \
@@ -2471,9 +2471,45 @@ class ARXMLParser(AbstractARXMLParser):
         self.readIdentifiable(element, channel)
         self.readPhysicalChannel(element, channel)
 
+    def readScheduleTableEntry(self, element: ET.Element, entry: ScheduleTableEntry):
+        entry.setDelay(self.getChildElementOptionalTimeValue(element, "DELAY")) \
+             .setPositionInTable(self.getChildElementOptionalIntegerValue(element, "POSITION-IN-TABLE"))
+
+    def getApplicationEntry(self, element: ET.Element, key: str) -> ApplicationEntry:
+        entry = None
+        if element is not None:
+            entry = ApplicationEntry()
+            self.readScheduleTableEntry(element, entry)
+            entry.setFrameTriggeringRef(self.getChildElementOptionalRefType(element, "FRAME-TRIGGERING-REF"))
+        return entry
+
+    def readLinScheduleTableTableEntries(self, element: ET.Element, table: LinScheduleTable):
+        for child_element in self.findall(element, "TABLE-ENTRYS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "APPLICATION-ENTRY":
+                table = table.addTableEntry(self.getApplicationEntry(child_element, "APPLICATION-ENTRY"))
+            else:
+                self.notImplemented("Unsupported Schedule Table <%s>" % tag_name)
+
+    def readLinScheduleTable(self, element: ET.Element, table: LinScheduleTable):
+        self.readIdentifiable(element, table)
+        table.setResumePosition(self.getChildElementOptionalLiteral(element, "RESUME-POSITION")) \
+             .setRunMode(self.getChildElementOptionalLiteral(element, "RUN-MODE"))
+        self.readLinScheduleTableTableEntries(element, table)
+
+    def readLinPhysicalChannelScheduleTables(self, element: ET.Element, channel: LinPhysicalChannel):
+        for child_element in self.findall(element, "SCHEDULE-TABLES/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "LIN-SCHEDULE-TABLE":
+                table = channel.createLinScheduleTable(self.getShortName(child_element))
+                self.readLinScheduleTable(child_element, table)
+            else:
+                self.notImplemented("Unsupported Schedule Table <%s>" % tag_name)
+
     def readLinPhysicalChannel(self, element: ET.Element, channel: LinPhysicalChannel):
         self.readIdentifiable(element, channel)
         self.readPhysicalChannel(element, channel)
+        self.readLinPhysicalChannelScheduleTables(element, channel)
 
     def getIpv6Configuration(self, element: ET.Element) -> Ipv6Configuration:
         configuration = None
@@ -2496,8 +2532,25 @@ class ARXMLParser(AbstractARXMLParser):
             else:
                 self.notImplemented("Unsupported Network EndPoint Address <%s>" % tag_name)
 
+    def getDoIpEntity(self, element: ET.Element, key:str) -> DoIpEntity:
+        entity = None
+        child_element = self.find(element, key)
+        if child_element is not None:
+            entity = DoIpEntity()
+            entity.setDoIpEntityRole(self.getChildElementOptionalLiteral(child_element, "DO-IP-ENTITY-ROLE"))
+        return entity
+
+    def getInfrastructureServices(self, element: ET.Element, key:str) -> InfrastructureServices:
+        services = None
+        child_element = self.find(element, key)
+        if child_element is not None:
+            services = InfrastructureServices()
+            services.setDoIpEntity(self.getDoIpEntity(child_element, "DO-IP-ENTITY"))
+        return services
+
     def readNetworkEndPoint(self, element: ET.Element, end_point: NetworkEndpoint):
         self.readIdentifiable(element, end_point)
+        end_point.setInfrastructureServices(self.getInfrastructureServices(element, "INFRASTRUCTURE-SERVICES"))
         self.readNetworkEndPointNetworkEndPointAddress(element, end_point)
         end_point.setPriority(self.getChildElementOptionalPositiveInteger(element, "PRIORITY"))
 
@@ -2531,11 +2584,15 @@ class ARXMLParser(AbstractARXMLParser):
         connection = None
         if element is not None:
             connection = SocketConnection()
-            connection.setClientPortRef(self.getChildElementOptionalRefType(element, "CLIENT-PORT-REF"))
+            connection.setClientIpAddrFromConnectionRequest(self.getChildElementOptionalBooleanValue(element, "CLIENT-IP-ADDR-FROM-CONNECTION-REQUEST")) \
+                      .setClientPortFromConnectionRequest(self.getChildElementOptionalBooleanValue(element, "CLIENT-PORT-FROM-CONNECTION-REQUEST")) \
+                      .setClientPortRef(self.getChildElementOptionalRefType(element, "CLIENT-PORT-REF"))
             for pdu in self.getSocketConnectionPdus(element):
                 connection.addPdu(pdu)
             connection.setPduCollectionMaxBufferSize(self.getChildElementOptionalPositiveInteger(element, "PDU-COLLECTION-MAX-BUFFER-SIZE")) \
                       .setPduCollectionTimeout(self.getChildElementOptionalTimeValue(element, "PDU-COLLECTION-TIMEOUT")) \
+                      .setRuntimeIpAddressConfiguration(self.getChildElementOptionalLiteral(element, "RUNTIME-IP-ADDRESS-CONFIGURATION")) \
+                      .setRuntimePortConfiguration(self.getChildElementOptionalLiteral(element, "RUNTIME-PORT-CONFIGURATION")) \
                       .setShortLabel(self.getChildElementOptionalLiteral(element, "SHORT-LABEL"))
         return connection
          
@@ -2560,18 +2617,145 @@ class ARXMLParser(AbstractARXMLParser):
             else:
                 self.notImplemented("Unsupported Connection Bundle <%s>" % tag_name)
 
+    def getTpPort(self, element: ET.SubElement, key: str) -> TpPort:
+        port = None
+        child_element = self.find(element, key)
+        if child_element is not None:
+            port = TpPort()
+            port.setDynamicallyAssigned(self.getChildElementOptionalBooleanValue(child_element, "DYNAMICALLY-ASSIGNED")) \
+                .setPortNumber(self.getChildElementOptionalPositiveInteger(child_element, "PORT-NUMBER"))
+        return port
+
+    def readUdpTp(self, element: ET.Element, tp: UdpTp):
+        tp.setUdpTpPort(self.getTpPort(element, "UDP-TP-PORT"))
+
+    def readTcpTp(self, element: ET.Element, tp: TcpTp):
+        tp.setKeepAliveInterval(self.getChildElementOptionalTimeValue(element, "KEEP-ALIVE-INTERVAL")) \
+                     .setKeepAliveProbesMax(self.getChildElementOptionalPositiveInteger(element, "KEEP-ALIVE-PROBES-MAX")) \
+                     .setKeepAliveTime(self.getChildElementOptionalTimeValue(element, "KEEP-ALIVE-TIME")) \
+                     .setKeepAlives(self.getChildElementOptionalBooleanValue(element, "KEEP-ALIVES")) \
+                     .setNaglesAlgorithm(self.getChildElementOptionalLiteral(element, "NAGLES-ALGORITHM")) \
+                     .setTcpTpPort(self.getTpPort(element, "TCP-TP-PORT"))
+
+
+    def readGenericTp(self, element: ET.Element, tp: GenericTp):
+        tp.setTpAddress(self.getChildElementOptionalLiteral(element, "TP-ADDRESS")) \
+          .setTpTechnology(self.getChildElementOptionalLiteral(element, "TP-TECHNOLOGY"))
+
+    def getTransportProtocolConfiguration(self, element: ET.Element, key: str) -> TransportProtocolConfiguration:
+        configuration = None
+        child_element = self.find(element, "%s/*" % key)
+        if child_element is not None:
+            tag_name = self.getTagName(child_element)
+            if tag_name == "UDP-TP":
+                configuration = UdpTp()
+                self.readUdpTp(child_element, configuration)
+            elif tag_name == "TCP-TP":
+                configuration = TcpTp()
+                self.readTcpTp(child_element, configuration)
+            elif tag_name == "GENERIC-TP":
+                configuration = GenericTp()
+                self.readGenericTp(child_element, configuration)
+            else:
+                self.notImplemented("Unsupported TransportProtocolConfiguration <%s>" % tag_name)
+        return configuration
+    
+    def readConsumedEventGroupRoutingGroupRefs(self, element: ET.Element, group: ConsumedEventGroup):
+        for ref in self.getChildElementRefTypeList(element, "ROUTING-GROUP-REFS/ROUTING-GROUP-REF"):
+            group.addRoutingGroupRef(ref)
+
+    def getRequestResponseDelay(self, element: ET.Element, key: str) -> RequestResponseDelay:
+        delay = None
+        child_element = self.find(element, key)
+        if child_element is not None:
+            delay = RequestResponseDelay()
+            delay.setMaxValue(self.getChildElementOptionalTimeValue(child_element, "MAX-VALUE")) \
+                 .setMinValue(self.getChildElementOptionalTimeValue(child_element, "MIN-VALUE"))
+        return delay
+    
+    def getInitialSdDelayConfig(self, element: ET.Element, key: str) -> InitialSdDelayConfig:
+        config = None
+        child_element = self.find(element, key)
+        if child_element is not None:
+            config = InitialSdDelayConfig()
+            config.setInitialDelayMaxValue(self.getChildElementOptionalTimeValue(child_element, "INITIAL-DELAY-MAX-VALUE")) \
+                  .setInitialDelayMinValue(self.getChildElementOptionalTimeValue(child_element, "INITIAL-DELAY-MIN-VALUE")) \
+                  .setInitialRepetitionsBaseDelay(self.getChildElementOptionalTimeValue(child_element, "INITIAL-REPETITIONS-BASE-DELAY")) \
+                  .setInitialRepetitionsMax(self.getChildElementOptionalPositiveInteger(child_element, "INITIAL-REPETITIONS-MAX"))
+        return config
+
+    def getSdClientConfig(self, element: ET.Element, key: str) -> SdClientConfig:
+        config = None
+        child_element = self.find(element, key)
+        if child_element is not None:
+            config = SdClientConfig()
+            config.setClientServiceMajorVersion(self.getChildElementOptionalPositiveInteger(child_element, "CLIENT-SERVICE-MAJOR-VERSION")) \
+                  .setClientServiceMinorVersion(self.getChildElementOptionalPositiveInteger(child_element, "CLIENT-SERVICE-MINOR-VERSION")) \
+                  .setInitialFindBehavior(self.getInitialSdDelayConfig(child_element, "INITIAL-FIND-BEHAVIOR")) \
+                  .setRequestResponseDelay(self.getRequestResponseDelay(child_element, "REQUEST-RESPONSE-DELAY")) \
+                  .setTtl(self.getChildElementOptionalPositiveInteger(child_element, "TTL"))
+        return config
+    
+    def readConsumedEventGroup(self, element: ET.Element, group: ConsumedEventGroup):
+        self.readIdentifiable(element, group)
+        group.setApplicationEndpointRef(self.getChildElementOptionalRefType(element, "APPLICATION-ENDPOINT-REF")) \
+             .setEventGroupIdentifier(self.getChildElementOptionalPositiveInteger(element, "EVENT-GROUP-IDENTIFIER"))
+        self.readConsumedEventGroupRoutingGroupRefs(element, group)
+        group.setSdClientConfig(self.getSdClientConfig(element, "SD-CLIENT-CONFIG"))
+    
+    def readConsumedServiceInstanceConsumedEventGroups(self, element: ET.Element, instance: ConsumedServiceInstance):
+        for child_element in self.findall(element, "CONSUMED-EVENT-GROUPS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "CONSUMED-EVENT-GROUP":
+                group = instance.createConsumedEventGroup(self.getShortName(child_element))
+                self.readConsumedEventGroup(child_element, group)
+            else:
+                self.notImplemented("Unsupported ConsumedEventGroups <%s>" % tag_name)
+
+    def readConsumedServiceInstance(self, element: ET.Element, instance: ConsumedServiceInstance):
+        self.readIdentifiable(element, instance)
+        self.readConsumedServiceInstanceConsumedEventGroups(element, instance)
+        instance.setProvidedServiceInstanceRef(self.getChildElementOptionalRefType(element, "PROVIDED-SERVICE-INSTANCE-REF"))
+        instance.setSdClientConfig(self.getSdClientConfig(element, "SD-CLIENT-CONFIG"))
+    
+    def readSocketAddressApplicationEndpointConsumedServiceInstances(self, element: ET.Element, end_point: ApplicationEndpoint):
+        for child_element in self.findall(element, "CONSUMED-SERVICE-INSTANCES/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "CONSUMED-SERVICE-INSTANCE":
+                instance = end_point.createConsumedServiceInstance(self.getShortName(child_element))
+                self.readConsumedServiceInstance(child_element, instance)
+            else:
+                self.notImplemented("Unsupported ConsumedServiceInstances <%s>" % tag_name)
+
+    def readSocketAddressApplicationEndpoint(self, element: ET.Element, address: SocketAddress):
+        child_element = self.find(element, "APPLICATION-ENDPOINT")
+        if child_element is not None:
+            end_point = address.createApplicationEndpoint(self.getShortName(child_element))
+            self.readSocketAddressApplicationEndpointConsumedServiceInstances(child_element, end_point)
+            end_point.setNetworkEndpointRef(self.getChildElementOptionalRefType(child_element, "NETWORK-ENDPOINT-REF")) \
+                     .setPriority(self.getChildElementOptionalPositiveInteger(child_element, "PRIORITY")) \
+                     .setTpConfiguration(self.getTransportProtocolConfiguration(child_element, "TP-CONFIGURATION"))
+            
+    def readSocketAddressMulticastConnectorRefs(self, element: ET.Element, address: SocketAddress):
+        for ref in self.getChildElementRefTypeList(element, "MULTICAST-CONNECTOR-REFS/MULTICAST-CONNECTOR-REF"):
+            address.addMulticastConnectorRef(ref)
+
     def readSocketAddress(self, element: ET.Element, address: SocketAddress):
-        self.readSocketConnectionBundleConnections(element, address)
-        address.setConnectorRef(self.getChildElementOptionalRefType(element, "CONNECTOR-REF"))
+        self.readIdentifiable(element, address)
+        self.readSocketAddressApplicationEndpoint(element, address)
+        self.readSocketAddressMulticastConnectorRefs(element, address)
+        address.setConnectorRef(self.getChildElementOptionalRefType(element, "CONNECTOR-REF")) \
+               .setPortAddress(self.getChildElementOptionalPositiveInteger(element, "PORT-ADDRESS"))
+
 
     def readSoAdConfigSocketAddresses(self, element: ET.Element, config: SoAdConfig):   
         for child_element in self.findall(element, "SOCKET-ADDRESSS/*"):
             tag_name = self.getTagName(child_element)
             if tag_name == "SOCKET-ADDRESS":
-                bundle = config.createSocketAddress(self.getShortName(child_element))
-                self.readSocketAddress(child_element, bundle)
+                address = config.createSocketAddress(self.getShortName(child_element))
+                self.readSocketAddress(child_element, address)
             else:
-                self.notImplemented("Unsupported Connection Bundle <%s>" % tag_name)
+                self.notImplemented("Unsupported Socket Address <%s>" % tag_name)
 
     def getSoAdConfig(self, element: ET.Element, key: str) -> SoAdConfig:
         child_element = self.find(element, key)
@@ -2581,12 +2765,19 @@ class ARXMLParser(AbstractARXMLParser):
             self.readSoAdConfigConnectionBundles(child_element, config)
             self.readSoAdConfigSocketAddresses(child_element, config)
         return config
+    
+    def readEthernetPhysicalChannelVlan(self, element: ET.Element, channel: EthernetPhysicalChannel):
+        child_element = self.find(element, "VLAN")
+        if child_element is not None:
+            vlan = channel.createVlanConfig(self.getShortName(child_element))
+            vlan.setVlanIdentifier(self.getChildElementOptionalPositiveInteger(child_element, "VLAN-IDENTIFIER"))
 
     def readEthernetPhysicalChannel(self, element: ET.Element, channel: EthernetPhysicalChannel):
         self.readIdentifiable(element, channel)
         self.readPhysicalChannel(element, channel)
         self.readEthernetPhysicalChannelNetworkEndPoints(element, channel)
         channel.setSoAdConfig(self.getSoAdConfig(element, "SO-AD-CONFIG"))
+        self.readEthernetPhysicalChannelVlan(element, channel)
 
     def readCommunicationClusterPhysicalChannels(self, element: ET.Element, cluster: CommunicationCluster):
         for child_element in self.findall(element, "PHYSICAL-CHANNELS/*"):
@@ -2609,9 +2800,20 @@ class ARXMLParser(AbstractARXMLParser):
         self.readCommunicationClusterPhysicalChannels(element, cluster)
         cluster.setProtocolName(self.getChildElementOptionalLiteral(element, "PROTOCOL-NAME")) \
                .setProtocolVersion(self.getChildElementOptionalLiteral(element, "PROTOCOL-VERSION"))
-
+        
+    def getCanClusterBusOffRecovery(self, element: ET.Element, key: str) -> CanClusterBusOffRecovery:
+        recovery = None
+        child_element = self.find(element, key)
+        if child_element is not None:
+            recovery = CanClusterBusOffRecovery()
+            recovery.setBorCounterL1ToL2(self.getChildElementOptionalPositiveInteger(child_element, "BOR-COUNTER-L-1-TO-L-2")) \
+                    .setBorTimeL1(self.getChildElementOptionalTimeValue(child_element, "BOR-TIME-L-1")) \
+                    .setBorTimeL2(self.getChildElementOptionalTimeValue(child_element, "BOR-TIME-L-2"))
+        return recovery
+        
     def readAbstractCanCluster(self, element: ET.Element, cluster: AbstractCanCluster):
-        cluster.setCanFdBaudrate(self.getChildElementOptionalNumericalValue(element, "CAN-FD-BAUDRATE")) \
+        cluster.setBusOffRecovery(self.getCanClusterBusOffRecovery(element, "BUS-OFF-RECOVERY")) \
+               .setCanFdBaudrate(self.getChildElementOptionalNumericalValue(element, "CAN-FD-BAUDRATE")) \
                .setSpeed(self.getChildElementOptionalNumericalValue(element, "SPEED"))
 
     def readLinCluster(self, element: ET.Element, parent: ARPackage):
@@ -2642,6 +2844,71 @@ class ARXMLParser(AbstractARXMLParser):
         if child_element is not None:
             self.readCommunicationCluster(child_element, cluster)
 
+    def readDiagnosticConnectionFunctionalRequestRefs(self, element: ET.Element, connection: DiagnosticConnection):
+        for ref in self.getChildElementRefTypeList(element, "FUNCTIONAL-REQUEST-REFS/FUNCTIONAL-REQUEST-REF"):
+            connection.addFunctionalRequestRef(ref)
+
+    def readDiagnosticConnection(self, element: ET.Element, connection: DiagnosticConnection):
+        self.logger.debug("Read DiagnosticConnection %s" % connection.getShortName())
+        self.readIdentifiable(element, connection)
+        self.readDiagnosticConnectionFunctionalRequestRefs(element, connection)
+        connection.setPhysicalRequestRef(self.getChildElementOptionalRefType(element, "PHYSICAL-REQUEST-REF")) \
+                  .setResponseOnEventRef(self.getChildElementOptionalRefType(element, "RESPONSE-REF"))
+
+    def readDiagnosticServiceTable(self, element: ET.Element, parent: ARPackage):
+        short_name = self.getShortName(element)
+        self.logger.debug("Read DiagnosticServiceTable %s" % short_name)
+        table = parent.createDiagnosticServiceTable(short_name)
+        self.readIdentifiable(element, table)
+
+    def readMultiplexedIPdu(self, element: ET.Element, parent: ARPackage):
+        short_name = self.getShortName(element)
+        self.logger.debug("Read MultiplexedIPdu %s" % short_name)
+        i_pdu = parent.createMultiplexedIPdu(short_name)
+        self.readIdentifiable(element, i_pdu)
+
+    def readUserDefinedIPdu(self, element: ET.Element, parent: ARPackage):
+        short_name = self.getShortName(element)
+        self.logger.debug("Read UserDefinedIPdu %s" % short_name)
+        i_pdu = parent.createUserDefinedIPdu(short_name)
+        self.readIdentifiable(element, i_pdu)
+
+    def readUserDefinedPdu(self, element: ET.Element, parent: ARPackage):
+        short_name = self.getShortName(element)
+        self.logger.debug("Read UserDefinedPdu %s" % short_name)
+        pdu = parent.createUserDefinedPdu(short_name)
+        self.readIdentifiable(element, pdu)
+
+    def readGeneralPurposePdu(self, element: ET.Element, parent: ARPackage):
+        short_name = self.getShortName(element)
+        self.logger.debug("Read GeneralPurposePdu %s" % short_name)
+        pdu = parent.createGeneralPurposePdu(short_name)
+        self.readIdentifiable(element, pdu)
+
+    def readGeneralPurposeIPdu(self, element: ET.Element, parent: ARPackage):
+        short_name = self.getShortName(element)
+        self.logger.debug("Read GeneralPurposeIPdu %s" % short_name)
+        i_pdu = parent.createGeneralPurposeIPdu(short_name)
+        self.readIdentifiable(element, i_pdu)
+
+    def readSecureCommunicationPropsSet(self, element: ET.Element, parent: ARPackage):
+        short_name = self.getShortName(element)
+        self.logger.debug("Read SecureCommunicationPropsSet %s" % short_name)
+        prop_set = parent.createSecureCommunicationPropsSet(short_name)
+        self.readIdentifiable(element, prop_set)
+
+    def readSoAdRoutingGroup(self, element: ET.Element, parent: ARPackage):
+        short_name = self.getShortName(element)
+        self.logger.debug("Read SoAdRoutingGroup %s" % short_name)
+        group = parent.createSoAdRoutingGroup(short_name)
+        self.readIdentifiable(element, group)
+
+    def readDoIpTpConfig(self, element: ET.Element, parent: ARPackage):
+        short_name = self.getShortName(element)
+        self.logger.debug("Read DoIpTpConfig %s" % short_name)
+        group = parent.createDoIpTpConfig(short_name)
+        self.readIdentifiable(element, group)
+
     def readPduToFrameMappings(self, element: ET.Element, parent: Frame):
         for child_element in self.findall(element, "PDU-TO-FRAME-MAPPINGS/PDU-TO-FRAME-MAPPING"):
             short_name = self.getShortName(child_element)
@@ -2696,6 +2963,8 @@ class ARXMLParser(AbstractARXMLParser):
         self.readIPdu(element, 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"))
@@ -2704,23 +2973,30 @@ class ARXMLParser(AbstractARXMLParser):
         for ref in self.getChildElementRefTypeList(element, "TX-NM-PDU-REFS/TX-NM-PDU-REF"):
             nm_node.addTxNmPduRefs(ref)
 
-    def readCanNmNode(self, element: ET.Element, parent: NmCluster):
-        short_name = self.getShortName(element)
-        self.logger.debug("readCanNmNode %s" % short_name)
-        nm_node = parent.createCanNmNode(short_name)            # type: CanNmNode
-        self.readIdentifiable(element, nm_node)
+    def readCanNmNode(self, element: ET.Element, nm_node: CanNmNode):
+        self.logger.debug("Read CanNmNode %s" % nm_node.getShortName())
+        
         self.readNmNode(element, nm_node)
 
         nm_node.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.readNmNode(element, nm_node)
 
     def readNmClusterNmNodes(self, element: ET.Element, parent: NmCluster):
         self.logger.debug("readNmConfigNmNodes %s" % parent.getShortName())
         for child_element in self.findall(element, "NM-NODES/*"):
             tag_name = self.getTagName(child_element)
             if tag_name == "CAN-NM-NODE":
-                self.readCanNmNode(child_element, parent)
+                nm_node = parent.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))
+                self.readUdpNmNode(child_element, nm_node)
             else:
                 self._raiseError("Unsupported Nm Node <%s>" % tag_name)
 
@@ -2734,6 +3010,10 @@ class ARXMLParser(AbstractARXMLParser):
                 .setNmImmediateRestartEnabled(self.getChildElementOptionalBooleanValue(element, "NM-IMMEDIATE-RESTART-ENABLED"))
     
         return coupling
+    
+    def getUdpNmClusterCoupling(self, element: ET.Element) -> UdpNmClusterCoupling:
+        coupling = UdpNmClusterCoupling()
+        return coupling
 
     def readNmConfigNmClusterCouplings(self, element: ET.Element, nm_config: NmConfig):
         self.logger.debug("readNmClusterNmClusterCouplings %s" % nm_config.getShortName())
@@ -2741,10 +3021,13 @@ class ARXMLParser(AbstractARXMLParser):
             tag_name = self.getTagName(child_element)
             if tag_name == "CAN-NM-CLUSTER-COUPLING":
                 nm_config.addNmClusterCouplings(self.getCanNmClusterCoupling(child_element))
+            elif tag_name == "UDP-NM-CLUSTER-COUPLING":
+                nm_config.addNmClusterCouplings(self.getUdpNmClusterCoupling(child_element))
             else:
-                self._raiseError("Unsupported Nm Node <%s>" % tag_name)
+                self.notImplemented("Unsupported Nm Node <%s>" % tag_name)
 
     def readNmCluster(self, element: ET.Element, cluster: NmCluster):
+        self.readIdentifiable(element, cluster)
         cluster.setCommunicationClusterRef(self.getChildElementOptionalRefType(element, "COMMUNICATION-CLUSTER-REF")) \
                .setNmChannelId(self.getChildElementOptionalNumericalValue(element, "NM-CHANNEL-ID")) \
                .setNmChannelSleepMaster(self.getChildElementOptionalBooleanValue(element, "NM-CHANNEL-SLEEP-MASTER"))
@@ -2755,7 +3038,6 @@ class ARXMLParser(AbstractARXMLParser):
         short_name = self.getShortName(element)
         self.logger.debug("readCanNmCluster %s" % short_name)
         cluster = parent.createCanNmCluster(short_name)         # type: CanNmCluster
-        self.readIdentifiable(element, cluster)
         self.readNmCluster(element, cluster)
 
         cluster.setNmBusloadReductionActive(self.getChildElementOptionalBooleanValue(element, "NM-BUSLOAD-REDUCTION-ACTIVE")) \
@@ -2773,11 +3055,19 @@ 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
+        self.readNmCluster(element, cluster)
+        
     def readNmConfigNmClusters(self, element: ET.Element, parent: 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)
+            elif tag_name == "UDP-NM-CLUSTER":
+                self.readUdpNmCluster(child_element, parent)
             else:
                 self._raiseError("Unsupported Nm Cluster <%s>" % tag_name)
     
@@ -2806,7 +3096,11 @@ class ARXMLParser(AbstractARXMLParser):
         self.readIdentifiable(element, controller)
 
     def readEthernetCommunicationController(self, element: ET.Element, controller: EthernetCommunicationController):
-        self.logger.debug("Read CanCommunicationController %s" % controller.getShortName())
+        self.logger.debug("Read EthernetCommunicationController %s" % controller.getShortName())
+        self.readIdentifiable(element, controller)
+
+    def readLinMaster(self, element: ET.Element, controller: LinMaster):
+        self.logger.debug("Read LinMaster %s" % controller.getShortName())
         self.readIdentifiable(element, controller)
 
     def readEcuInstanceCommControllers(self, element: ET.Element, instance: EcuInstance):
@@ -2819,6 +3113,9 @@ class ARXMLParser(AbstractARXMLParser):
             elif tag_name == "ETHERNET-COMMUNICATION-CONTROLLER":
                 controller = instance.createEthernetCommunicationController(self.getShortName(child_element))
                 self.readEthernetCommunicationController(child_element, controller)
+            elif tag_name == "LIN-MASTER":
+                controller = instance.createLinMaster(self.getShortName(child_element))
+                self.readLinMaster(child_element, controller)
             else:
                 self._raiseError("Unsupported Communication Controller <%s>" % tag_name)
 
@@ -2859,7 +3156,10 @@ class ARXMLParser(AbstractARXMLParser):
     def readCanCommunicationConnector(self, element: ET.Element, connector: CanCommunicationConnector):
         self.readCommunicationConnector(element, connector)
 
-    def readEthernetCommunicationConnector(self, element: ET.Element, connector: CanCommunicationConnector):
+    def readEthernetCommunicationConnector(self, element: ET.Element, connector: EthernetCommunicationConnector):
+        self.readCommunicationConnector(element, connector)
+
+    def readLinCommunicationConnector(self, element: ET.Element, connector: LinCommunicationConnector):
         self.readCommunicationConnector(element, connector)
 
     def readEcuInstanceConnectors(self, element: ET.Element, instance: EcuInstance):
@@ -2872,6 +3172,9 @@ class ARXMLParser(AbstractARXMLParser):
             elif tag_name == "ETHERNET-COMMUNICATION-CONNECTOR":
                 connector = instance.createEthernetCommunicationConnector(self.getShortName(child_element))
                 self.readEthernetCommunicationConnector(child_element, connector)
+            elif tag_name == "LIN-COMMUNICATION-CONNECTOR":
+                connector = instance.createLinCommunicationConnector(self.getShortName(child_element))
+                self.readLinCommunicationConnector(child_element, connector)
             else:
                 self._raiseError("Unsupported Communication Connector <%s>" % tag_name)                
 
@@ -3367,8 +3670,6 @@ class ARXMLParser(AbstractARXMLParser):
         self.readIdentifiable(element, mapping_set)
         self.readPortInterfaceMappings(element, mapping_set)
 
-    
-
     def readARPackageElements(self, element: ET.Element, parent: ARPackage):
         for child_element in self.findall(element, "ELEMENTS/*"):
             tag_name = self.getTagName(child_element.tag)
@@ -3415,6 +3716,7 @@ class ARXMLParser(AbstractARXMLParser):
             elif tag_name == "APPLICATION-ARRAY-DATA-TYPE":
                 self.readApplicationArrayDataType(child_element, parent)
             elif tag_name == "SW-RECORD-LAYOUT":
+                
                 self.readSwRecordLayout(child_element, parent)
             elif tag_name == "SW-ADDR-METHOD":
                 self.readSwAddrMethod(child_element, parent)
@@ -3490,6 +3792,27 @@ class ARXMLParser(AbstractARXMLParser):
                 self.readPortInterfaceMappingSet(child_element, parent)
             elif tag_name == "ETHERNET-CLUSTER":
                 self.readEthernetCluster(child_element, parent)
+            elif tag_name == "DIAGNOSTIC-CONNECTION":
+                connection = parent.createDiagnosticConnection(self.getShortName(child_element))
+                self.readDiagnosticConnection(child_element, connection)
+            elif tag_name == "DIAGNOSTIC-SERVICE-TABLE":
+                self.readDiagnosticServiceTable(child_element, parent)
+            elif tag_name == "MULTIPLEXED-I-PDU":
+                self.readMultiplexedIPdu(child_element, parent)
+            elif tag_name == "USER-DEFINED-I-PDU":
+                self.readUserDefinedIPdu(child_element, parent)
+            elif tag_name == "USER-DEFINED-PDU":
+                self.readUserDefinedPdu(child_element, parent)
+            elif tag_name == "GENERAL-PURPOSE-PDU":
+                self.readGeneralPurposePdu(child_element, parent)
+            elif tag_name == "GENERAL-PURPOSE-I-PDU":
+                self.readGeneralPurposeIPdu(child_element, parent)
+            elif tag_name == "SECURE-COMMUNICATION-PROPS-SET":
+                self.readSecureCommunicationPropsSet(child_element, parent)
+            elif tag_name == "SO-AD-ROUTING-GROUP":
+                self.readSoAdRoutingGroup(child_element, parent)
+            elif tag_name == "DO-IP-TP-CONFIG":
+                self.readDoIpTpConfig(child_element, parent)
             else:
                 self.notImplemented("Unsupported element type of ARPackage <%s>" % tag_name)