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

armodel/parser/arxml_parser.py

@@ -2,10 +2,6 @@ from typing import List
 import xml.etree.ElementTree as ET
 import os
 
-
-
-
-
 from ..models.M2.MSR.AsamHdo.AdminData import AdminData
 from ..models.M2.MSR.AsamHdo.BaseTypes import BaseTypeDirectDefinition
 from ..models.M2.MSR.AsamHdo.Constraints.GlobalConstraints import DataConstrRule, InternalConstrs, PhysConstrs, DataConstr
@@ -51,20 +47,21 @@ from ..models.M2.AUTOSARTemplates.GenericStructure.AbstractStructure import AnyI
 from ..models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import Identifiable, MultilanguageReferrable
 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 RefType, ARLiteral
+from ..models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import Ip6AddressString, RefType, ARLiteral
 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.Datatype.Datatypes import 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, AutosarVariableRef, VariableInAtomicSWCTypeInstanceRef
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.InstanceRefsUsage import AutosarParameterRef, VariableInAtomicSWCTypeInstanceRef
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Communication import CompositeNetworkRepresentation, TransmissionAcknowledgementRequest
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.IncludedDataTypes import IncludedDataTypeSet
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Components import AbstractProvidedPortPrototype, AbstractRequiredPortPrototype, CompositionSwComponentType, PortGroup, SwComponentType, SymbolProps, PPortPrototype, RPortPrototype
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Components.InstanceRefs import InnerPortGroupInCompositionInstanceRef, PModeGroupInAtomicSwcInstanceRef, RModeGroupInAtomicSWCInstanceRef, RModeInAtomicSwcInstanceRef, RVariableInAtomicSwcInstanceRef
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior import RunnableEntity, RunnableEntityArgument, SwcInternalBehavior
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.AutosarVariableRef import AutosarVariableRef
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.ServiceMapping import RoleBasedPortAssignment, SwcServiceDependency
-from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Components import AbstractProvidedPortPrototype, AbstractRequiredPortPrototype, CompositionSwComponentType, PortGroup, SwComponentType, SymbolProps, PPortPrototype, RPortPrototype
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Composition import AssemblySwConnector, DelegationSwConnector
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.ModeDeclarationGroup import IncludedModeDeclarationGroupSet, ModeAccessPoint
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.ServerCall import ServerCallPoint
@@ -75,15 +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, 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 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 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
@@ -205,17 +208,18 @@ class ARXMLParser(AbstractARXMLParser):
             iref.setTargetComponentRef(self.getChildElementOptionalRefType(element, "TARGET-COMPONENT-REF"))
         return iref
 
-    def getAutosarVariableInImplDatatype(self, element: ET.Element) ->  AutosarVariableRef:
-        child_element = self.find(element, "ACCESSED-VARIABLE")
+    def getAutosarVariableRef(self, element: ET.Element, key: str) ->  AutosarVariableRef:
+        child_element = self.find(element, key)
         ref  = None
         if (child_element is not None):
             ref = AutosarVariableRef()
             #self.readARObjectAttributes(child_element, ref)
-            ref.setAutosarVariableIRef(self.getVariableInAtomicSWCTypeInstanceRef(self.find(child_element, "AUTOSAR-VARIABLE-IREF")))
+            ref.setAutosarVariableIRef(self.getVariableInAtomicSWCTypeInstanceRef(self.find(child_element, "AUTOSAR-VARIABLE-IREF"))) \
+               .setLocalVariableRef(self.getChildElementOptionalRefType(child_element, "LOCAL-VARIABLE-REF"))
         return ref
 
-    def getLocalVariableRef(self, element: ET.Element) ->  AutosarVariableRef:
-        child_element = self.find(element, "ACCESSED-VARIABLE")
+    def getLocalVariableRef(self, element: ET.Element, key: str) ->  AutosarVariableRef:
+        child_element = self.find(element, key)
         ref  = None
         if (child_element is not None):
             ref = AutosarVariableRef()
@@ -230,25 +234,25 @@ class ARXMLParser(AbstractARXMLParser):
 
             if (key == "DATA-RECEIVE-POINT-BY-ARGUMENTS"):
                 variable_access = parent.createDataReceivePointByArgument(short_name)
-                variable_access.setAccessedVariableRef(self.getAutosarVariableInImplDatatype(child_element))
+                variable_access.setAccessedVariableRef(self.getAutosarVariableRef(child_element, "ACCESSED-VARIABLE"))
             elif (key == "DATA-RECEIVE-POINT-BY-VALUES"):
                 variable_access = parent.createDataReceivePointByValue(short_name)
-                variable_access.setAccessedVariableRef(self.getAutosarVariableInImplDatatype(child_element))
+                variable_access.setAccessedVariableRef(self.getAutosarVariableRef(child_element, "ACCESSED-VARIABLE"))
             elif (key == "DATA-READ-ACCESSS"):
                 variable_access = parent.createDataReadAccess(short_name)
-                variable_access.setAccessedVariableRef(self.getAutosarVariableInImplDatatype(child_element))
+                variable_access.setAccessedVariableRef(self.getAutosarVariableRef(child_element, "ACCESSED-VARIABLE"))
             elif (key == "DATA-WRITE-ACCESSS"):
                 variable_access = parent.createDataWriteAccess(short_name)
-                variable_access.setAccessedVariableRef(self.getAutosarVariableInImplDatatype(child_element))
+                variable_access.setAccessedVariableRef(self.getAutosarVariableRef(child_element, "ACCESSED-VARIABLE"))
             elif (key == "DATA-SEND-POINTS"):
                 variable_access = parent.createDataSendPoint(short_name)
-                variable_access.setAccessedVariableRef(self.getAutosarVariableInImplDatatype(child_element))
+                variable_access.setAccessedVariableRef(self.getAutosarVariableRef(child_element, "ACCESSED-VARIABLE"))
             elif (key == "WRITTEN-LOCAL-VARIABLES"):
                 variable_access = parent.createWrittenLocalVariable(short_name)
-                variable_access.setAccessedVariableRef(self.getLocalVariableRef(child_element))
+                variable_access.setAccessedVariableRef(self.getLocalVariableRef(child_element, "ACCESSED-VARIABLE"))
             elif (key == "READ-LOCAL-VARIABLES"):
                 variable_access = parent.createReadLocalVariable(short_name)
-                variable_access.setAccessedVariableRef(self.getLocalVariableRef(child_element))
+                variable_access.setAccessedVariableRef(self.getLocalVariableRef(child_element, "ACCESSED-VARIABLE"))
             else:
                 self.notImplemented("Unsupported Variable Accesss <%s>" % key)
 
@@ -297,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")
 
@@ -369,6 +371,7 @@ class ARXMLParser(AbstractARXMLParser):
     def getRoleBasedDataAssignment(self, element: ET.Element) -> RoleBasedDataAssignment:
         assignment = RoleBasedDataAssignment()
         assignment.setRole(self.getChildElementOptionalLiteral(element, "ROLE")) \
+                  .setUsedDataElement(self.getAutosarVariableRef(element, "USED-DATA-ELEMENT")) \
                   .setUsedParameterElement(self.getAutosarParameterRef(element, "USED-PARAMETER-ELEMENT")) \
                   .setUsedPimRef(self.getChildElementOptionalRefType(element, "USED-PIM-REF"))
         return assignment
@@ -432,6 +435,7 @@ class ARXMLParser(AbstractARXMLParser):
              .setUseCRCCompMechanism(self.getChildElementOptionalBooleanValue(element, "USE-CRC-COMP-MECHANISM")) \
              .setWriteOnlyOnce(self.getChildElementOptionalBooleanValue(element, "WRITE-ONLY-ONCE")) \
              .setWriteVerification(self.getChildElementOptionalBooleanValue(element, "WRITE-VERIFICATION")) \
+             .setWritingFrequency(self.getChildElementOptionalPositiveInteger(element, "WRITING-FREQUENCY")) \
              .setWritingPriority(self.getChildElementOptionalLiteral(element, "WRITING-PRIORITY"))
         
     def reaDiagnosticCommunicationManagerNeeds(self, element: ET.Element, parent: SwcServiceDependency):
@@ -475,16 +479,23 @@ class ARXMLParser(AbstractARXMLParser):
     def readDiagnosticEventNeeds(self, element: ET.Element, parent: SwcServiceDependency):
         short_name = self.getShortName(element)
         needs = parent.createDiagnosticEventNeeds(short_name)
-        self.logger.debug("read DiagnosticEventNeeds %s" % short_name)
+        self.logger.debug("Read DiagnosticEventNeeds %s" % short_name)
         self.readIdentifiable(element, needs)
         self.readDiagEventDebounceAlgorithm(element, needs)
         needs.setDtcKind(self.getChildElementOptionalLiteral(element, "DTC-KIND")) \
-             .setUdsDtcNumber(self.getChildElementOptionalIntegerValue(element, "UDS-DTC-NUMBER")) 
+             .setUdsDtcNumber(self.getChildElementOptionalIntegerValue(element, "UDS-DTC-NUMBER"))
+        
+    def readDiagnosticEventInfoNeeds(self, element: ET.Element, parent: SwcServiceDependency):
+        short_name = self.getShortName(element)
+        needs = parent.createDiagnosticEventInfoNeeds(short_name)
+        self.logger.debug("Read DiagnosticEventInfoNeeds %s" % short_name)
+        self.readIdentifiable(element, needs)
+        needs.setUdsDtcNumber(self.getChildElementOptionalPositiveInteger(element, "UDS-DTC-NUMBER"))
 
     def readCryptoServiceNeeds(self, element: ET.Element, parent: SwcServiceDependency):
         short_name = self.getShortName(element)
         needs = parent.createCryptoServiceNeeds(short_name)
-        self.logger.debug("read DiagnosticValueNeeds %s" % short_name)
+        self.logger.debug("Read DiagnosticValueNeeds %s" % short_name)
         self.readIdentifiable(element, needs)
         needs.setMaximumKeyLength(self.getChildElementOptionalPositiveInteger(element, "MAXIMUM-KEY-LENGTH"))
 
@@ -507,6 +518,8 @@ class ARXMLParser(AbstractARXMLParser):
                 self.readDiagnosticValueNeeds(child_element, parent)
             elif tag_name == "DIAGNOSTIC-EVENT-NEEDS":
                 self.readDiagnosticEventNeeds(child_element, parent)
+            elif tag_name == "DIAGNOSTIC-EVENT-INFO-NEEDS":
+                self.readDiagnosticEventInfoNeeds(child_element, parent)
             elif tag_name == "CRYPTO-SERVICE-NEEDS":
                 self.readCryptoServiceNeeds(child_element, parent)
             elif tag_name == "ECU-STATE-MGR-USER-NEEDS":
@@ -540,6 +553,18 @@ class ARXMLParser(AbstractARXMLParser):
                 include_data_type_set.addDataTypeRef(ref_type)
             include_data_type_sets.append(include_data_type_set)
         return include_data_type_sets
+    
+    def readSwcInternalBehaviorArTypedPerInstanceMemories(self, element: ET.Element, parent: SwcInternalBehavior):
+        for child_element in self.findall(element, "AR-TYPED-PER-INSTANCE-MEMORYS/VARIABLE-DATA-PROTOTYPE"):
+            short_name = self.getShortName(child_element)
+            prototype = parent.createArTypedPerInstanceMemory(short_name)
+            self.readVariableDataPrototype(child_element, prototype)
+
+    def readSwcInternalBehaviorSharedParameters(self, element: ET.Element, behavior: SwcInternalBehavior):
+        for child_element in self.findall(element, "SHARED-PARAMETERS/PARAMETER-DATA-PROTOTYPE"):
+            short_name = self.getShortName(child_element)
+            prototype = behavior.createSharedParameter(short_name)
+            self.readParameterDataPrototype(child_element, prototype)
 
     def readSwcInternalBehavior(self, element: ET.Element, parent: AtomicSwComponentType):
         for child_element in self.findall(element, "INTERNAL-BEHAVIORS/SWC-INTERNAL-BEHAVIOR"):
@@ -551,16 +576,17 @@ class ARXMLParser(AbstractARXMLParser):
             self.readInternalBehavior(child_element, behavior)
             
             # read the extra SwcInternalBehavior
+            self.readSwcInternalBehaviorArTypedPerInstanceMemories(child_element, behavior)
             self.readSwcInternalBehaviorRunnables(child_element, behavior)
             self.readSwcInternalBehaviorEvents(child_element, behavior)
             self.readSwcInternalBehaviorServiceDependencies(child_element, behavior)
             self.readExplicitInterRunnableVariables(child_element, behavior)
-            for data_type_set  in self.getIncludedDataTypeSets(child_element):
-                behavior.addIncludedDataTypeSet(data_type_set)
-            behavior.handleTerminationAndRestart = self.getChildElementOptionalLiteral(child_element, "HANDLE-TERMINATION-AND-RESTART")
+            
+            behavior.setHandleTerminationAndRestart(self.getChildElementOptionalLiteral(child_element, "HANDLE-TERMINATION-AND-RESTART"))
             self.readPerInstanceMemories(child_element, behavior)
             self.readPerInstanceParameters(child_element, behavior)
             self.readPortAPIOptions(child_element, behavior)
+            self.readSwcInternalBehaviorSharedParameters(child_element, behavior)
             behavior.setSupportsMultipleInstantiation(self.getChildElementOptionalBooleanValue(child_element, "SUPPORTS-MULTIPLE-INSTANTIATION"))
 
     def getIncludedModeDeclarationGroupSets(self, element: ET.Element) -> List[IncludedModeDeclarationGroupSet]:
@@ -799,21 +825,21 @@ class ARXMLParser(AbstractARXMLParser):
         argument = RunnableEntityArgument()
         argument.setSymbol(self.getChildElementOptionalLiteral(element, "SYMBOL"))
         return argument
-
+    
     def getAutosarParameterRef(self, element: ET.Element, key: str) -> AutosarParameterRef:
-        accessed_parameter = None
+        parameter = None
         child_element = self.find(element, key)
         if child_element is not None:
-            accessed_parameter = AutosarParameterRef()
-            accessed_parameter.local_parameter_ref = self.getChildElementOptionalRefType(child_element, "LOCAL-PARAMETER-REF")
-        return accessed_parameter
+            parameter = AutosarParameterRef()
+            parameter.setLocalParameterRef(self.getChildElementOptionalRefType(child_element, "LOCAL-PARAMETER-REF"))
+        return parameter
 
     def readParameterAccesses(self, element: ET.Element, parent: RunnableEntity):
         for child_element in self.findall(element, "PARAMETER-ACCESSS/PARAMETER-ACCESS"):
             short_name = self.getShortName(child_element)
             self.logger.debug("readParameterAccesses %s" % short_name)
             parameter_access = parent.createParameterAccess(short_name)
-            parameter_access.accessed_parameter = self.getAutosarParameterRef(child_element, "ACCESSED-PARAMETER")
+            parameter_access.setAccessedParameter(self.getAutosarParameterRef(child_element, "ACCESSED-PARAMETER"))
 
     def readWrittenLocalVariables(self, element: ET.Element, parent: RunnableEntity):
         self._readVariableAccesses(element, parent, "WRITTEN-LOCAL-VARIABLES")
@@ -991,7 +1017,7 @@ class ARXMLParser(AbstractARXMLParser):
     def readVariableDataPrototype(self, element: ET.Element, prototype: VariableDataPrototype):
         self.readAutosarDataPrototype(element, prototype)
         prototype.setInitValue(self.getInitValue(element))
-        
+
     def readExplicitInterRunnableVariables(self, element: ET.Element, parent: SwcInternalBehavior):
         for child_element in self.findall(element, "EXPLICIT-INTER-RUNNABLE-VARIABLES/VARIABLE-DATA-PROTOTYPE"):
             short_name = self.getShortName(child_element)
@@ -1016,7 +1042,7 @@ class ARXMLParser(AbstractARXMLParser):
         self.readIdentifiable(element, prototype)
         self.readAutosarDataPrototype(element, prototype)
         prototype.setInitValue(self.getInitValue(element))
-        
+
     def readPerInstanceParameters(self, element: ET.Element, behavior: SwcInternalBehavior):
         for child_element in self.findall(element, "PER-INSTANCE-PARAMETERS/PARAMETER-DATA-PROTOTYPE"):
             short_name = self.getShortName(child_element)
@@ -1356,16 +1382,17 @@ class ARXMLParser(AbstractARXMLParser):
         '''
 
     def readBaseTypeDirectDefinition(self, element: ET.Element, definition: BaseTypeDirectDefinition):
-        definition.baseTypeSize = self.getChildElementOptionalNumericalValue(element, "BASE-TYPE-SIZE")
-        definition.baseTypeEncoding = self.getChildElementOptionalLiteral(element, "BASE-TYPE-ENCODING")
-        definition.memAlignment = self.getChildElementOptionalNumericalValue(element, "MEM-ALIGNMENT")
-        definition.nativeDeclaration = self.getChildElementOptionalLiteral(element, "NATIVE-DECLARATION")
+        definition.setBaseTypeSize(self.getChildElementOptionalNumericalValue(element, "BASE-TYPE-SIZE")) \
+                  .setBaseTypeEncoding(self.getChildElementOptionalLiteral(element, "BASE-TYPE-ENCODING")) \
+                  .setByteOrder(self.getChildElementOptionalLiteral(element, "BYTE-ORDER")) \
+                  .setMemAlignment(self.getChildElementOptionalNumericalValue(element, "MEM-ALIGNMENT")) \
+                  .setNativeDeclaration(self.getChildElementOptionalLiteral(element, "NATIVE-DECLARATION"))
 
     def readSwBaseType(self, element: ET.Element, parent: ARPackage):
         short_name = self.getShortName(element)
         data_type = parent.createSwBaseType(short_name)
         self.readIdentifiable(element, data_type)
-        self.readBaseTypeDirectDefinition(element, data_type.baseTypeDefinition)
+        self.readBaseTypeDirectDefinition(element, data_type.getBaseTypeDefinition())
 
     def getApplicationCompositeElementInPortInterfaceInstanceRef(self, element: ET.Element, key:str) -> ApplicationCompositeElementInPortInterfaceInstanceRef:
         child_element = self.find(element, key)
@@ -1464,7 +1491,9 @@ class ARXMLParser(AbstractARXMLParser):
     def getModeSwitchReceiverComSpec(self, element: ET.Element) -> ModeSwitchReceiverComSpec:
         com_spec = ModeSwitchReceiverComSpec()
         self.readARObjectAttributes(element, com_spec)
-        com_spec.modeGroupRef = self.getChildElementOptionalRefType(element, "MODE-GROUP-REF")
+        com_spec.setEnhancedModeApi(self.getChildElementOptionalBooleanValue(element, "ENHANCED-MODE-API")) \
+                .setModeGroupRef(self.getChildElementOptionalRefType(element, "MODE-GROUP-REF")) \
+                .setSupportsAsynchronousModeSwitch(self.getChildElementOptionalBooleanValue(element, "SUPPORTS-ASYNCHRONOUS-MODE-SWITCH"))
         return com_spec
 
     def getNonqueuedReceiverComSpec(self, element: ET.Element) -> NonqueuedReceiverComSpec:
@@ -2243,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
@@ -2255,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")) \
@@ -2442,9 +2471,313 @@ 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
+        if element is not None:
+            configuration = Ipv6Configuration()
+            configuration.setAssignmentPriority(self.getChildElementOptionalPositiveInteger(element, "ASSIGNMENT-PRIORITY")) \
+                         .setDefaultRouter(self.getChildElementOptionalLiteral(element, "DEFAULT-ROUTER")) \
+                         .setEnableAnycast(self.getChildElementOptionalBooleanValue(element, "ENABLE-ANYCAST")) \
+                         .setHopCount(self.getChildElementOptionalPositiveInteger(element, "HOP-COUNT")) \
+                         .setIpAddressPrefixLength(self.getChildElementOptionalPositiveInteger(element, "IP-ADDRESS-PREFIX-LENGTH")) \
+                         .setIpv6Address(self.getChildElementOptionalLiteral(element, "IPV-6-ADDRESS")) \
+                         .setIpv6AddressSource(self.getChildElementOptionalLiteral(element, "IPV-6-ADDRESS-SOURCE"))
+        return configuration
+
+    def readNetworkEndPointNetworkEndPointAddress(self, element: ET.Element, end_point: NetworkEndpoint):
+        for child_element in self.findall(element, "NETWORK-ENDPOINT-ADDRESSES/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "IPV-6-CONFIGURATION":
+                end_point.addNetworkEndpointAddress(self.getIpv6Configuration(child_element))
+            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"))
+
+    def readEthernetPhysicalChannelNetworkEndPoints(self, element: ET.Element, channel: EthernetPhysicalChannel):
+        for child_element in self.findall(element, "NETWORK-ENDPOINTS/NETWORK-ENDPOINT"):
+            end_point = channel.createNetworkEndPoint(self.getShortName(child_element))
+            self.readNetworkEndPoint(child_element, end_point)
+
+    def getSocketConnectionIpduIdentifier(self, element: ET.Element) -> SocketConnectionIpduIdentifier:
+        identifier = None
+        if element is not None:
+            identifier = SocketConnectionIpduIdentifier()
+            identifier.setHeaderId(self.getChildElementOptionalPositiveInteger(element, "HEADER-ID")) \
+                      .setPduCollectionSemantics(self.getChildElementOptionalLiteral(element, "PDU-COLLECTION-SEMANTICS")) \
+                      .setPduCollectionTrigger(self.getChildElementOptionalLiteral(element, "PDU-COLLECTION-TRIGGER")) \
+                      .setPduRef(self.getChildElementOptionalRefType(element, "PDU-REF")) \
+                      .setPduTriggeringRef(self.getChildElementOptionalRefType(element, "PDU-TRIGGERING-REF"))
+        return identifier
+
+    def getSocketConnectionPdus(self, element: ET.Element) -> List[SocketConnectionIpduIdentifier]:
+        pdus = []
+        for child_element in self.findall(element, "PDUS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "SOCKET-CONNECTION-IPDU-IDENTIFIER":
+                pdus.append(self.getSocketConnectionIpduIdentifier(child_element))
+            else:
+                self.notImplemented("Unsupported Pdu <%s>" % tag_name)
+        return pdus
+
+    def getSocketConnection(self, element: ET.Element) -> SocketConnection:
+        connection = None
+        if element is not None:
+            connection = SocketConnection()
+            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
+         
+    def readSocketConnectionBundleConnections(self, element: ET.Element, bundle: SocketConnectionBundle):
+        for child_element in self.findall(element, "BUNDLED-CONNECTIONS/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "SOCKET-CONNECTION":
+                bundle.addBundledConnection(self.getSocketConnection(child_element))
+            else: 
+                self.notImplemented("Unsupported Bundled Connection <%s>" % tag_name)
+
+    def readSocketConnectionBundle(self, element: ET.Element, bundle: SocketConnectionBundle):
+        self.readSocketConnectionBundleConnections(element, bundle)
+        bundle.setServerPortRef(self.getChildElementOptionalRefType(element, "SERVER-PORT-REF"))
+
+    def readSoAdConfigConnectionBundles(self, element: ET.Element, config: SoAdConfig):
+        for child_element in self.findall(element, "CONNECTION-BUNDLES/*"):
+            tag_name = self.getTagName(child_element)
+            if tag_name == "SOCKET-CONNECTION-BUNDLE":
+                bundle = config.createSocketConnectionBundle(self.getShortName(child_element))
+                self.readSocketConnectionBundle(child_element, bundle)
+            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.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":
+                address = config.createSocketAddress(self.getShortName(child_element))
+                self.readSocketAddress(child_element, address)
+            else:
+                self.notImplemented("Unsupported Socket Address <%s>" % tag_name)
+
+    def getSoAdConfig(self, element: ET.Element, key: str) -> SoAdConfig:
+        child_element = self.find(element, key)
+        config = None
+        if child_element is not None:
+            config = SoAdConfig()
+            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/*"):
@@ -2455,6 +2788,9 @@ class ARXMLParser(AbstractARXMLParser):
             elif tag_name == "LIN-PHYSICAL-CHANNEL":
                 channel = cluster.createLinPhysicalChannel(self.getShortName(child_element))
                 self.readLinPhysicalChannel(child_element, channel)
+            elif tag_name == "ETHERNET-PHYSICAL-CHANNEL":
+                channel = cluster.createEthernetPhysicalChannel(self.getShortName(child_element))
+                self.readEthernetPhysicalChannel(child_element, channel)
             else:
                 self.notImplemented("Unsupported Physical Channel <%s>" % tag_name)
 
@@ -2464,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):
@@ -2488,6 +2835,80 @@ class ARXMLParser(AbstractARXMLParser):
             self.readCommunicationCluster(child_element, cluster)
             self.readAbstractCanCluster(child_element, cluster)
 
+    def readEthernetCluster(self, element: ET.Element, parent: ARPackage):
+        short_name = self.getShortName(element)
+        self.logger.debug("Read EthernetCluster %s" % short_name)
+        cluster = parent.createEthernetCluster(short_name)
+        self.readIdentifiable(element, cluster)
+        child_element = self.find(element, "ETHERNET-CLUSTER-VARIANTS/ETHERNET-CLUSTER-CONDITIONAL")
+        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)
@@ -2542,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"))
@@ -2550,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)
 
@@ -2580,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())
@@ -2587,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"))
@@ -2601,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")) \
@@ -2619,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)
     
@@ -2648,7 +3092,15 @@ class ARXMLParser(AbstractARXMLParser):
         self.readFrame(element, frame)
 
     def readCanCommunicationController(self, element: ET.Element, controller: CanCommunicationController):
-        self.logger.debug("read CanCommunicationController %s" % controller.getShortName())
+        self.logger.debug("Read CanCommunicationController %s" % controller.getShortName())
+        self.readIdentifiable(element, controller)
+
+    def readEthernetCommunicationController(self, element: ET.Element, controller: EthernetCommunicationController):
+        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):
@@ -2658,6 +3110,12 @@ class ARXMLParser(AbstractARXMLParser):
             if tag_name == "CAN-COMMUNICATION-CONTROLLER":
                 controller = instance.createCanCommunicationController(self.getShortName(child_element))
                 self.readCanCommunicationController(child_element, controller)
+            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)
 
@@ -2698,6 +3156,12 @@ class ARXMLParser(AbstractARXMLParser):
     def readCanCommunicationConnector(self, element: ET.Element, connector: CanCommunicationConnector):
         self.readCommunicationConnector(element, connector)
 
+    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):
         self.logger.debug("readEcuInstanceCommControllers %s" % instance.getShortName())
         for child_element in self.findall(element, "CONNECTORS/*"):
@@ -2705,8 +3169,14 @@ class ARXMLParser(AbstractARXMLParser):
             if tag_name == "CAN-COMMUNICATION-CONNECTOR":
                 connector = instance.createCanCommunicationConnector(self.getShortName(child_element))
                 self.readCanCommunicationConnector(child_element, connector)
+            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 Controller <%s>" % tag_name)                
+                self._raiseError("Unsupported Communication Connector <%s>" % tag_name)                
 
     def readEcuInstance(self, element: ET.Element, parent: ARPackage):
         short_name = self.getShortName(element)
@@ -2768,6 +3238,7 @@ class ARXMLParser(AbstractARXMLParser):
         signal = parent.createISignal(short_name)
         self.readIdentifiable(element, signal)
         signal.setDataTypePolicy(self.getChildElementOptionalLiteral(element, "DATA-TYPE-POLICY")) \
+              .setISignalType(self.getChildElementOptionalLiteral(element, "I-SIGNAL-TYPE")) \
               .setInitValue(self.getInitValue(element)) \
               .setLength(self.getChildElementOptionalNumericalValue(element, "LENGTH")) \
               .setNetworkRepresentationProps(self.getSwDataDefProps(element, "NETWORK-REPRESENTATION-PROPS")) \
@@ -2932,7 +3403,8 @@ class ARXMLParser(AbstractARXMLParser):
         self.logger.debug("SystemSignal %s" % short_name)
         signal = parent.createSystemSignal(short_name)
         self.readIdentifiable(element, signal)
-        signal.setDynamicLength(self.getChildElementOptionalBooleanValue(element, "DYNAMIC-LENGTH"))
+        signal.setDynamicLength(self.getChildElementOptionalBooleanValue(element, "DYNAMIC-LENGTH")) \
+              .setPhysicalProps(self.getSwDataDefProps(element, "PHYSICAL-PROPS"))
 
     def readSystemSignalGroup(self, element: ET.Element, parent: ARPackage):
         short_name = self.getShortName(element)
@@ -2985,6 +3457,8 @@ class ARXMLParser(AbstractARXMLParser):
         child_element = self.find(element, key)
         if child_element is not None:
             timing = CyclicTiming()
+            timing.setTimeOffset(self.getTimeRangeType(child_element, "TIME-OFFSET")) \
+                  .setTimePeriod(self.getTimeRangeType(child_element, "TIME-PERIOD"))
         return timing
 
     def getEventControlledTiming(self, element: ET.Element, key: str) -> EventControlledTiming:
@@ -3002,8 +3476,8 @@ class ARXMLParser(AbstractARXMLParser):
         if child_element is not None:
             self.logger.debug("Get TransmissionModeTiming of <%s>" % key)
             timing = TransmissionModeTiming()
-            #timing.getCyclicTiming(child_element, "")
-            timing.setEventControlledTiming(self.getEventControlledTiming(child_element, "EVENT-CONTROLLED-TIMING"))
+            timing.setCyclicTiming(self.getCyclicTiming(child_element, "CYCLIC-TIMING")) \
+                  .setEventControlledTiming(self.getEventControlledTiming(child_element, "EVENT-CONTROLLED-TIMING"))
         return timing
 
     def getTransmissionModeDeclaration(self, element: ET.Element, key: str) -> TransmissionModeDeclaration:
@@ -3021,7 +3495,8 @@ class ARXMLParser(AbstractARXMLParser):
         child_element = self.find(element, "I-PDU-TIMING-SPECIFICATIONS/I-PDU-TIMING")
         if child_element is not None:
             timing = IPduTiming()
-            timing.setTransmissionModeDeclaration(self.getTransmissionModeDeclaration(child_element, "TRANSMISSION-MODE-DECLARATION"))
+            timing.setMinimumDelay(self.getChildElementOptionalTimeValue(child_element, "MINIMUM-DELAY")) \
+                  .setTransmissionModeDeclaration(self.getTransmissionModeDeclaration(child_element, "TRANSMISSION-MODE-DECLARATION"))
         return timing
 
     def readISignalIPdu(self, element: ET.Element, parent: ARPackage):
@@ -3241,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)
@@ -3314,6 +3790,29 @@ class ARXMLParser(AbstractARXMLParser):
                 self.readFlatMap(child_element, parent)
             elif tag_name == "PORT-INTERFACE-MAPPING-SET":
                 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)