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

armodel/writer/arxml_writer.py

@@ -1,6 +1,9 @@
 import xml.etree.cElementTree as ET
 from typing import List
 
+from armodel.models.M2.AUTOSARTemplates.SystemTemplate.ECUResourceMapping import ECUMapping
+from armodel.models.M2.AUTOSARTemplates.SystemTemplate.SWmapping import SwcToImplMapping
+
 from ..models.M2.AUTOSARTemplates.GenericStructure.LifeCycles import LifeCycleInfoSet
 from ..models.M2.MSR.AsamHdo.AdminData import AdminData
 from ..models.M2.MSR.AsamHdo.BaseTypes import BaseTypeDirectDefinition, SwBaseType
@@ -25,12 +28,12 @@ from ..models.M2.AUTOSARTemplates.AutosarTopLevelStructure import AUTOSAR
 from ..models.M2.AUTOSARTemplates.BswModuleTemplate.BswOverview import BswModuleDescription
 from ..models.M2.AUTOSARTemplates.BswModuleTemplate.BswImplementation import BswImplementation
 from ..models.M2.AUTOSARTemplates.BswModuleTemplate.BswInterfaces import BswModuleEntry
-from ..models.M2.AUTOSARTemplates.BswModuleTemplate.BswBehavior import BswCalledEntity, BswEvent, BswInternalBehavior, BswInterruptEntity, BswModeSenderPolicy, BswModuleEntity, BswSchedulableEntity, BswScheduleEvent, BswTimingEvent
+from ..models.M2.AUTOSARTemplates.BswModuleTemplate.BswBehavior import BswBackgroundEvent, BswCalledEntity, BswDataReceivedEvent, BswEvent, BswExternalTriggerOccurredEvent, BswInternalBehavior, BswInterruptEntity, BswModeSenderPolicy, BswModuleEntity, BswSchedulableEntity, BswScheduleEvent, BswTimingEvent
 from ..models.M2.AUTOSARTemplates.CommonStructure import ApplicationValueSpecification, ArrayValueSpecification, ConstantReference, ConstantSpecification, NumericalValueSpecification, RecordValueSpecification, TextValueSpecification, ValueSpecification
 from ..models.M2.AUTOSARTemplates.CommonStructure.FlatMap import FlatInstanceDescriptor, FlatMap
 from ..models.M2.AUTOSARTemplates.CommonStructure.Filter import DataFilter
 from ..models.M2.AUTOSARTemplates.CommonStructure.SwcBswMapping import SwcBswMapping, SwcBswRunnableMapping
-from ..models.M2.AUTOSARTemplates.CommonStructure.Implementation import Code, Implementation
+from ..models.M2.AUTOSARTemplates.CommonStructure.Implementation import Code, Implementation, ImplementationProps
 from ..models.M2.AUTOSARTemplates.CommonStructure.Timing.TimingConstraint.TimingExtensions import SwcTiming, TimingExtension
 from ..models.M2.AUTOSARTemplates.CommonStructure.Timing.TimingConstraint.ExecutionOrderConstraint import EOCExecutableEntityRef, ExecutionOrderConstraint
 from ..models.M2.AUTOSARTemplates.CommonStructure.ServiceNeeds import CryptoServiceNeeds, DiagEventDebounceMonitorInternal, DiagnosticCommunicationManagerNeeds, DiagnosticEventInfoNeeds, DiagnosticEventNeeds, DiagnosticRoutineNeeds, DiagnosticValueNeeds, EcuStateMgrUserNeeds, NvBlockNeeds, RoleBasedDataAssignment, RoleBasedDataTypeAssignment, ServiceDependency
@@ -49,13 +52,13 @@ from ..models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ARPack
 from ..models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import RefType, ARLiteral, Limit
 
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.PortAPIOptions import PortAPIOption, PortDefinedArgumentValue
-from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.RTEEvents import AsynchronousServerCallReturnsEvent, DataReceivedEvent, InitEvent, InternalTriggerOccurredEvent, OperationInvokedEvent, RTEEvent, SwcModeSwitchEvent, TimingEvent
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.RTEEvents import AsynchronousServerCallReturnsEvent, BackgroundEvent, DataReceivedEvent, InitEvent, InternalTriggerOccurredEvent, ModeSwitchedAckEvent, OperationInvokedEvent, RTEEvent, SwcModeSwitchEvent, TimingEvent
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.IncludedDataTypes import IncludedDataTypeSet
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Datatype.Datatypes import ApplicationArrayDataType, ApplicationCompositeDataType, ApplicationDataType, ApplicationPrimitiveDataType, ApplicationRecordDataType, AutosarDataType
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.EndToEndProtection import EndToEndDescription, EndToEndProtection, EndToEndProtectionVariablePrototype
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.ModeDeclarationGroup import IncludedModeDeclarationGroupSet
-from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Communication import CompositeNetworkRepresentation, TransmissionAcknowledgementRequest
-from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Components import AbstractProvidedPortPrototype, AbstractRequiredPortPrototype, ApplicationSwComponentType, AtomicSwComponentType, ComplexDeviceDriverSwComponentType, CompositionSwComponentType, EcuAbstractionSwComponentType, PRPortPrototype, PortGroup, SwComponentType, PPortPrototype, PortPrototype, RPortPrototype
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Communication import CompositeNetworkRepresentation, ModeSwitchedAckRequest, TransmissionAcknowledgementRequest
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Components import AbstractProvidedPortPrototype, AbstractRequiredPortPrototype, ApplicationSwComponentType, AtomicSwComponentType, ComplexDeviceDriverSwComponentType, CompositionSwComponentType, EcuAbstractionSwComponentType, PRPortPrototype, PortGroup, SwComponentType, PPortPrototype, PortPrototype, RPortPrototype, SymbolProps
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Components.InstanceRefs import InnerPortGroupInCompositionInstanceRef, PModeGroupInAtomicSwcInstanceRef, RModeGroupInAtomicSWCInstanceRef, RModeInAtomicSwcInstanceRef, RVariableInAtomicSwcInstanceRef
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior import AsynchronousServerCallPoint, RunnableEntity, RunnableEntityArgument, SwcInternalBehavior, SynchronousServerCallPoint
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.AutosarVariableRef import AutosarVariableRef
@@ -78,23 +81,23 @@ from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcImplementation import S
 from ..models.M2.AUTOSARTemplates.SystemTemplate import SwcToEcuMapping, System, SystemMapping
 from ..models.M2.AUTOSARTemplates.SystemTemplate.DataMapping import SenderReceiverToSignalGroupMapping, SenderReceiverToSignalMapping
 from ..models.M2.AUTOSARTemplates.SystemTemplate.DiagnosticConnection import DiagnosticConnection
-from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.CoreCommunication import FrameTriggering, GeneralPurposeIPdu, GeneralPurposePdu, IPdu, IPduTiming, ISignalGroup, ISignalIPdu, ISignalIPduGroup, ISignalTriggering, MultiplexedIPdu, PduTriggering, SecureCommunicationPropsSet, SecuredIPdu, SystemSignal, DcmIPdu, Frame, ISignal, NPdu, NmPdu, SystemSignalGroup, UserDefinedIPdu, UserDefinedPdu
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.CoreCommunication import DynamicPart, DynamicPartAlternative, FrameTriggering, GeneralPurposeIPdu, GeneralPurposePdu, IPdu, IPduTiming, ISignalGroup, ISignalIPdu, ISignalIPduGroup, ISignalToIPduMapping, ISignalTriggering, MultiplexedIPdu, MultiplexedPart, Pdu, PduTriggering, SecureCommunicationAuthenticationProps, SecureCommunicationFreshnessProps, SecureCommunicationProps, SecureCommunicationPropsSet, SecuredIPdu, SegmentPosition, StaticPart, SystemSignal, DcmIPdu, Frame, ISignal, NPdu, NmPdu, SystemSignalGroup, UserDefinedIPdu, UserDefinedPdu
 from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.EcuInstance import EcuInstance
 from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.Timing import CyclicTiming, EventControlledTiming, TimeRangeType, TransmissionModeCondition, TransmissionModeDeclaration, TransmissionModeTiming
 from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Ethernet.EthernetCommunication import SoAdRoutingGroup, SocketConnection, SocketConnectionBundle, SocketConnectionIpduIdentifier
 from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Ethernet.EthernetFrame import GenericEthernetFrame
-from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Ethernet.EthernetTopology import EthernetCluster, EthernetCommunicationConnector, EthernetCommunicationController, InitialSdDelayConfig, RequestResponseDelay, SdClientConfig
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Ethernet.EthernetTopology import CouplingPort, CouplingPortDetails, CouplingPortFifo, CouplingPortScheduler, CouplingPortStructuralElement, EthernetCluster, EthernetCommunicationConnector, EthernetCommunicationController, EthernetPriorityRegeneration, InitialSdDelayConfig, MacMulticastGroup, RequestResponseDelay, SdClientConfig, VlanMembership
 from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Ethernet.NetworkEndpoint import DoIpEntity, InfrastructureServices, Ipv6Configuration, NetworkEndpoint, NetworkEndpointAddress
-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 Gateway, ISignalMapping
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Ethernet.ServiceInstances import ApplicationEndpoint, ConsumedEventGroup, ConsumedServiceInstance, EventHandler, GenericTp, ProvidedServiceInstance, SdServerConfig, SoAdConfig, SocketAddress, TcpTp, TpPort, TransportProtocolConfiguration, UdpTp
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Multiplatform import Gateway, IPduMapping, ISignalMapping, TargetIPduRef
 from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Can.CanCommunication import CanFrame, CanFrameTriggering, RxIdentifierRange
-from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Can.CanTopology import CanCommunicationConnector, CanCommunicationController
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Can.CanTopology import AbstractCanCommunicationController, AbstractCanCommunicationControllerAttributes, CanCommunicationConnector, CanCommunicationController, CanControllerConfigurationRequirements, CanControllerFdConfiguration, CanControllerFdConfigurationRequirements
 from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Lin.LinCommunication import ApplicationEntry, LinFrameTriggering, LinScheduleTable, LinUnconditionalFrame, ScheduleTableEntry
-from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.CoreTopology import AbstractCanCluster, CanCluster, CanClusterBusOffRecovery, CanPhysicalChannel, CommConnectorPort, CommunicationCluster, CommunicationConnector, EthernetPhysicalChannel, FramePort, IPduPort, ISignalPort, LinCluster, LinPhysicalChannel, PhysicalChannel
-from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Lin.LinTopology import LinCommunicationConnector, LinMaster
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.CoreTopology import AbstractCanCluster, CanCluster, CanClusterBusOffRecovery, CanPhysicalChannel, CommConnectorPort, CommunicationCluster, CommunicationConnector, CommunicationController, EthernetPhysicalChannel, FramePort, IPduPort, ISignalPort, LinCluster, LinPhysicalChannel, PhysicalChannel
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Lin.LinTopology import LinCommunicationConnector, LinCommunicationController, LinMaster
 from ..models.M2.AUTOSARTemplates.SystemTemplate.InstanceRefs import ComponentInSystemInstanceRef, VariableDataPrototypeInSystemInstanceRef
-from ..models.M2.AUTOSARTemplates.SystemTemplate.NetworkManagement import CanNmCluster, CanNmClusterCoupling, CanNmNode, NmCluster, NmConfig, NmNode, UdpNmCluster, UdpNmClusterCoupling, UdpNmNode
-from ..models.M2.AUTOSARTemplates.SystemTemplate.TransportProtocols import CanTpConfig, DoIpTpConfig
+from ..models.M2.AUTOSARTemplates.SystemTemplate.NetworkManagement import CanNmCluster, CanNmClusterCoupling, CanNmNode, NmCluster, NmConfig, NmEcu, NmNode, UdpNmCluster, UdpNmClusterCoupling, UdpNmEcu, UdpNmNode
+from ..models.M2.AUTOSARTemplates.SystemTemplate.TransportProtocols import CanTpAddress, CanTpChannel, CanTpConfig, CanTpConnection, CanTpEcu, CanTpNode, DoIpLogicAddress, DoIpTpConfig, DoIpTpConnection, LinTpConfig, LinTpConnection, LinTpNode, TpAddress, TpConfig, TpConnection
 
 from .abstract_arxml_writer import AbstractARXMLWriter
 class ARXMLWriter(AbstractARXMLWriter):
@@ -120,14 +123,26 @@ class ARXMLWriter(AbstractARXMLWriter):
                 sd_tag.attrib['GID'] = sd.gid
             sd_tag.text = sd.value
 
-    def setSdg(self, parent: ET.Element, sdg: Sdg):
+    def writeSdgCaption(self, element: ET.Element, sdg: Sdg):
+        caption = sdg.getSdgCaption()
+        if caption is not None:
+            child_element = ET.SubElement(element, "SDG-CAPTION")
+            self.writeMultilanguageReferrable(child_element, caption)
+
+    def writeSdgSdxRefs(self, element: ET.Element, sdg: Sdg):
+        for ref in sdg.getSdxRefs():
+            self.setChildElementOptionalRefType(element, "SDX-REF", ref)
+
+    def setSdg(self, element: ET.Element, sdg: Sdg):
         if sdg is not None:
-            sdg_tag = ET.SubElement(parent, "SDG")
+            child_element = ET.SubElement(element, "SDG")
             if sdg.gid is not None and sdg.gid != "":
-                sdg_tag.attrib['GID'] = sdg.gid
-            self.writeSds(sdg_tag, sdg)
+                child_element.attrib['GID'] = sdg.gid
+            self.writeSdgCaption(child_element, sdg)
+            self.writeSds(child_element, sdg)
             for sdg_item in sdg.getSdgContentsTypes():
-                self.setSdg(sdg_tag, sdg_item)
+                self.setSdg(child_element, sdg_item)
+            self.writeSdgSdxRefs(child_element, sdg)
             
     def writeSdgs(self, parent: ET.Element, admin_data: AdminData):
         sdgs = admin_data.getSdgs()
@@ -139,18 +154,18 @@ class ARXMLWriter(AbstractARXMLWriter):
     def setChildLimitElement(self, element: ET.Element, key: str, limit: Limit):
         if limit is not None:
             limit_tag = ET.SubElement(element, key)
-            self.setARObjectAttributes(limit_tag, limit)
+            self.writeARObjectAttributes(limit_tag, limit)
             if limit.intervalType is not None:
                 limit_tag.attrib['INTERVAL-TYPE'] = limit.intervalType
             limit_tag.text = limit.value
     
-    def setReferable(self, element: ET.Element, referrable: Referrable):
-        self.setARObjectAttributes(element, referrable)
+    def writeReferrable(self, element: ET.Element, referrable: Referrable):
+        self.writeARObjectAttributes(element, referrable)
         self.setShortName(element, referrable.getShortName())
 
     def setLanguageSpecific(self, element: ET.Element, key: str, specific: LanguageSpecific):
         child_element = ET.SubElement(element, key)
-        self.setARObjectAttributes(child_element, specific)
+        self.writeARObjectAttributes(child_element, specific)
         if specific.l is not None:
             child_element.attrib['L'] = specific.l
         child_element.text = specific.value
@@ -161,7 +176,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     def setMultiLongName(self, element: ET.Element, key: str, long_name: MultilanguageLongName):
         if long_name is not None:
             child_element = ET.SubElement(element, key)
-            self.setARObjectAttributes(child_element, long_name)
+            self.writeARObjectAttributes(child_element, long_name)
             for l4 in long_name.getL4s():
                 self.setLLongName(child_element, l4)
 
@@ -171,12 +186,12 @@ class ARXMLWriter(AbstractARXMLWriter):
     def setMultiLanguageOverviewParagraph(self, element: ET.Element, key: str, paragraph: MultiLanguageOverviewParagraph):
         if paragraph is not None:
             child_element = ET.SubElement(element, key)
-            self.setARObjectAttributes(child_element, paragraph)
+            self.writeARObjectAttributes(child_element, paragraph)
             for l2 in paragraph.getL2s():
                 self.setLOverviewParagraph(child_element, l2)
 
-    def setMultilanguageReferrable(self, element: ET.Element, referrable: MultilanguageReferrable):
-        self.setReferable(element, referrable)
+    def writeMultilanguageReferrable(self, element: ET.Element, referrable: MultilanguageReferrable):
+        self.writeReferrable(element, referrable)
         if referrable.longName is not None:
             self.setMultiLongName(element, "LONG-NAME", referrable.longName)
 
@@ -186,7 +201,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     def setMultiLanguagePlainText(self, element: ET.Element, key: str, paragraph: MultiLanguagePlainText):
         if paragraph is not None:
             child_element = ET.SubElement(element, key)
-            self.setARObjectAttributes(child_element, paragraph)
+            self.writeARObjectAttributes(child_element, paragraph)
             for l10 in paragraph.getL10s():
                 self.setLPlainText(child_element, l10)
 
@@ -198,20 +213,20 @@ class ARXMLWriter(AbstractARXMLWriter):
             self.writeSdgs(child_element, admin_data)
 
     def writeIdentifiable(self, element: ET.Element, identifiable: Identifiable):
-        self.setMultilanguageReferrable(element, identifiable)
+        self.writeMultilanguageReferrable(element, identifiable)
         self.setAnnotations(element, identifiable.getAnnotations())
         self.setMultiLanguageOverviewParagraph(element, "DESC", identifiable.getDesc())
         self.setChildElementOptionalLiteral(element, "CATEGORY", identifiable.getCategory())
         self.setDocumentationBlock(element, "INTRODUCTION", identifiable.getIntroduction())
         self.setAdminData(element, identifiable.getAdminData())
 
-    def setARElement(self, parent: ET.Element, ar_element: ARElement):
+    def writeARElement(self, parent: ET.Element, ar_element: ARElement):
         self.writeIdentifiable(parent, ar_element)
     
     def setTransmissionAcknowledgementRequest(self, element: ET.Element, acknowledge: TransmissionAcknowledgementRequest):
         if (acknowledge != None):
             child_element = ET.SubElement(element, "TRANSMISSION-ACKNOWLEDGE")
-            self.setARObjectAttributes(child_element, acknowledge)
+            self.writeARObjectAttributes(child_element, acknowledge)
             if acknowledge.timeout != None:
                 self.setChildElementOptionalFloatValue(child_element, "TIMEOUT", acknowledge.timeout)
 
@@ -229,25 +244,32 @@ class ARXMLWriter(AbstractARXMLWriter):
     
     def setNonqueuedSenderComSpec(self, element: ET.Element, com_spec: NonqueuedSenderComSpec):
         child_element = ET.SubElement(element, "NONQUEUED-SENDER-COM-SPEC")
-        self.setARObjectAttributes(child_element, com_spec)
+        self.writeARObjectAttributes(child_element, com_spec)
         self.setSenderComSpec(child_element, com_spec)
         self.setValueSpecification(child_element, "INIT-VALUE", com_spec.getInitValue())
             
     def setServerComSpec(self, element: ET.Element, com_spec: ServerComSpec):
         child_element = ET.SubElement(element, "SERVER-COM-SPEC")
-        self.setARObjectAttributes(child_element, com_spec)
+        self.writeARObjectAttributes(child_element, com_spec)
         self.setChildElementOptionalRefType(child_element, "OPERATION-REF", com_spec.getOperationRef())
         self.setChildElementOptionalNumericalValue(child_element, "QUEUE-LENGTH",    com_spec.getQueueLength())
 
     def setQueuedSenderComSpec(self, element: ET.Element, com_spec: QueuedSenderComSpec):
         child_element = ET.SubElement(element, "QUEUED-SENDER-COM-SPEC")
-        self.setARObjectAttributes(child_element, com_spec)
+        self.writeARObjectAttributes(child_element, com_spec)
         self.setSenderComSpec(child_element, com_spec)
 
+    def setModeSwitchedAckRequest(self, element: ET.Element, key: str, request: ModeSwitchedAckRequest):
+        if request is not None:
+            child_element = ET.SubElement(element, key)
+            self.writeARObjectAttributes(child_element, request)
+            self.setChildElementOptionalTimeValue(child_element, "TIMEOUT", request.getTimeout())
+
     def setModeSwitchSenderComSpec(self, element: ET.Element, com_spec: ModeSwitchSenderComSpec):
         child_element = ET.SubElement(element, "MODE-SWITCH-SENDER-COM-SPEC")
-        self.setARObjectAttributes(child_element, com_spec)
+        self.writeARObjectAttributes(child_element, com_spec)
         self.setChildElementOptionalRefType(child_element, "MODE-GROUP-REF", com_spec.getModeGroupRef())
+        self.setModeSwitchedAckRequest(child_element, "MODE-SWITCHED-ACK", com_spec.getModeSwitchedAck())
         self.setChildElementOptionalNumericalValue(child_element, "QUEUE-LENGTH", com_spec.getQueueLength())
     
     def writePPortComSpec(self, com_specs_tag: ET.Element, com_spec: PPortComSpec):
@@ -291,7 +313,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     def setSwValues(self, element: ET.Element, key: str, sw_values: SwValues):
         if sw_values is not None:
             child_element = ET.SubElement(element, key)
-            self.setARObjectAttributes(child_element, sw_values)
+            self.writeARObjectAttributes(child_element, sw_values)
             for v in sw_values.getVs():
                 self.setChildElementOptionalFloatValue(child_element, "V", v)
             self.setChildElementOptionalLiteral(child_element, "VT", sw_values.vt)
@@ -299,20 +321,20 @@ class ARXMLWriter(AbstractARXMLWriter):
     def setValueList(self, element: ET.Element, key: str, value_list: ValueList):
         if value_list is not None:
             child_element = ET.SubElement(element, key)
-            self.setARObjectAttributes(child_element, value_list)
+            self.writeARObjectAttributes(child_element, value_list)
             self.setChildElementOptionalFloatValue(child_element, "V", value_list.v)
 
     def writeSwValueCont(self, element: ET.Element, cont: SwValueCont):
         if cont is not None:
             child_element = ET.SubElement(element, "SW-VALUE-CONT")
-            self.setARObjectAttributes(child_element, cont)
+            self.writeARObjectAttributes(child_element, cont)
             self.setChildElementOptionalRefType(child_element, "UNIT-REF", cont.unitRef)
             self.setValueList(child_element, "SW-ARRAYSIZE", cont.swArraysize)
             self.setSwValues(child_element, "SW-VALUES-PHYS", cont.swValuesPhys)
 
     def writeValueSpecification(self, element: ET.Element, value_spec: ValueSpecification):
         if value_spec is not None:
-            self.setARObjectAttributes(element, value_spec)
+            self.writeARObjectAttributes(element, value_spec)
             self.setChildElementOptionalLiteral(element, "SHORT-LABEL", value_spec.getShortLabel())                                
 
     def setApplicationValueSpecification(self, element: ET.Element, value_spec: ApplicationValueSpecification):
@@ -379,7 +401,7 @@ class ARXMLWriter(AbstractARXMLWriter):
 
     def writeNonqueuedReceiverComSpec(self, element: ET.Element, com_spec: NonqueuedReceiverComSpec):
         child_element = ET.SubElement(element, "NONQUEUED-RECEIVER-COM-SPEC")
-        self.setARObjectAttributes(child_element, com_spec)
+        self.writeARObjectAttributes(child_element, com_spec)
         self.writeReceiverComSpec(child_element, com_spec)
         self.setChildElementOptionalFloatValue(child_element, "ALIVE-TIMEOUT", com_spec.getAliveTimeout())
         self.setChildElementOptionalBooleanValue(child_element, "ENABLE-UPDATE", com_spec.getEnableUpdated())
@@ -390,27 +412,27 @@ class ARXMLWriter(AbstractARXMLWriter):
 
     def writeQueuedReceiverComSpec(self, element: ET.Element, com_spec: QueuedReceiverComSpec):
         child_element = ET.SubElement(element, "QUEUED-RECEIVER-COM-SPEC")
-        self.setARObjectAttributes(child_element, com_spec)
+        self.writeARObjectAttributes(child_element, com_spec)
         self.writeReceiverComSpec(child_element, com_spec)
         self.setChildElementOptionalNumericalValue(child_element, "QUEUE-LENGTH", com_spec.queueLength)
     
     def writeClientComSpec(self, element: ET.Element, com_spec: ClientComSpec):
         self.logger.debug("writeClientComSpec")
         child_element = ET.SubElement(element, "CLIENT-COM-SPEC")
-        self.setARObjectAttributes(child_element, com_spec)
+        self.writeARObjectAttributes(child_element, com_spec)
         self.setChildElementOptionalRefType(child_element, "OPERATION-REF", com_spec.getOperationRef())
 
     def writeParameterRequireComSpec(self, element: ET.Element, com_spec: ParameterRequireComSpec):
         self.logger.debug("writeParameterRequireComSpec")
         child_element = ET.SubElement(element, "PARAMETER-REQUIRE-COM-SPEC")
-        self.setARObjectAttributes(child_element, com_spec)
+        self.writeARObjectAttributes(child_element, com_spec)
         self.setChildElementOptionalRefType(child_element, "PARAMETER-REF", com_spec.getParameterRef())
         self.setValueSpecification(child_element, "INIT-VALUE", com_spec.getInitValue())
 
     def setModeSwitchReceiverComSpec(self, element: ET.Element, com_spec: ModeSwitchReceiverComSpec):
         self.logger.debug("writeModeSwitchReceiverComSpec")
         child_element = ET.SubElement(element, "MODE-SWITCH-RECEIVER-COM-SPEC")
-        self.setARObjectAttributes(child_element, com_spec)
+        self.writeARObjectAttributes(child_element, com_spec)
         self.setChildElementOptionalBooleanValue(child_element, "ENHANCED-MODE-API", com_spec.getEnhancedModeApi())
         self.setChildElementOptionalRefType(child_element, "MODE-GROUP-REF", com_spec.getModeGroupRef())
         self.setChildElementOptionalBooleanValue(child_element, "SUPPORTS-ASYNCHRONOUS-MODE-SWITCH", com_spec.getSupportsAsynchronousModeSwitch())
@@ -539,14 +561,14 @@ class ARXMLWriter(AbstractARXMLWriter):
         if sw_connector.getProviderIRef() is not None:
             provider_iref_tag = ET.SubElement(child_element, "PROVIDER-IREF")
             provider_iref = sw_connector.getProviderIRef()
-            self.setARObjectAttributes(provider_iref_tag, provider_iref)
+            self.writeARObjectAttributes(provider_iref_tag, provider_iref)
             self.setChildElementOptionalRefType(provider_iref_tag, "CONTEXT-COMPONENT-REF", provider_iref.getContextComponentRef())
             self.setChildElementOptionalRefType(provider_iref_tag, "TARGET-P-PORT-REF", provider_iref.getTargetPPortRef())
 
         if sw_connector.getRequesterIRef() is not None:
             requester_iref_tag = ET.SubElement(child_element, "REQUESTER-IREF")
             requester_iref = sw_connector.getRequesterIRef()
-            self.setARObjectAttributes(requester_iref_tag, requester_iref)
+            self.writeARObjectAttributes(requester_iref_tag, requester_iref)
             self.setChildElementOptionalRefType(requester_iref_tag, "CONTEXT-COMPONENT-REF", requester_iref.getContextComponentRef())
             self.setChildElementOptionalRefType(requester_iref_tag, "TARGET-R-PORT-REF", requester_iref.getTargetRPortRef())
 
@@ -615,7 +637,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     def writeLParagraphs(self, element: ET.Element, paragraph: MultiLanguageParagraph):
         for l1 in paragraph.getL1s():
             l1_tag = ET.SubElement(element, "L-1")
-            self.setARObjectAttributes(l1_tag, l1)
+            self.writeARObjectAttributes(l1_tag, l1)
             if l1.l is not None:
                 l1_tag.attrib['L'] = l1.l
                 l1_tag.text = l1.value
@@ -623,7 +645,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     def setMultiLanguageParagraphs(self, element: ET.Element, key: str, paragraphs: List[MultiLanguageParagraph]):
         for paragraph in paragraphs:
             child_element = ET.SubElement(element, key)
-            self.setARObjectAttributes(child_element, paragraph)
+            self.writeARObjectAttributes(child_element, paragraph)
             self.writeLParagraphs(child_element, paragraph)
         return paragraphs
     
@@ -639,7 +661,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     def setDocumentationBlock(self, element: ET.Element, key: str, block: DocumentationBlock):
         if block is not None:
             child_element = ET.SubElement(element, key)
-            self.setARObjectAttributes(child_element, block)
+            self.writeARObjectAttributes(child_element, block)
             self.setMultiLanguageParagraphs(child_element, "P", block.getPs())
             for list in block.getLists():
                 self.setListElement(child_element, "LIST", list)
@@ -658,7 +680,7 @@ class ARXMLWriter(AbstractARXMLWriter):
 
     def setSwAxisIndividual(self, element: ET.Element, props: SwAxisIndividual):
         child_element = ET.SubElement(element, "SW-AXIS-INDIVIDUAL")
-        self.setARObjectAttributes(child_element, props)
+        self.writeARObjectAttributes(child_element, props)
         self.setChildElementOptionalRefType(child_element, "INPUT-VARIABLE-TYPE-REF", props.getInputVariableTypeRef())
         self.setChildElementOptionalRefType(child_element, "COMPU-METHOD-REF", props.getCompuMethodRef())
         self.setChildElementOptionalNumericalValue(child_element, "SW-MAX-AXIS-POINTS", props.getSwMaxAxisPoints()) 
@@ -667,7 +689,7 @@ class ARXMLWriter(AbstractARXMLWriter):
 
     def setSwAxisGrouped(self, element: ET.Element, props: SwAxisGrouped):
         child_element = ET.SubElement(element, "SW-AXIS-GROUPED")
-        self.setARObjectAttributes(child_element, props)
+        self.writeARObjectAttributes(child_element, props)
         self.setChildElementOptionalRefType(child_element, "SHARED-AXIS-TYPE-REF", props.sharedAxisTypeRef)
 
     def setSwCalprmAxis(self, element: ET.Element, axis: SwCalprmAxis):
@@ -699,20 +721,19 @@ class ARXMLWriter(AbstractARXMLWriter):
     def setSwDataDefProps(self, element: ET.Element, key: str, props: SwDataDefProps):
         if props is not None:
             child_element = ET.SubElement(element, key)
-            self.setARObjectAttributes(child_element, props)
+            self.writeARObjectAttributes(child_element, props)
             sw_data_def_props_variants_tag = ET.SubElement(child_element, "SW-DATA-DEF-PROPS-VARIANTS")
             conditional_tag = ET.SubElement(sw_data_def_props_variants_tag, "SW-DATA-DEF-PROPS-CONDITIONAL")
-            self.setARObjectAttributes(conditional_tag, props.conditional)
+            self.writeARObjectAttributes(conditional_tag, props.conditional)
             self.setAnnotations(conditional_tag, props.getAnnotations())
             self.setChildElementOptionalRefType(conditional_tag, "BASE-TYPE-REF", props.getBaseTypeRef())
             self.setChildElementOptionalRefType(conditional_tag, "COMPU-METHOD-REF", props.getCompuMethodRef())
-            
             self.setValueSpecification(conditional_tag, "INVALID-VALUE", props.getInvalidValue())
-            self.setChildElementOptionalRefType(conditional_tag, "IMPLEMENTATION-DATA-TYPE-REF", props.getImplementationDataTypeRef())
             self.setChildElementOptionalFloatValue(conditional_tag, "STEP-SIZE", props.getStepSize())
             self.setChildElementOptionalRefType(conditional_tag, "SW-ADDR-METHOD-REF", props.getSwAddrMethodRef())
             self.setChildElementOptionalLiteral(conditional_tag, "SW-CALIBRATION-ACCESS", props.getSwCalibrationAccess())
             self.setChildElementOptionalRefType(conditional_tag, "DATA-CONSTR-REF", props.getDataConstrRef())
+            self.setChildElementOptionalRefType(conditional_tag, "IMPLEMENTATION-DATA-TYPE-REF", props.getImplementationDataTypeRef())
             self.setSwCalprmAxisSet(conditional_tag, "SW-CALPRM-AXIS-SET", props.getSwCalprmAxisSet())
             self.setChildElementOptionalLiteral(conditional_tag, "SW-IMPL-POLICY", props.getSwImplPolicy())
             self.setChildElementOptionalNumericalValue(conditional_tag, "SW-INTENDED-RESOLUTION", props.getSwIntendedResolution())
@@ -728,7 +749,7 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.setApplicationDataType(element, data_type)
 
     def setAutosarDataType(self, element: ET.Element, data_type: AutosarDataType):
-        self.setARElement(element, data_type)
+        self.writeARElement(element, data_type)
         self.setSwDataDefProps(element, "SW-DATA-DEF-PROPS", data_type.getSwDataDefProps())
 
     def writeApplicationPrimitiveDataType(self, element: ET.Element, data_type: ApplicationPrimitiveDataType):
@@ -824,9 +845,10 @@ class ARXMLWriter(AbstractARXMLWriter):
             compu_scales_tag = ET.SubElement(element, "COMPU-SCALES")
             for compu_scale in compu_scales.getCompuScales():
                 child_element = ET.SubElement(compu_scales_tag, "COMPU-SCALE")
-                self.setARObjectAttributes(child_element, compu_scale)
+                self.writeARObjectAttributes(child_element, compu_scale)
                 self.setChildElementOptionalLiteral(child_element, "SHORT-LABEL", compu_scale.getShortLabel())
                 self.setChildElementOptionalLiteral(child_element, "SYMBOL", compu_scale.getSymbol())
+                self.setMultiLanguageOverviewParagraph(child_element, "DESC", compu_scale.getDesc())
                 self.setChildLimitElement(child_element, "LOWER-LIMIT", compu_scale.getLowerLimit())
                 self.setChildLimitElement(child_element, "UPPER-LIMIT", compu_scale.getUpperLimit())
                 self.writeCompuScaleContents(child_element, compu_scale)
@@ -834,13 +856,13 @@ class ARXMLWriter(AbstractARXMLWriter):
     def setCompuConst(self, element: ET.Element, key: str, compu_const: CompuConst):
         if compu_const is not None:
             child_element = ET.SubElement(element, key)
-            self.setARObjectAttributes(child_element, compu_const)
+            self.writeARObjectAttributes(child_element, compu_const)
             self.setCompuConstContent(child_element, compu_const.getCompuConstContentType())
 
     def setCompu(self, element: ET.Element, key: str, compu: Compu):
         if  compu is not None:
             child_element = ET.SubElement(element, key)
-            self.setARObjectAttributes(child_element, compu)
+            self.writeARObjectAttributes(child_element, compu)
             self.setCompuScales(child_element, compu.getCompuContent())
             self.setCompuConst(child_element, "COMPU-DEFAULT-VALUE", compu.getCompuDefaultValue())
 
@@ -860,7 +882,7 @@ class ARXMLWriter(AbstractARXMLWriter):
 
     def setRecordValueSpecification(self, element: ET.Element, spec: RecordValueSpecification):
         child_element = ET.SubElement(element, "RECORD-VALUE-SPECIFICATION")
-        self.setARObjectAttributes(child_element, spec)
+        self.writeARObjectAttributes(child_element, spec)
         self.setChildElementOptionalLiteral(child_element, "SHORT-LABEL", spec.getShortLabel())
         fields = spec.getFields()
         if len(fields) > 0:
@@ -889,7 +911,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     def setInternalConstrs(self, element: ET.Element, constrs: InternalConstrs):
         if constrs is not None:
             constrs_tag = ET.SubElement(element, "INTERNAL-CONSTRS")
-            self.setARObjectAttributes(constrs_tag, constrs)
+            self.writeARObjectAttributes(constrs_tag, constrs)
             if constrs.lower_limit is not None:
                 self.setChildLimitElement(constrs_tag, "LOWER-LIMIT", constrs.lower_limit)
             if constrs.upper_limit is not None:
@@ -898,7 +920,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     def setPhysConstrs(self, element: ET.Element, constrs: PhysConstrs):
         if constrs is not None:
             child_element = ET.SubElement(element, "PHYS-CONSTRS")
-            self.setARObjectAttributes(child_element, constrs)
+            self.writeARObjectAttributes(child_element, constrs)
             if constrs.lower_limit is not None:
                 self.setChildLimitElement(child_element, "LOWER-LIMIT", constrs.lower_limit)
             if constrs.upper_limit is not None:
@@ -911,7 +933,7 @@ class ARXMLWriter(AbstractARXMLWriter):
             rules_tag = ET.SubElement(element, "DATA-CONSTR-RULES")
             for rule in rules:
                 child_element = ET.SubElement(rules_tag, "DATA-CONSTR-RULE")
-                self.setARObjectAttributes(child_element, rule)
+                self.writeARObjectAttributes(child_element, rule)
                 self.setChildElementOptionalNumericalValue(child_element, "CONSTR-LEVEL", rule.constrLevel)
                 self.setPhysConstrs(child_element, rule.physConstrs)
                 self.setInternalConstrs(child_element, rule.internalConstrs)
@@ -932,7 +954,7 @@ class ARXMLWriter(AbstractARXMLWriter):
 
     def setRModeInAtomicSwcInstanceRef(self, element: ET.Element, key: str, iref: RModeInAtomicSwcInstanceRef):
         child_element = ET.SubElement(element, key)
-        self.setARObjectAttributes(child_element, iref)
+        self.writeARObjectAttributes(child_element, iref)
         self.setChildElementOptionalRefType(child_element, "BASE", iref.getBaseRef())
         self.setChildElementOptionalRefType(child_element, "CONTEXT-PORT-REF", iref.getContextPortRef())
         self.setChildElementOptionalRefType(child_element, "CONTEXT-MODE-DECLARATION-GROUP-PROTOTYPE-REF", iref.getContextModeDeclarationGroupPrototypeRef())
@@ -941,7 +963,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     def setPOperationInAtomicSwcInstanceRef(self, element: ET.Element, key: str, iref: POperationInAtomicSwcInstanceRef):
         if iref is not None:
             child_element = ET.SubElement(element, key)
-            self.setARObjectAttributes(child_element, iref)
+            self.writeARObjectAttributes(child_element, iref)
             self.setChildElementOptionalRefType(child_element, "CONTEXT-P-PORT-REF", iref.getContextPPortRef())
             self.setChildElementOptionalRefType(child_element, "TARGET-PROVIDED-OPERATION-REF", iref.getTargetProvidedOperationRef())
 
@@ -954,20 +976,20 @@ class ARXMLWriter(AbstractARXMLWriter):
                 self.setRModeInAtomicSwcInstanceRef(child_element, "DISABLED-MODE-IREF", iref)
         self.setChildElementOptionalRefType(element, "START-ON-EVENT-REF", event.startOnEventRef)
 
-    def setTimingEvent(self, element: ET.Element, event: TimingEvent):
+    def writeTimingEvent(self, element: ET.Element, event: TimingEvent):
         if event is not None:
             child_element = ET.SubElement(element, "TIMING-EVENT")
             self.setRTEEvent(child_element, event)
             self.setChildElementOptionalTimeValue(child_element, "OFFSET", event.getOffset())
             self.setChildElementOptionalTimeValue(child_element, "PERIOD", event.getPeriod())
 
-    def setOperationInvokedEvent(self, element: ET.Element, event: OperationInvokedEvent):
+    def writeOperationInvokedEvent(self, element: ET.Element, event: OperationInvokedEvent):
         if event is not None:
             child_element = ET.SubElement(element, "OPERATION-INVOKED-EVENT")
             self.setRTEEvent(child_element, event)
             self.setPOperationInAtomicSwcInstanceRef(child_element, "OPERATION-IREF", event.operationIRef)
 
-    def setSwcModeSwitchEvent(self, element: ET.Element, event: SwcModeSwitchEvent):
+    def writeSwcModeSwitchEvent(self, element: ET.Element, event: SwcModeSwitchEvent):
         if event is not None:
             child_element = ET.SubElement(element, "SWC-MODE-SWITCH-EVENT")
             self.setRTEEvent(child_element, event)
@@ -984,26 +1006,37 @@ class ARXMLWriter(AbstractARXMLWriter):
             self.setChildElementOptionalRefType(child_element, "CONTEXT-R-PORT-REF", iref.getContextRPortRef())
             self.setChildElementOptionalRefType(child_element, "TARGET-DATA-ELEMENT-REF", iref.getTargetDataElementRef())
 
-    def setDataReceivedEvent(self, element: ET.Element, event: DataReceivedEvent):
+    def writeDataReceivedEvent(self, element: ET.Element, event: DataReceivedEvent):
         if event is not None:
             child_element = ET.SubElement(element, "DATA-RECEIVED-EVENT")
             self.setRTEEvent(child_element, event)
             self.setRVariableInAtomicSwcInstanceRef(child_element, event.dataIRef)
 
-    def setInternalTriggerOccurredEvent(self, element: ET.Element, event: DataReceivedEvent):
+    def writeInternalTriggerOccurredEvent(self, element: ET.Element, event: DataReceivedEvent):
         pass
 
-    def setInitEvent(self, element: ET.Element, event: InitEvent):
+    def writeInitEvent(self, element: ET.Element, event: InitEvent):
         if event is not None:
             child_element = ET.SubElement(element, "INIT-EVENT")
             self.setRTEEvent(child_element, event)
 
-    def setAsynchronousServerCallReturnsEvent(self, element: ET.Element, event: InitEvent):
+    def writeAsynchronousServerCallReturnsEvent(self, element: ET.Element, event: InitEvent):
         if event is not None:
             child_element = ET.SubElement(element, "ASYNCHRONOUS-SERVER-CALL-RETURNS-EVENT")
             self.setRTEEvent(child_element, event)
             self.setChildElementOptionalRefType(child_element, "EVENT-SOURCE-REF", event.getActivationReasonRepresentationRef())
 
+    def writeModeSwitchedAckEvent(self, element: ET.Element, event: ModeSwitchedAckEvent):
+        if event is not None:
+            child_element = ET.SubElement(element, "MODE-SWITCHED-ACK-EVENT")
+            self.setRTEEvent(child_element, event)
+            self.setChildElementOptionalRefType(child_element, "EVENT-SOURCE-REF", event.getEventSourceRef())
+
+    def writeBackgroundEvent(self, element: ET.Element, event: BackgroundEvent):
+        if event is not None:
+            child_element = ET.SubElement(element, "BACKGROUND-EVENT")
+            self.setRTEEvent(child_element, event)
+
     def writeRTEEvents(self, element: ET.Element, parent: SwcInternalBehavior):
         events = parent.getRteEvents()
         if len(events) > 0:
@@ -1011,19 +1044,23 @@ class ARXMLWriter(AbstractARXMLWriter):
             
             for event in events:
                 if isinstance(event, TimingEvent):
-                    self.setTimingEvent(child_element, event)
+                    self.writeTimingEvent(child_element, event)
                 elif isinstance(event, OperationInvokedEvent):
-                    self.setOperationInvokedEvent(child_element, event)
+                    self.writeOperationInvokedEvent(child_element, event)
                 elif isinstance(event, SwcModeSwitchEvent):
-                    self.setSwcModeSwitchEvent(child_element, event)
+                    self.writeSwcModeSwitchEvent(child_element, event)
                 elif isinstance(event, DataReceivedEvent):
-                    self.setDataReceivedEvent(child_element, event)
+                    self.writeDataReceivedEvent(child_element, event)
                 elif isinstance(event, InternalTriggerOccurredEvent):
-                    self.setInternalTriggerOccurredEvent(child_element, event)
+                    self.writeInternalTriggerOccurredEvent(child_element, event)
                 elif isinstance(event, InitEvent):
-                    self.setInitEvent(child_element, event)
+                    self.writeInitEvent(child_element, event)
                 elif isinstance(event, AsynchronousServerCallReturnsEvent):
-                    self.setAsynchronousServerCallReturnsEvent(child_element, event)
+                    self.writeAsynchronousServerCallReturnsEvent(child_element, event)
+                elif isinstance(event, ModeSwitchedAckEvent):
+                    self.writeModeSwitchedAckEvent(child_element, event)
+                elif isinstance(event, BackgroundEvent):
+                    self.writeBackgroundEvent(child_element, event)
                 else:
                     self.notImplemented("Unsupported Event <%s>" % type(event))
                 
@@ -1051,7 +1088,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     def setAutosarVariableRef(self, element: ET.Element, key: str, ref: AutosarVariableRef):
         if ref is not None:
             child_element = ET.SubElement(element, key)
-            self.setARObjectAttributes(child_element, ref)
+            self.writeARObjectAttributes(child_element, ref)
             if ref.getAutosarVariableIRef() is not None:
                 child_element = ET.SubElement(child_element, "AUTOSAR-VARIABLE-IREF")
                 #self.setARObjectAttributes(child_element, ref)
@@ -1062,7 +1099,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     def setComponentInSystemInstanceRef(self, element: ET.Element, tag_name: str, ref: ComponentInSystemInstanceRef):
         if ref is not None:
             child_element = ET.SubElement(element, tag_name)
-            self.setARObjectAttributes(child_element, ref)
+            self.writeARObjectAttributes(child_element, ref)
             self.setChildElementOptionalRefType(child_element, "BASE-REF", ref.getBaseRef())
             self.setChildElementOptionalRefType(child_element, "CONTEXT-COMPOSITION-REF", ref.getContextCompositionRef())
             self.setChildElementOptionalRefType(child_element, "TARGET-COMPONENT-REF", ref.getTargetComponentRef())
@@ -1127,7 +1164,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     def setROperationInAtomicSwcInstanceRef(self, element: ET.Element, key: str, iref: ROperationInAtomicSwcInstanceRef):
         if iref is not None:
             child_element = ET.SubElement(element, key)
-            self.setARObjectAttributes(child_element, iref)
+            self.writeARObjectAttributes(child_element, iref)
             self.setChildElementOptionalRefType(child_element, "CONTEXT-R-PORT-REF", iref.getContextRPortRef())
             self.setChildElementOptionalRefType(child_element, "TARGET-REQUIRED-OPERATION-REF", iref.getTargetRequiredOperationRef())
         
@@ -1493,7 +1530,7 @@ class ARXMLWriter(AbstractARXMLWriter):
             include_data_type_sets_tag = ET.SubElement(element, "INCLUDED-DATA-TYPE-SETS")
             for set in sets:
                 child_element = ET.SubElement(include_data_type_sets_tag, "INCLUDED-DATA-TYPE-SET")
-                self.setARObjectAttributes(child_element, set)
+                self.writeARObjectAttributes(child_element, set)
                 type_refs = set.getDataTypeRefs()
                 if len(type_refs) > 0:
                     data_type_refs_tag = ET.SubElement(child_element, "DATA-TYPE-REFS")
@@ -1529,7 +1566,7 @@ class ARXMLWriter(AbstractARXMLWriter):
 
     def writeAtomicSwComponentType(self, element: ET.Element, sw_component: AtomicSwComponentType):
         self.writeSwComponentType(element, sw_component)
-        self.writeAtomicSwComponentTypeInternalBehaviors(element, sw_component.internal_behavior)
+        self.writeAtomicSwComponentTypeInternalBehaviors(element, sw_component.getInternalBehavior())
 
     def writeComplexDeviceDriverSwComponentType(self, element: ET.Element, sw_component: ComplexDeviceDriverSwComponentType):
         self.logger.debug("writeComplexDeviceDriverSwComponentType %s" % sw_component.getShortName())
@@ -1543,7 +1580,7 @@ class ARXMLWriter(AbstractARXMLWriter):
             for artifact_desc in artifact_descriptors:
                 artifact_desc_tag = ET.SubElement(artifact_descs_tag, "AUTOSAR-ENGINEERING-OBJECT")
                 self.logger.debug("writeArtifactDescriptor %s", artifact_desc.short_label)
-                self.setARObjectAttributes(artifact_desc_tag, artifact_desc)
+                self.writeARObjectAttributes(artifact_desc_tag, artifact_desc)
                 self.setChildElementOptionalLiteral(artifact_desc_tag, "SHORT-LABEL", artifact_desc.short_label)
                 self.setChildElementOptionalLiteral(artifact_desc_tag, "CATEGORY", artifact_desc.category)
 
@@ -1811,22 +1848,46 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.writeIdentifiable(element, event)
         self.setChildElementOptionalRefType(element, "STARTS-ON-EVENT-REF", event.startsOnEventRef)
 
-    def setBswScheduleEvent(self, element: ET.Element, event: BswScheduleEvent):
+    def writeBswScheduleEvent(self, element: ET.Element, event: BswScheduleEvent):
         self.setBswEvent(element, event)
 
-    def setBswTimingEvent(self, element: ET.Element, event: BswTimingEvent):
-        self.logger.debug("setBswTimingEvent %s" % event.getShortName())
+    def writeBswTimingEvent(self, element: ET.Element, event: BswTimingEvent):
+        self.logger.debug("Write BswTimingEvent <%s>" % event.getShortName())
         child_element = ET.SubElement(element, "BSW-TIMING-EVENT")
-        self.setBswScheduleEvent(child_element, event)
+        self.writeBswScheduleEvent(child_element, event)
         self.setChildElementOptionalTimeValue(child_element, "PERIOD", event.getPeriod())
 
+    def writeBswBackgroundEvent(self, element: ET.Element, event: BswBackgroundEvent):
+        self.logger.debug("Write BswTimingEvent <%s>" % event.getShortName())
+        child_element = ET.SubElement(element, "BSW-BACKGROUND-EVENT")
+        self.writeBswScheduleEvent(child_element, event)
+
+    def writeBswExternalTriggerOccurredEvent(self, element: ET.Element, event: BswExternalTriggerOccurredEvent):
+        self.logger.debug("Write BswExternalTriggerOccurredEvent %s" % event.getShortName())
+        child_element = ET.SubElement(element, "BSW-EXTERNAL-TRIGGER-OCCURRED-EVENT")
+        self.writeBswScheduleEvent(child_element, event)
+        self.setChildElementOptionalRefType(child_element, "TRIGGER-REF", event.getTriggerRef())
+
+    def writeBswDataReceivedEvent(self, element: ET.Element, event: BswDataReceivedEvent):
+        self.logger.debug("Write BswDataReceivedEvent %s" % event.getShortName())
+        # Read the Inherit BswScheduleEvent
+        child_element = ET.SubElement(element, "BSW-DATA-RECEIVED-EVENT")
+        self.writeBswScheduleEvent(child_element, event)
+        self.setChildElementOptionalRefType(child_element, "DATA-REF", event.getDataRef())
+
     def writeBswInternalBehaviorBswEvents(self, element: ET.Element, parent: BswInternalBehavior):
         events = parent.getBswEvents()
         if len(events) > 0:
             child_element = ET.SubElement(element, "EVENTS")
             for event in events:
                 if isinstance(event, BswTimingEvent):
-                    self.setBswTimingEvent(child_element, event)
+                    self.writeBswTimingEvent(child_element, event)
+                elif isinstance(event, BswBackgroundEvent):
+                    self.writeBswBackgroundEvent(child_element, event)
+                elif isinstance(event, BswExternalTriggerOccurredEvent):
+                    self.writeBswExternalTriggerOccurredEvent(child_element, event)
+                elif isinstance(event, BswDataReceivedEvent):
+                    self.writeBswDataReceivedEvent(child_element, event)
                 else:
                     self._raiseError("Unsupported BswModuleEntity <%s>" % type(event))
 
@@ -1941,7 +2002,7 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.setChildElementOptionalRefType(child_element, "SWC-BEHAVIOR-REF", mapping.getSwcBehaviorRef())
 
     def writeEngineeringObject(self, element: ET.Element, engineering_obj: EngineeringObject):
-        self.setARObjectAttributes(element, engineering_obj)
+        self.writeARObjectAttributes(element, engineering_obj)
         self.setChildElementOptionalLiteral(element, "SHORT-LABEL", engineering_obj.short_label)
         self.setChildElementOptionalLiteral(element, "CATEGORY", engineering_obj.category)
         
@@ -1989,12 +2050,25 @@ class ARXMLWriter(AbstractARXMLWriter):
                 self.writeImplementationDataTypeElements(child_element, type_element)
                 self.setSwDataDefProps(child_element, "SW-DATA-DEF-PROPS", type_element.getSwDataDefProps())
 
+    def writeImplementationProps(self, element: ET.Element, props: ImplementationProps):
+        self.writeReferrable(element, props)
+        self.setChildElementOptionalLiteral(element, "SYMBOL", props.getSymbol())
+
+    def writeSymbolProps(self, element: ET.Element, props: SymbolProps):
+        if props is not None:
+            child_element = ET.SubElement(element, "SYMBOL-PROPS")
+            self.writeImplementationProps(child_element, props)
+
+    def writeImplementationDataTypeSymbolProps(self, element: ET.Element, data_type: ImplementationDataType):
+        self.writeSymbolProps(element, data_type.getSymbolProps())
+
     def writeImplementationDataType(self, element: ET.Element, data_type: ImplementationDataType):
         self.logger.debug("writeImplementationDataType %s" % data_type.getShortName())
         child_element = ET.SubElement(element, "IMPLEMENTATION-DATA-TYPE")
         self.setAutosarDataType(child_element, data_type)
         self.setChildElementOptionalLiteral(child_element, "DYNAMIC-ARRAY-SIZE-PROFILE", data_type.getDynamicArraySizeProfile())
         self.writeImplementationDataTypeElements(child_element, data_type)
+        self.writeImplementationDataTypeSymbolProps(child_element, data_type)
         self.setChildElementOptionalLiteral(child_element, "TYPE-EMITTER", data_type.getTypeEmitter())
 
     def writeArgumentDataPrototypes(self, element: ET.Element, parent: ClientServerOperation):
@@ -2077,17 +2151,19 @@ class ARXMLWriter(AbstractARXMLWriter):
         child_element = ET.SubElement(element, "ECU-ABSTRACTION-SW-COMPONENT-TYPE")
         self.writeAtomicSwComponentType(child_element, sw_component)
 
-    def setApplicationArrayElement(self, element: ET.Element, prototype: ApplicationArrayElement):
-        if prototype is not None:
+    def setApplicationArrayElement(self, element: ET.Element, array_element: ApplicationArrayElement):
+        if array_element is not None:
             child_element = ET.SubElement(element, "ELEMENT")
-            self.setApplicationCompositeElementDataPrototype(child_element, prototype)
-            self.setChildElementOptionalLiteral(child_element, "ARRAY-SIZE-SEMANTICS", prototype.arraySizeSemantics)
-            self.setChildElementOptionalNumericalValue(child_element, "MAX-NUMBER-OF-ELEMENTS", prototype.maxNumberOfElements)
+            self.setApplicationCompositeElementDataPrototype(child_element, array_element)
+            self.setChildElementOptionalLiteral(child_element, "ARRAY-SIZE-HANDLING", array_element.getArraySizeHandling())
+            self.setChildElementOptionalLiteral(child_element, "ARRAY-SIZE-SEMANTICS", array_element.getArraySizeSemantics())
+            self.setChildElementOptionalNumericalValue(child_element, "MAX-NUMBER-OF-ELEMENTS", array_element.getMaxNumberOfElements())
 
     def writeApplicationArrayDataType(self, element: ET.Element, data_type: ApplicationArrayDataType):
         self.logger.debug("writeApplicationArrayDataType %s" % data_type.getShortName())
         child_element = ET.SubElement(element, "APPLICATION-ARRAY-DATA-TYPE")
         self.setApplicationCompositeDataType(child_element, data_type)
+        self.setChildElementOptionalLiteral(child_element, "DYNAMIC-ARRAY-SIZE-PROFILE", data_type.getDynamicArraySizeProfile())
         self.setApplicationArrayElement(child_element, data_type.element)
 
     def setSwRecordLayoutV(self, element: ET.Element, key: str, layout_v: SwRecordLayoutV):
@@ -2099,19 +2175,22 @@ class ARXMLWriter(AbstractARXMLWriter):
             self.setChildElementOptionalLiteral(child_element, "SW-RECORD-LAYOUT-V-PROP", layout_v.getSwRecordLayoutVProp())
             self.setChildElementOptionalLiteral(child_element, "SW-RECORD-LAYOUT-V-INDEX", layout_v.getSwRecordLayoutVIndex())
 
+    def writeSwRecordLayoutGroupSwRecordLayoutGroupContentType(self, element: ET.Element, group: SwRecordLayoutGroup):
+        content = group.getSwRecordLayoutGroupContentType()
+        self.setSwRecordLayoutGroup(element, "SW-RECORD-LAYOUT-GROUP", content.getSwRecordLayoutGroup())
+        self.setSwRecordLayoutV(element, "SW-RECORD-LAYOUT-V", content.getSwRecordLayoutV())
+
     def setSwRecordLayoutGroup(self, element: ET.Element, key: str, group: SwRecordLayoutGroup):
         if group is not None:
             child_element = ET.SubElement(element, key)
             self.setChildElementOptionalLiteral(child_element, "SHORT-LABEL", group.getShortLabel())
             self.setChildElementOptionalLiteral(child_element, "CATEGORY", group.getCategory())
+            #self.writeSwRecordLayoutGroupSwRecordLayoutGroupContentType(child_element, group)
             self.setChildElementOptionalLiteral(child_element, "SW-RECORD-LAYOUT-GROUP-AXIS", group.getSwRecordLayoutGroupAxis())
             self.setChildElementOptionalLiteral(child_element, "SW-RECORD-LAYOUT-GROUP-INDEX", group.getSwRecordLayoutGroupIndex())
             self.setChildElementOptionalLiteral(child_element, "SW-RECORD-LAYOUT-GROUP-FROM", group.getSwRecordLayoutGroupFrom())
             self.setChildElementOptionalLiteral(child_element, "SW-RECORD-LAYOUT-GROUP-TO", group.getSwRecordLayoutGroupTo())
             self.setChildElementOptionalIntegerValue(child_element, "SW-RECORD-LAYOUT-GROUP-STEP", group.getSwRecordLayoutGroupStep())
-            #self.setSwRecordLayoutV(child_element, "SW-RECORD-LAYOUT-V", group.swRecordLayoutGroupContentType.swRecordLayoutV)
-            #self.setSwRecordLayoutGroup(child_element, "SW-RECORD-LAYOUT-GROUP", group.swRecordLayoutGroupContentType.swRecordLayoutGroup)
-        return group
 
     def writeSwRecordLayout(self, element: ET.Element, layout: SwRecordLayout):
         self.logger.debug("writeSwRecordLayout %s" % layout.getShortName())
@@ -2147,7 +2226,7 @@ class ARXMLWriter(AbstractARXMLWriter):
             maps_tag = ET.SubElement(element, "DATA-TYPE-MAPS")
             for map in maps:
                 child_element = ET.SubElement(maps_tag, "DATA-TYPE-MAP")
-                self.setARObjectAttributes(child_element, map)
+                self.writeARObjectAttributes(child_element, map)
                 self.setChildElementOptionalRefType(child_element, "APPLICATION-DATA-TYPE-REF", map.getApplicationDataTypeRef())
                 self.setChildElementOptionalRefType(child_element, "IMPLEMENTATION-DATA-TYPE-REF", map.getImplementationDataTypeRef())
 
@@ -2157,7 +2236,7 @@ class ARXMLWriter(AbstractARXMLWriter):
             maps_tag = ET.SubElement(element, "MODE-REQUEST-TYPE-MAPS")
             for map in maps:
                 child_element = ET.SubElement(maps_tag, "MODE-REQUEST-TYPE-MAP")
-                self.setARObjectAttributes(child_element, map)
+                self.writeARObjectAttributes(child_element, map)
                 self.setChildElementOptionalRefType(child_element, "IMPLEMENTATION-DATA-TYPE-REF", map.getImplementationDataTypeRef())
                 self.setChildElementOptionalRefType(child_element, "MODE-GROUP-REF", map.getModeGroupRef())
 
@@ -2270,8 +2349,10 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.writeFrame(child_element, frame)
 
     def writeNmNode(self, element: ET.Element, nm_node: NmNode):
+        self.writeIdentifiable(element, nm_node)
         self.setChildElementOptionalRefType(element, "CONTROLLER-REF", nm_node.getControllerRef())
         self.setChildElementOptionalRefType(element, "NM-IF-ECU-REF", nm_node.getNmIfEcuRef())
+        self.setChildElementOptionalBooleanValue(element, "NM-PASSIVE-MODE-ENABLED", nm_node.getNmPassiveModeEnabled())
         self.setChildElementOptionalNumericalValue(element, "NM-NODE-ID", nm_node.getNmNodeId())
 
         refs = nm_node.getRxNmPduRefs()
@@ -2289,9 +2370,8 @@ class ARXMLWriter(AbstractARXMLWriter):
     def writeCanNmNode(self, element: ET.Element, nm_node: CanNmNode):
         self.logger.debug("write CanNmNode %s" % nm_node.getShortName())
         child_element = ET.SubElement(element, "CAN-NM-NODE")
-        self.writeIdentifiable(child_element, nm_node)
         self.writeNmNode(child_element, nm_node)
-
+        self.setChildElementOptionalBooleanValue(child_element, "NM-CAR-WAKE-UP-RX-ENABLED", nm_node.getNmCarWakeUpRxEnabled())
         self.setChildElementOptionalFloatValue(child_element, "NM-MSG-CYCLE-OFFSET", nm_node.getNmMsgCycleOffset())
         self.setChildElementOptionalFloatValue(child_element, "NM-MSG-REDUCED-TIME", nm_node.getNmMsgReducedTime())
         self.setChildElementRxIdentifierRange(child_element, "NM-RANGE-CONFIG", nm_node.getNmRangeConfig())
@@ -2299,8 +2379,8 @@ class ARXMLWriter(AbstractARXMLWriter):
     def writeUdpNmNode(self, element: ET.Element, nm_node: UdpNmNode):
         self.logger.debug("write UdpNmNode %s" % nm_node.getShortName())
         child_element = ET.SubElement(element, "UDP-NM-NODE")
-        self.writeIdentifiable(child_element, nm_node)
         self.writeNmNode(child_element, nm_node)
+        self.setChildElementOptionalTimeValue(child_element, "NM-MSG-CYCLE-OFFSET", nm_node.getNmMsgCycleOffset())
 
     def writeNmClusterNmNodes(self, element: ET.Element, parent: NmCluster):
         nodes = parent.getNmNodes()
@@ -2321,15 +2401,20 @@ class ARXMLWriter(AbstractARXMLWriter):
             refs_tag = ET.SubElement(child_element, "COUPLED-CLUSTER-REFS")
             for ref in refs:
                 self.setChildElementOptionalRefType(refs_tag, "COUPLED-CLUSTER-REF", ref)
-
         self.setChildElementOptionalBooleanValue(child_element, "NM-BUSLOAD-REDUCTION-ENABLED", coupling.getNmBusloadReductionEnabled())
         self.setChildElementOptionalBooleanValue(child_element, "NM-IMMEDIATE-RESTART-ENABLED", coupling.getNmImmediateRestartEnabled())
 
     def writeUdpNmClusterCoupling(self, element: ET.Element, coupling: UdpNmClusterCoupling):
         child_element = ET.SubElement(element, "UDP-NM-CLUSTER-COUPLING")
+        refs = coupling.getCoupledClusterRefs()
+        if len(refs) > 0:
+            refs_tag = ET.SubElement(child_element, "COUPLED-CLUSTER-REFS")
+            for ref in refs:
+                self.setChildElementOptionalRefType(refs_tag, "COUPLED-CLUSTER-REF", ref)
+        self.setChildElementOptionalBooleanValue(child_element, "NM-IMMEDIATE-RESTART-ENABLED", coupling.getNmImmediateRestartEnabled())
 
     def writeNmConfigNmClusterCouplings(self, element: ET.Element, config: NmConfig):
-        self.logger.debug("writeNmConfigNmClusterCouplings %s" % config.getShortName())
+        self.logger.debug("Write NmConfigNmClusterCouplings <%s>" % config.getShortName())
         couplings = config.getNmClusterCouplings()
         if len(couplings) > 0:
             child_element= ET.SubElement(element, "NM-CLUSTER-COUPLINGS")
@@ -2342,6 +2427,7 @@ class ARXMLWriter(AbstractARXMLWriter):
                     self.notImplemented("Unsupported Nm Cluster Coupling <%s>" % type(coupling))
 
     def writeNmCluster(self, element: ET.Element, cluster: NmCluster):
+        self.logger.debug("Write NmCluster <%s>" % cluster.getShortName())
         self.writeIdentifiable(element, cluster)
         self.setChildElementOptionalRefType(element, "COMMUNICATION-CLUSTER-REF", cluster.communicationClusterRef)
         self.setChildElementOptionalNumericalValue(element, "NM-CHANNEL-ID", cluster.nmChannelId)
@@ -2350,7 +2436,7 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.setChildElementOptionalBooleanValue(element, "NM-SYNCHRONIZING-NETWORK", cluster.getNmSynchronizingNetwork())
 
     def writeCanNmCluster(self, element: ET.Element, cluster: CanNmCluster):
-        self.logger.debug("WriteCanNmCluster %s" % cluster.getShortName())
+        self.logger.debug("Write CanNmCluster <%s>" % cluster.getShortName())
         child_element = ET.SubElement(element, "CAN-NM-CLUSTER")
         self.writeNmCluster(child_element, cluster)
 
@@ -2369,10 +2455,22 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.setChildElementOptionalNumericalValue(child_element, "NM-USER-DATA-LENGTH", cluster.getNmUserDataLength())
         self.setChildElementOptionalFloatValue(child_element, "NM-WAIT-BUS-SLEEP-TIME", cluster.getNmWaitBusSleepTime())
 
-    def writeUdpNmCluster(self, element: ET.Element, cluster: CanNmCluster):
-        self.logger.debug("Write UdpNmCluster %s" % cluster.getShortName())
+    def writeUdpNmCluster(self, element: ET.Element, cluster: UdpNmCluster):
+        self.logger.debug("Write UdpNmCluster <%s>" % cluster.getShortName())
         child_element = ET.SubElement(element, "UDP-NM-CLUSTER")
         self.writeNmCluster(child_element, cluster)
+        self.setChildElementOptionalIntegerValue(child_element, "NM-CBV-POSITION", cluster.getNmCbvPosition())
+        self.setChildElementOptionalBooleanValue(child_element, "NM-CHANNEL-ACTIVE", cluster.getNmChannelActive())
+        self.setChildElementOptionalTimeValue(child_element, "NM-IMMEDIATE-NM-CYCLE-TIME", cluster.getNmImmediateNmCycleTime())
+        self.setChildElementOptionalPositiveInteger(child_element, "NM-IMMEDIATE-NM-TRANSMISSIONS", cluster.getNmImmediateNmTransmissions())
+        self.setChildElementOptionalTimeValue(child_element, "NM-MESSAGE-TIMEOUT-TIME", cluster.getNmMessageTimeoutTime())
+        self.setChildElementOptionalTimeValue(child_element, "NM-MSG-CYCLE-TIME", cluster.getNmMsgCycleTime())
+        self.setChildElementOptionalTimeValue(child_element, "NM-NETWORK-TIMEOUT", cluster.getNmNetworkTimeout())
+        self.setChildElementOptionalIntegerValue(child_element, "NM-NID-POSITION", cluster.getNmNidPosition())
+        self.setChildElementOptionalTimeValue(child_element, "NM-REMOTE-SLEEP-INDICATION-TIME", cluster.getNmRemoteSleepIndicationTime())
+        self.setChildElementOptionalTimeValue(child_element, "NM-REPEAT-MESSAGE-TIME", cluster.getNmRepeatMessageTime())
+        self.setChildElementOptionalTimeValue(child_element, "NM-WAIT-BUS-SLEEP-TIME", cluster.getNmWaitBusSleepTime())
+        self.setChildElementOptionalRefType(child_element, "VLAN-REF", cluster.getVlanRef())
 
     def writeNmConfigNmClusters(self, element: ET.Element, parent: NmConfig):
         clusters = parent.getNmClusters()
@@ -2386,45 +2484,311 @@ class ARXMLWriter(AbstractARXMLWriter):
                 else:
                     self.notImplemented("Unsupported Nm Cluster <%s>" % type(cluster))
 
+    def writeUdpNmEcu(self, element: ET.Element, ecu: UdpNmEcu):
+        if ecu is not None:
+            child_element = ET.SubElement(element, "UDP-NM-ECU")
+            self.setChildElementOptionalBooleanValue(child_element, "NM-SYNCHRONIZATION-POINT-ENABLED", ecu.getNmSynchronizationPointEnabled())
+
+    def writeBusDependentNmEcus(self, element: ET.Element, nm_ecu: NmEcu):
+        dependent_nm_ecus = nm_ecu.getBusDependentNmEcus()
+        if len(dependent_nm_ecus) > 0:
+            child_element = ET.SubElement(element, "BUS-DEPENDENT-NM-ECUS")
+            for dependent_nm_ecu in dependent_nm_ecus:
+                if isinstance(dependent_nm_ecu, UdpNmEcu):
+                    self.writeUdpNmEcu(child_element, dependent_nm_ecu)
+                else:
+                    self.notImplemented("Unsupported BusDependentNmEcu <%s>" % type(dependent_nm_ecu))
+
+    def writeNmEcu(self, element: ET.Element, nm_ecu: NmEcu):
+        child_element = ET.SubElement(element, "NM-ECU")
+        self.writeIdentifiable(child_element, nm_ecu)
+        self.writeBusDependentNmEcus(child_element, nm_ecu)
+        self.setChildElementOptionalRefType(child_element, "ECU-INSTANCE-REF", nm_ecu.getEcuInstanceRef())
+        self.setChildElementOptionalBooleanValue(child_element, "NM-BUS-SYNCHRONIZATION-ENABLED", nm_ecu.getNmBusSynchronizationEnabled())
+        self.setChildElementOptionalBooleanValue(child_element, "NM-COM-CONTROL-ENABLED", nm_ecu.getNmComControlEnabled())
+        self.setChildElementOptionalBooleanValue(child_element, "NM-NODE-DETECTION-ENABLED", nm_ecu.getNmNodeDetectionEnabled())
+        self.setChildElementOptionalBooleanValue(child_element, "NM-NODE-ID-ENABLED", nm_ecu.getNmNodeIdEnabled())
+        self.setChildElementOptionalBooleanValue(child_element, "NM-PDU-RX-INDICATION-ENABLED", nm_ecu.getNmPduRxIndicationEnabled())
+        self.setChildElementOptionalBooleanValue(child_element, "NM-REMOTE-SLEEP-IND-ENABLED", nm_ecu.getNmRemoteSleepIndEnabled())
+        self.setChildElementOptionalBooleanValue(child_element, "NM-REPEAT-MSG-IND-ENABLED", nm_ecu.getNmRepeatMsgIndEnabled())
+        self.setChildElementOptionalBooleanValue(child_element, "NM-STATE-CHANGE-IND-ENABLED", nm_ecu.getNmStateChangeIndEnabled())
+        self.setChildElementOptionalBooleanValue(child_element, "NM-USER-DATA-ENABLED", nm_ecu.getNmUserDataEnabled())
+
+    def writeNmConfigNmIfEcus(self, element: ET.Element, nm_config: NmConfig):
+        ecus = nm_config.getNmIfEcus()
+        if len(ecus) > 0:
+            child_element = ET.SubElement(element, "NM-IF-ECUS")
+            for ecu in ecus:
+                if isinstance(ecu, NmEcu):
+                    self.writeNmEcu(child_element, ecu)
+                else:
+                    self.notImplemented("Unsupported NmIfEcus <%s>" % type(ecu))
+
     def writeNmConfig(self, element: ET.Element, config: NmConfig):
-        self.logger.debug("WriteNmConfig %s" % config.getShortName())
+        self.logger.debug("Write NmConfig <%s>" % config.getShortName())
         child_element = ET.SubElement(element, "NM-CONFIG")
         self.writeIdentifiable(child_element, config)
         self.writeNmConfigNmClusters(child_element, config)
         self.writeNmConfigNmClusterCouplings(child_element, config)
+        self.writeNmConfigNmIfEcus(child_element, config)
+
+    def writeISignalToIPduMapping(self, element: ET.Element, mapping: ISignalToIPduMapping):
+        if mapping is not None:
+            child_element = ET.SubElement(element, "I-SIGNAL-TO-I-PDU-MAPPING")
+            self.writeIdentifiable(child_element, mapping)
+            self.setChildElementOptionalRefType(child_element, "I-SIGNAL-REF", mapping.getISignalRef())
+            self.setChildElementOptionalLiteral(child_element, "PACKING-BYTE-ORDER", mapping.getPackingByteOrder())
+            self.setChildElementOptionalIntegerValue(child_element, "START-POSITION", mapping.getStartPosition())
+            self.setChildElementOptionalLiteral(child_element, "TRANSFER-PROPERTY", mapping.getTransferProperty())
+        
+    def writeNmPduISignalToIPduMappings(self, element: ET.Element, pdu: NmPdu):
+        mappings = pdu.getISignalToIPduMappings()
+        if len(mappings) > 0:
+            child_element = ET.SubElement(element, "I-SIGNAL-TO-I-PDU-MAPPINGS")
+            for mapping in mappings:
+                if isinstance(mapping, ISignalToIPduMapping):
+                    self.writeISignalToIPduMapping(child_element, mapping)
+                else:
+                    self.notImplemented("Unsupported ISignalToIPduMapping <%s>" % type(mapping))
 
     def writeNmPdu(self, element: ET.Element, pdu: NmPdu):
-        self.logger.debug("NmPdu %s" % pdu.getShortName())
+        self.logger.debug("Write NmPdu <%s>" % pdu.getShortName())
         child_element = ET.SubElement(element, "NM-PDU")
-        self.writeIdentifiable(child_element, pdu)
-        self.writeIPdu(child_element, pdu)
+        self.writePdu(child_element, pdu)
+        self.writeNmPduISignalToIPduMappings(child_element, pdu)
+        self.setChildElementOptionalIntegerValue(child_element, "UNUSED-BIT-PATTERN", pdu.getUnusedBitPattern())
 
     def writeNPdu(self, element: ET.Element, pdu: NPdu):
-        self.logger.debug("NPdu %s" % pdu.getShortName())
+        self.logger.debug("Write NPdu <%s>" % pdu.getShortName())
         child_element = ET.SubElement(element, "N-PDU")
-        self.writeIdentifiable(child_element, pdu)
-        self.writeIPdu(child_element, pdu)
-
-    def writeIPdu(self, element: ET.Element, pdu: IPdu):
-        self.setChildElementOptionalLiteral(element, "LENGTH", pdu.getLength())
+        self.writePdu(child_element, pdu)
 
     def writeDcmIPdu(self, element: ET.Element, pdu: DcmIPdu):
-        self.logger.debug("DcmIPdu %s" % pdu.getShortName())
+        self.logger.debug("Write DcmIPdu <%s>" % pdu.getShortName())
         child_element = ET.SubElement(element, "DCM-I-PDU")
-        self.writeIdentifiable(child_element, pdu)
         self.writeIPdu(child_element, pdu)
         self.setChildElementOptionalLiteral(child_element, "DIAG-PDU-TYPE", pdu.getDiagPduType())
 
-    def writeSecuredIPdu(self, element: ET.Element, pdu: DcmIPdu):
-        self.logger.debug("SecuredIPdu %s" % pdu.getShortName())
+    def setSecureCommunicationProps(self, element: ET.Element, key: str, props: SecureCommunicationProps):
+        if props is not None:
+            child_element = ET.SubElement(element, key)
+            self.setChildElementOptionalPositiveInteger(child_element, "AUTH-DATA-FRESHNESS-LENGTH", props.getAuthDataFreshnessLength())
+            self.setChildElementOptionalPositiveInteger(child_element, "AUTH-DATA-FRESHNESS-START-POSITION", props.getAuthDataFreshnessStartPosition())
+            self.setChildElementOptionalPositiveInteger(child_element, "AUTH-INFO-TX-LENGTH", props.getAuthInfoTxLength())
+            self.setChildElementOptionalPositiveInteger(child_element, "AUTHENTICATION-BUILD-ATTEMPTS", props.getAuthenticationBuildAttempts())
+            self.setChildElementOptionalPositiveInteger(child_element, "AUTHENTICATION-RETRIES", props.getAuthenticationRetries())
+            self.setChildElementOptionalPositiveInteger(child_element, "DATA-ID", props.getDataId())
+            self.setChildElementOptionalPositiveInteger(child_element, "FRESHNESS-VALUE-ID", props.getFreshnessValueId())
+            self.setChildElementOptionalPositiveInteger(child_element, "FRESHNESS-VALUE-LENGTH", props.getFreshnessValueLength())
+            self.setChildElementOptionalPositiveInteger(child_element, "FRESHNESS-VALUE-TX-LENGTH", props.getFreshnessValueTxLength())
+
+    def writeSecuredIPdu(self, element: ET.Element, i_pdu: SecuredIPdu):
+        self.logger.debug("Write SecuredIPdu <%s>" % i_pdu.getShortName())
         child_element = ET.SubElement(element, "SECURED-I-PDU")
-        self.writeIdentifiable(child_element, pdu)
-        self.writeIPdu(child_element, pdu)
+        self.writeIPdu(child_element, i_pdu)
+        self.setChildElementOptionalRefType(child_element, "AUTHENTICATION-PROPS-REF", i_pdu.getAuthenticationPropsRef())
+        self.setChildElementOptionalRefType(child_element, "FRESHNESS-PROPS-REF", i_pdu.getFreshnessPropsRef())
+        self.setChildElementOptionalRefType(child_element, "PAYLOAD-REF", i_pdu.getPayloadRef())
+        self.setSecureCommunicationProps(child_element, "SECURE-COMMUNICATION-PROPS", i_pdu.getSecureCommunicationProps())
+        self.setChildElementOptionalBooleanValue(child_element, "USE-AS-CRYPTOGRAPHIC-I-PDU", i_pdu.getUseAsCryptographicIPdu())
+
+    def writeTpConfig(self, element: ET.Element, config: TpConfig):
+        self.writeIdentifiable(element, config)
+        self.setChildElementOptionalRefType(element, "COMMUNICATION-CLUSTER-REF", config.getCommunicationClusterRef())
+
+    def writeCanTpAddress(self, element: ET.Element, address: CanTpAddress):
+        if address is not None:
+            child_element = ET.SubElement(element, "CAN-TP-ADDRESS")
+            self.writeIdentifiable(child_element, address)
+            self.setChildElementOptionalIntegerValue(child_element, "TP-ADDRESS", address.getTpAddress())
+            self.setChildElementOptionalIntegerValue(child_element, "TP-ADDRESS-EXTENSION-VALUE", address.getTpAddressExtensionValue())
+
+    def writeCanTpConfigTpAddresses(self, element: ET.Element, config: CanTpConfig):
+        addresses = config.getTpAddresses()
+        if len(addresses) > 0:
+            child_element = ET.SubElement(element, "TP-ADDRESSS")
+            for address in addresses:
+                if isinstance(address, CanTpAddress):
+                    self.writeCanTpAddress(child_element, address)
+                else:
+                    self.notImplemented("Unsupported TpAddress <%s>" % type(address))
+
+    def writeCanTpChannel(self, element: ET.Element, channel: CanTpChannel):
+        if channel is not None:
+            child_element = ET.SubElement(element, "CAN-TP-CHANNEL")
+            self.writeIdentifiable(child_element, channel)
+            self.setChildElementOptionalPositiveInteger(child_element, "CHANNEL-ID", channel.getChannelId())
+            self.setChildElementOptionalLiteral(child_element, "CHANNEL-MODE", channel.getChannelMode())
+
+    def writeCanTpConfigTpChannels(self, element: ET.Element, config: CanTpConfig):
+        channels = config.getTpChannels()
+        if len(channels) > 0:
+            child_element = ET.SubElement(element, "TP-CHANNELS")
+            for channel in channels:
+                if isinstance(channel, CanTpChannel):
+                    self.writeCanTpChannel(child_element, channel)
+                else:
+                    self.notImplemented("Unsupported TpChannel <%s>" % type(channel))
+
+    def writeTpConnection(self, element: ET.Element, connection: TpConnection):
+        self.writeARObjectAttributes(element, connection)
+        ident = connection.getIdent()
+        if ident is not None:
+            child_element = ET.SubElement(element, "IDENT")
+            self.writeReferrable(child_element, ident)
+
+    def writeTpConnectionReceiverRefs(self, element: ET.Element, connection: CanTpConnection):
+        refs = connection.getReceiverRefs()
+        if len(refs) > 0:
+            child_element = ET.SubElement(element, "RECEIVER-REFS")
+            for ref in refs:
+                self.setChildElementOptionalRefType(child_element, "RECEIVER-REF", ref)
+
+    def writeCanTpConnection(self, element: ET.Element, connection: CanTpConnection):
+        if connection is not None:
+            child_element = ET.SubElement(element, "CAN-TP-CONNECTION")
+            self.writeTpConnection(child_element, connection)
+            self.setChildElementOptionalLiteral(child_element, "ADDRESSING-FORMAT", connection.getAddressingFormat())
+            self.setChildElementOptionalRefType(child_element, "CAN-TP-CHANNEL-REF", connection.getCanTpChannelRef())
+            self.setChildElementOptionalBooleanValue(child_element, "CANCELLATION", connection.getCancellation())
+            self.setChildElementOptionalRefType(child_element, "DATA-PDU-REF", connection.getDataPduRef())
+            self.setChildElementOptionalRefType(child_element, "FLOW-CONTROL-PDU-REF", connection.getFlowControlPduRef())
+            self.setChildElementOptionalIntegerValue(child_element, "MAX-BLOCK-SIZE", connection.getMaxBlockSize())
+            self.setChildElementOptionalRefType(child_element, "MULTICAST-REF", connection.getMulticastRef())
+            self.setChildElementOptionalBooleanValue(child_element, "PADDING-ACTIVATION", connection.getPaddingActivation())
+            self.writeTpConnectionReceiverRefs(child_element, connection)
+            self.setChildElementOptionalLiteral(child_element, "TA-TYPE", connection.getTaType())
+            self.setChildElementOptionalTimeValue(child_element, "TIMEOUT-BR", connection.getTimeoutBr())
+            self.setChildElementOptionalTimeValue(child_element, "TIMEOUT-BS", connection.getTimeoutBs())
+            self.setChildElementOptionalTimeValue(child_element, "TIMEOUT-CR", connection.getTimeoutCr())
+            self.setChildElementOptionalTimeValue(child_element, "TIMEOUT-CS", connection.getTimeoutCs())
+            self.setChildElementOptionalRefType(child_element, "TP-SDU-REF", connection.getTpSduRef())
+            self.setChildElementOptionalRefType(child_element, "TRANSMITTER-REF", connection.getTransmitterRef())
+
+    def writeCanTpConfigTpConnections(self, element: ET.Element, config: CanTpConfig):
+        connections = config.getTpConnections()
+        if len(connections) > 0:
+            child_element = ET.SubElement(element, "TP-CONNECTIONS")
+            for connection in connections:
+                if isinstance(connection, CanTpConnection):
+                    self.writeCanTpConnection(child_element, connection)
+                else:
+                    self.notImplemented("Unsupported TpConnection <%s>" % type(connection))
+
+    def writeCanTpEcu(self, element: ET.Element, tp_ecu: CanTpEcu):
+        if tp_ecu is not None:
+            child_element = ET.SubElement(element, "CAN-TP-ECU")
+            self.setChildElementOptionalTimeValue(child_element, "CYCLE-TIME-MAIN-FUNCTION", tp_ecu.getCycleTimeMainFunction())
+            self.setChildElementOptionalRefType(child_element, "ECU-INSTANCE-REF", tp_ecu.getEcuInstanceRef())
+
+    def writeCanTpConfigTpEcus(self, element: ET.Element, config: CanTpConfig):
+        tp_ecus = config.getTpEcus()
+        if len(tp_ecus) > 0:
+            child_element = ET.SubElement(element, "TP-ECUS")
+            for tp_ecu in tp_ecus:
+                if isinstance(tp_ecu, CanTpEcu):
+                    self.writeCanTpEcu(child_element, tp_ecu)
+                else:
+                    self.notImplemented("Unsupported TpEcu <%s>" % type(tp_ecu))
+
+    def writeCanTpNode(self, element: ET.Element, tp_node: CanTpNode):
+        if tp_node is not None:
+            child_element = ET.SubElement(element, "CAN-TP-NODE")
+            self.writeIdentifiable(child_element, tp_node)
+            self.setChildElementOptionalRefType(child_element, "CONNECTOR-REF", tp_node.getConnectorRef())
+            self.setChildElementOptionalIntegerValue(child_element, "MAX-FC-WAIT", tp_node.getMaxFcWait())
+            self.setChildElementOptionalTimeValue(child_element, "ST-MIN", tp_node.getStMin())
+            self.setChildElementOptionalTimeValue(child_element, "TIMEOUT-AR", tp_node.getTimeoutAr())
+            self.setChildElementOptionalTimeValue(child_element, "TIMEOUT-AS", tp_node.getTimeoutAs())
+            self.setChildElementOptionalRefType(child_element, "TP-ADDRESS-REF", tp_node.getTpAddressRef())
+
+    def writeCanTpConfigTpNodes(self, element: ET.Element, config: CanTpConfig):
+        tp_nodes = config.getTpNodes()
+        if len(tp_nodes) > 0:
+            child_element = ET.SubElement(element, "TP-NODES")
+            for tp_node in tp_nodes:
+                if isinstance(tp_node, CanTpNode):
+                    self.writeCanTpNode(child_element, tp_node)
+                else:
+                    self.notImplemented("Unsupported TpNode <%s>" % type(tp_node))
+
 
     def writeCanTpConfig(self, element: ET.Element, config: CanTpConfig):
-        self.logger.debug("CanTpConfig %s" % config.getShortName())
+        self.logger.debug("Write CanTpConfig <%s>" % config.getShortName())
         child_element = ET.SubElement(element, "CAN-TP-CONFIG")
-        self.writeIdentifiable(child_element, config)
+        self.writeTpConfig(child_element, config)
+        self.writeCanTpConfigTpAddresses(child_element, config)
+        self.writeCanTpConfigTpChannels(child_element, config)
+        self.writeCanTpConfigTpConnections(child_element, config)
+        self.writeCanTpConfigTpEcus(child_element, config)
+        self.writeCanTpConfigTpNodes(child_element, config)
+
+    def writeTpAddress(self, element: ET.Element, address: TpAddress):
+        if address is not None:
+            child_element = ET.SubElement(element, "TP-ADDRESS")
+            self.writeIdentifiable(child_element, address)
+            self.setChildElementOptionalIntegerValue(child_element, "TP-ADDRESS", address.getTpAddress())
+
+    def writeLinTpConfigTpAddresses(self, element: ET.Element, config: CanTpConfig):
+        addresses = config.getTpAddresses()
+        if len(addresses) > 0:
+            child_element = ET.SubElement(element, "TP-ADDRESSS")
+            for address in addresses:
+                if isinstance(address, TpAddress):
+                    self.writeTpAddress(child_element, address)
+                else:
+                    self.notImplemented("Unsupported TpAddress <%s>" % type(address))
+
+    def writeLinTpConnection(self, element: ET.Element, connection: LinTpConnection):
+        if connection is not None:
+            child_element = ET.SubElement(element, "LIN-TP-CONNECTION")
+            self.writeTpConnection(child_element, connection)
+            self.setChildElementOptionalRefType(child_element, "DATA-PDU-REF", connection.getDataPduRef())
+            self.setChildElementOptionalRefType(child_element, "FLOW-CONTROL-REF", connection.getFlowControlRef())
+            self.setChildElementOptionalRefType(child_element, "LIN-TP-N-SDU-REF", connection.getLinTpNSduRef())
+            self.writeTpConnectionReceiverRefs(child_element, connection)
+            self.setChildElementOptionalTimeValue(child_element, "TIMEOUT-AS", connection.getTimeoutAs())
+            self.setChildElementOptionalTimeValue(child_element, "TIMEOUT-CR", connection.getTimeoutCr())
+            self.setChildElementOptionalTimeValue(child_element, "TIMEOUT-CS", connection.getTimeoutCs())
+            self.setChildElementOptionalRefType(child_element, "TRANSMITTER-REF", connection.getTransmitterRef())
+
+    def writeLinTpConfigTpConnections(self, element: ET.Element, config: LinTpConfig):
+        connections = config.getTpConnections()
+        if len(connections) > 0:
+            child_element = ET.SubElement(element, "TP-CONNECTIONS")
+            for connection in connections:
+                if isinstance(connection, LinTpConnection):
+                    self.writeLinTpConnection(child_element, connection)
+                else:
+                    self.notImplemented("Unsupported TpConnection <%s>" % type(connection))
+
+    def writeLinTpNode(self, element: ET.Element, tp_node: LinTpNode):
+        if tp_node is not None:
+            child_element = ET.SubElement(element, "LIN-TP-NODE")
+            self.writeIdentifiable(child_element, tp_node)
+            self.setChildElementOptionalRefType(child_element, "CONNECTOR-REF", tp_node.getConnectorRef())
+            self.setChildElementOptionalBooleanValue(element, "DROP-NOT-REQUESTED-NAD", tp_node.getDropNotRequestedNad())
+            self.setChildElementOptionalTimeValue(child_element, "P-2-MAX", tp_node.getP2Max())
+            self.setChildElementOptionalTimeValue(child_element, "P-2-TIMING", tp_node.getP2Timing())
+            self.setChildElementOptionalRefType(child_element, "TP-ADDRESS-REF", tp_node.getTpAddressRef())
+
+    def writeLinTpConfigTpNodes(self, element: ET.Element, config: LinTpConfig):
+        tp_nodes = config.getTpNodes()
+        if len(tp_nodes) > 0:
+            child_element = ET.SubElement(element, "TP-NODES")
+            for tp_node in tp_nodes:
+                if isinstance(tp_node, LinTpNode):
+                    self.writeLinTpNode(child_element, tp_node)
+                else:
+                    self.notImplemented("Unsupported TpNode <%s>" % type(tp_node))
+
+    def writeLinTpConfig(self, element: ET.Element, config: LinTpConfig):
+        self.logger.debug("Write LinTpConfig <%s>" % config.getShortName())
+        child_element = ET.SubElement(element, "LIN-TP-CONFIG")
+        self.writeTpConfig(child_element, config)
+        self.writeLinTpConfigTpAddresses(child_element, config)
+        self.writeLinTpConfigTpConnections(child_element, config)
+        self.writeLinTpConfigTpNodes(child_element, config)
 
     def writeFrameTriggering(self, element: ET.Element, triggering: FrameTriggering):
         ref_list = triggering.getFramePortRefs()
@@ -2666,7 +3030,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     def writeSocketConnectionBundle(self, element: ET.Element, bundle: SocketConnectionBundle):
         if bundle is not None:
             child_element = ET.SubElement(element, "SOCKET-CONNECTION-BUNDLE")
-            self.setReferable(child_element, bundle)
+            self.writeReferrable(child_element, bundle)
             self.writeSocketConnectionBundleConnections(child_element, bundle)
             self.setChildElementOptionalRefType(child_element, "SERVER-PORT-REF", bundle.getServerPortRef())
 
@@ -2750,12 +3114,13 @@ class ARXMLWriter(AbstractARXMLWriter):
             self.setChildElementOptionalPositiveInteger(child_element, "TTL", config.getTtl())
     
     def writeConsumedEventGroup(self, element: ET.Element, group: ConsumedEventGroup):
-        child_element = ET.SubElement(element, "CONSUMED-EVENT-GROUP")
-        self.writeIdentifiable(child_element, group)
-        self.setChildElementOptionalRefType(child_element, "APPLICATION-ENDPOINT-REF", group.getApplicationEndpointRef())
-        self.setChildElementOptionalPositiveInteger(child_element, "EVENT-GROUP-IDENTIFIER", group.getEventGroupIdentifier())
-        self.writeConsumedEventGroupRoutingGroupRefs(child_element, group)
-        self.setSdClientConfig(child_element, "SD-CLIENT-CONFIG", group.getSdClientConfig())
+        if group is not None:
+            child_element = ET.SubElement(element, "CONSUMED-EVENT-GROUP")
+            self.writeIdentifiable(child_element, group)
+            self.setChildElementOptionalRefType(child_element, "APPLICATION-ENDPOINT-REF", group.getApplicationEndpointRef())
+            self.setChildElementOptionalPositiveInteger(child_element, "EVENT-GROUP-IDENTIFIER", group.getEventGroupIdentifier())
+            self.writeConsumedEventGroupRoutingGroupRefs(child_element, group)
+            self.setSdClientConfig(child_element, "SD-CLIENT-CONFIG", group.getSdClientConfig())
     
     def writeConsumedServiceInstanceConsumedEventGroups(self, element: ET.Element, instance: ConsumedServiceInstance):
         groups = instance.getConsumedEventGroups()
@@ -2768,11 +3133,12 @@ class ARXMLWriter(AbstractARXMLWriter):
                     self.notImplemented("Unsupported ConsumedEventGroups <%s>" % type(group)) 
     
     def writeConsumedServiceInstance(self, element: ET.Element, instance: ConsumedServiceInstance):
-        child_element = ET.SubElement(element, "CONSUMED-SERVICE-INSTANCE")
-        self.writeIdentifiable(child_element, instance)
-        self.writeConsumedServiceInstanceConsumedEventGroups(child_element, instance)
-        self.setChildElementOptionalRefType(child_element, "PROVIDED-SERVICE-INSTANCE-REF", instance.getProvidedServiceInstanceRef())
-        self.setSdClientConfig(child_element, "SD-CLIENT-CONFIG", instance.getSdClientConfig())
+        if instance is not None:
+            child_element = ET.SubElement(element, "CONSUMED-SERVICE-INSTANCE")
+            self.writeIdentifiable(child_element, instance)
+            self.writeConsumedServiceInstanceConsumedEventGroups(child_element, instance)
+            self.setChildElementOptionalRefType(child_element, "PROVIDED-SERVICE-INSTANCE-REF", instance.getProvidedServiceInstanceRef())
+            self.setSdClientConfig(child_element, "SD-CLIENT-CONFIG", instance.getSdClientConfig())
     
     def writeSocketAddressApplicationEndpointConsumedServiceInstances(self, element: ET.Element, end_point: ApplicationEndpoint):
         instances = end_point.getConsumedServiceInstances()
@@ -2784,6 +3150,74 @@ class ARXMLWriter(AbstractARXMLWriter):
                 else:   
                     self.notImplemented("Unsupported ConsumedServiceInstances <%s>" % type(instance))
 
+    def setInitialSdDelayConfig(self, element: ET.Element, key: str, config: InitialSdDelayConfig):
+        if config is not None:
+            child_element = ET.SubElement(element, key)
+            self.setChildElementOptionalTimeValue(child_element, "INITIAL-DELAY-MAX-VALUE", config.getInitialDelayMaxValue())
+            self.setChildElementOptionalTimeValue(child_element, "INITIAL-DELAY-MIN-VALUE", config.getInitialDelayMinValue())
+            self.setChildElementOptionalTimeValue(child_element, "INITIAL-REPETITIONS-BASE-DELAY", config.getInitialRepetitionsBaseDelay())
+            self.setChildElementOptionalPositiveInteger(child_element, "INITIAL-REPETITIONS-MAX", config.getInitialRepetitionsMax())
+
+    def setSdServerConfig(self, element: ET.Element, key: str, config: SdServerConfig):
+        if config is not None:
+            child_element = ET.SubElement(element, key)
+            self.setInitialSdDelayConfig(child_element, "INITIAL-OFFER-BEHAVIOR", config.getInitialOfferBehavior())
+            self.setChildElementOptionalTimeValue(child_element, "OFFER-CYCLIC-DELAY", config.getOfferCyclicDelay())
+            self.setRequestResponseDelay(child_element, "REQUEST-RESPONSE-DELAY", config.getRequestResponseDelay())
+            self.setChildElementOptionalPositiveInteger(child_element, "SERVER-SERVICE-MAJOR-VERSION", config.getServerServiceMajorVersion())
+            self.setChildElementOptionalPositiveInteger(child_element, "SERVER-SERVICE-MINOR-VERSION", config.getServerServiceMinorVersion())
+            self.setChildElementOptionalPositiveInteger(child_element, "TTL", config.getTtl())
+
+    def writeEventHandler(self, element: ET.Element, handler: EventHandler):
+        if handler is not None:
+            child_element = ET.SubElement(element, "EVENT-HANDLER")
+            self.writeIdentifiable(child_element, handler)
+            self.setChildElementOptionalRefType(child_element, "APPLICATION-ENDPOINT-REF", handler.getApplicationEndpointRef())
+            
+            refs = handler.getConsumedEventGroupRefs()
+            if len(refs) > 0:
+                refs_tag = ET.SubElement(child_element, "CONSUMED-EVENT-GROUP-REFS")
+                for ref in refs:
+                    self.setChildElementOptionalRefType(refs_tag, "CONSUMED-EVENT-GROUP-REF", ref)
+
+            self.setChildElementOptionalPositiveInteger(child_element, "MULTICAST-THRESHOLD", handler.getMulticastThreshold())
+
+            refs = handler.getRoutingGroupRefs()
+            if len(refs) > 0:
+                refs_tag = ET.SubElement(child_element, "ROUTING-GROUP-REFS")
+                for ref in refs:
+                    self.setChildElementOptionalRefType(refs_tag, "ROUTING-GROUP-REF", ref)
+            self.setSdServerConfig(child_element, "SD-SERVER-CONFIG", handler.getSdServerConfig())
+
+    def writeProvidedServiceInstanceEventHandlers(self, element: ET.Element, instance: ProvidedServiceInstance):
+        handlers = instance.getEventHandlers()
+        if len(handlers) > 0:
+            child_element = ET.SubElement(element, "EVENT-HANDLERS")
+            for handler in handlers:
+                if isinstance(handler, EventHandler):
+                    self.writeEventHandler(child_element, handler)
+                else:
+                    self.notImplemented("Unsupported Event Handler <%s>" % type(handler))
+
+    def writeProvidedServiceInstance(self, element: ET.Element, instance: ProvidedServiceInstance):
+        if instance is not None:
+            child_element = ET.SubElement(element, "PROVIDED-SERVICE-INSTANCE")
+            self.writeIdentifiable(child_element, instance)
+            self.writeProvidedServiceInstanceEventHandlers(child_element, instance)
+            self.setChildElementOptionalPositiveInteger(child_element, "INSTANCE-IDENTIFIER", instance.getInstanceIdentifier())
+            self.setSdServerConfig(child_element, "SD-SERVER-CONFIG", instance.getSdServerConfig())
+            self.setChildElementOptionalPositiveInteger(child_element, "SERVICE-IDENTIFIER", instance.getServiceIdentifier())
+
+    def writeSocketAddressApplicationEndpointProvidedServiceInstance(self, element: ET.Element, end_point: ApplicationEndpoint):
+        instances = end_point.getProvidedServiceInstances()
+        if len(instances) > 0:
+            child_element = ET.SubElement(element, "PROVIDED-SERVICE-INSTANCES")
+            for instance in instances:
+                if isinstance(instance, ProvidedServiceInstance):
+                    self.writeProvidedServiceInstance(child_element, instance)
+                else:
+                    self.notImplemented("Unsupported ConsumedServiceInstances <%s>" % type(instance))
+
     def writeSocketAddressApplicationEndpoint(self, element: ET.Element, address: SocketAddress):
         end_point = address.getApplicationEndpoint()
         if end_point is not None:
@@ -2792,6 +3226,7 @@ class ARXMLWriter(AbstractARXMLWriter):
             self.writeSocketAddressApplicationEndpointConsumedServiceInstances(child_element, end_point)
             self.setChildElementOptionalRefType(child_element, "NETWORK-ENDPOINT-REF", end_point.getNetworkEndpointRef())
             self.setChildElementOptionalPositiveInteger(child_element, "PRIORITY", end_point.getPriority())
+            self.writeSocketAddressApplicationEndpointProvidedServiceInstance(child_element, end_point)
             self.writeTransportProtocolConfiguration(child_element, end_point.getTpConfiguration())
 
     def writeSocketAddressMulticastConnectorRefs(self, element: ET.Element, address: SocketAddress):
@@ -2891,14 +3326,31 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.writeCommunicationCluster(child_element, cluster)
         self.writeAbstractCanCluster(child_element, cluster)
 
+    def writeMacMulticastGroup(self, element: ET.Element, group: MacMulticastGroup):
+        if group is not None:
+            child_element = ET.SubElement(element, "MAC-MULTICAST-GROUP")
+            self.writeIdentifiable(child_element, group)
+            self.setChildElementOptionalLiteral(child_element, "MAC-MULTICAST-ADDRESS", group.getMacMulticastAddress())
+
+    def writeEthernetClusterMacMulticastGroups(self, element: ET.Element, cluster: EthernetCluster):
+        groups = cluster.getMacMulticastGroups()
+        if len(groups) > 0:
+            child_element = ET.SubElement(element, "MAC-MULTICAST-GROUPS")
+            for group in groups:
+                if isinstance(group, MacMulticastGroup):
+                    self.writeMacMulticastGroup(child_element, group)
+                else:
+                    self.notImplemented("Unsupported assigned data type <%s>" % type(group))
+
     def writeEthernetCluster(self, element: ET.Element, cluster: EthernetCluster):
         self.logger.debug("Set EthernetCluster %s" % cluster.getShortName())
         child_element = ET.SubElement(element, "ETHERNET-CLUSTER")
-        self.setARElement(child_element, cluster)
+        self.writeARElement(child_element, cluster)
 
         child_element = ET.SubElement(child_element, "ETHERNET-CLUSTER-VARIANTS")
         child_element = ET.SubElement(child_element, "ETHERNET-CLUSTER-CONDITIONAL")
         self.writeCommunicationCluster(child_element, cluster)
+        self.writeEthernetClusterMacMulticastGroups(child_element, cluster)
 
     def writeCanFrame(self, element: ET.Element, frame: CanFrame):
         self.logger.debug("Write CanFrame %s" % frame.getShortName())
@@ -2916,10 +3368,14 @@ class ARXMLWriter(AbstractARXMLWriter):
     def writeIPduPort(self, element: ET.Element, port: IPduPort):
         child_element = ET.SubElement(element, "I-PDU-PORT")
         self.writeCommConnectorPort(child_element, port)
+        self.setChildElementOptionalPositiveInteger(child_element, "KEY-ID", port.getKeyId())
+        self.setChildElementOptionalBooleanValue(child_element, "RX-SECURITY-VERIFICATION", port.getRxSecurityVerification())
+        self.setChildElementOptionalBooleanValue(child_element, "USE-AUTH-DATA-FRESHNESS", port.getUseAuthDataFreshness())
 
     def writeISignalPort(self, element: ET.Element, port: ISignalPort):
         child_element = ET.SubElement(element, "I-SIGNAL-PORT")
         self.writeCommConnectorPort(child_element, port)
+        self.setChildElementOptionalTimeValue(child_element, "TIMEOUT", port.getTimeout())
 
     def writeCommunicationConnectorEcuCommPortInstances(self, element: ET.Element, connector: CommunicationConnector):
         self.logger.debug("write EcuCommPortInstances of CommunicationConnector %s" % connector.getShortName())
@@ -2934,17 +3390,156 @@ class ARXMLWriter(AbstractARXMLWriter):
                 elif isinstance(port, ISignalPort):
                     self.writeISignalPort(instances_tag, port)
                 else:
-                    self._raiseError("Unsupported CommConnectorPort <%s>" % type(port))      
+                    self._raiseError("Unsupported CommConnectorPort <%s>" % type(port))  
+
+    def writeCommunicationController(self, element: ET.Element, controller: CommunicationController):
+        self.setChildElementOptionalBooleanValue(element, "WAKE-UP-BY-CONTROLLER-SUPPORTED", controller.getWakeUpByControllerSupported())
+
+    def setCanControllerFdConfiguration(self, element: ET.Element, key: str, configuration: CanControllerFdConfiguration):
+        if configuration is not None:
+            child_element = ET.SubElement(element, key)
+            #TODO: need to implemented
+    
+    def setCanControllerFdConfigurationRequirements(self, element: ET.Element, key: str, requirements: CanControllerFdConfigurationRequirements):
+        if requirements is not None:
+            child_element = ET.SubElement(element, key)
+            self.setChildElementOptionalIntegerValue(child_element, "MAX-NUMBER-OF-TIME-QUANTA-PER-BIT", requirements.getMaxNumberOfTimeQuantaPerBit())
+            self.setChildElementOptionalFloatValue(child_element, "MAX-SAMPLE-POINT", requirements.getMaxSamplePoint())
+            self.setChildElementOptionalFloatValue(child_element, "MAX-SYNC-JUMP-WIDTH", requirements.getMaxSyncJumpWidth())
+            self.setChildElementOptionalTimeValue(child_element, "MAX-TRCV-DELAY-COMPENSATION-OFFSET", requirements.getMaxTrcvDelayCompensationOffset())
+            self.setChildElementOptionalIntegerValue(child_element, "MIN-NUMBER-OF-TIME-QUANTA-PER-BIT", requirements.getMinNumberOfTimeQuantaPerBit())
+            self.setChildElementOptionalFloatValue(child_element, "MIN-SAMPLE-POINT", requirements.getMinSamplePoint())
+            self.setChildElementOptionalFloatValue(child_element, "MIN-SYNC-JUMP-WIDTH", requirements.getMinSyncJumpWidth())
+            self.setChildElementOptionalTimeValue(child_element, "MIN-TRCV-DELAY-COMPENSATION-OFFSET", requirements.getMinTrcvDelayCompensationOffset())
+            self.setChildElementOptionalBooleanValue(child_element, "TX-BIT-RATE-SWITCH", requirements.getTxBitRateSwitch())
+
+    def writeAbstractCanCommunicationControllerAttributes(self, element: ET.Element, attributes: AbstractCanCommunicationControllerAttributes):
+        self.setCanControllerFdConfiguration(element, "CAN-CONTROLLER-FD-CONFIGURATION", attributes.getCanControllerFdAttributes())
+        self.setCanControllerFdConfigurationRequirements(element, "CAN-CONTROLLER-FD-REQUIREMENTS", attributes.getCanControllerFdRequirements())
+
+    def writeCanControllerConfigurationRequirements(self, element: ET.Element, requirements: CanControllerConfigurationRequirements):
+        if requirements is not None:
+            child_element = ET.SubElement(element, "CAN-CONTROLLER-CONFIGURATION-REQUIREMENTS")
+            self.writeAbstractCanCommunicationControllerAttributes(child_element, requirements)
+            self.setChildElementOptionalIntegerValue(child_element, "MAX-NUMBER-OF-TIME-QUANTA-PER-BIT", requirements.getMaxNumberOfTimeQuantaPerBit())
+            self.setChildElementOptionalFloatValue(child_element, "MAX-SAMPLE-POINT", requirements.getMaxSamplePoint())
+            self.setChildElementOptionalFloatValue(child_element, "MAX-SYNC-JUMP-WIDTH", requirements.getMaxSyncJumpWidth())
+            self.setChildElementOptionalIntegerValue(child_element, "MIN-NUMBER-OF-TIME-QUANTA-PER-BIT", requirements.getMinNumberOfTimeQuantaPerBit())
+            self.setChildElementOptionalFloatValue(child_element, "MIN-SAMPLE-POINT", requirements.getMinSamplePoint())
+            self.setChildElementOptionalFloatValue(child_element, "MIN-SYNC-JUMP-WIDTH", requirements.getMinSyncJumpWidth())
+
+    def writeAbstractCanCommunicationControllerCanControllerAttributes(self, element: ET.SubElement, controller: AbstractCanCommunicationController):
+        attributes = controller.getCanControllerAttributes()
+        if attributes is not None:
+            child_element = ET.SubElement(element, "CAN-CONTROLLER-ATTRIBUTES")
+            if isinstance(attributes, CanControllerConfigurationRequirements):
+                self.writeCanControllerConfigurationRequirements(child_element, attributes)
+            else:
+                self.notImplemented("Unsupported CanControllerAttributes <%s>" % type(attributes))    
+
+    def writeAbstractCanCommunicationController(self, element: ET.Element, controller: AbstractCanCommunicationController):
+        self.writeCommunicationController(element, controller)
+        self.writeAbstractCanCommunicationControllerCanControllerAttributes(element, controller)
 
     def writeCanCommunicationController(self, element: ET.Element, controller: CanCommunicationController):
         child_element = ET.SubElement(element, "CAN-COMMUNICATION-CONTROLLER")
         self.logger.debug("Write CanCommunicationController %s" % controller.getShortName())
         self.writeIdentifiable(child_element, controller)
+        variants_tag = ET.SubElement(child_element, "CAN-COMMUNICATION-CONTROLLER-VARIANTS")
+        cond_tag = ET.SubElement(variants_tag, "CAN-COMMUNICATION-CONTROLLER-CONDITIONAL")
+        self.writeAbstractCanCommunicationController(cond_tag, controller)
+
+    def writeCouplingPortSchedulerCouplingPortStructuralElement(self, element: ET.Element, item: CouplingPortStructuralElement):
+        self.writeIdentifiable(element, item)
+
+    def writeCouplingPortFifo(self, element: ET.Element, fifo: CouplingPortFifo):
+        if fifo is not None:
+            child_element = ET.SubElement(element, "COUPLING-PORT-FIFO")
+            self.writeCouplingPortSchedulerCouplingPortStructuralElement(child_element, fifo)
+
+    def writeCouplingPortScheduler(self, element: ET.Element, scheduler: CouplingPortScheduler):
+        if scheduler is not None:
+            child_element = ET.SubElement(element, "COUPLING-PORT-SCHEDULER")
+            self.writeCouplingPortSchedulerCouplingPortStructuralElement(child_element, scheduler)
+            self.setChildElementOptionalLiteral(child_element, "PORT-SCHEDULER", scheduler.getPortScheduler())
+
+    def writeCouplingPortDetailsCouplingPortStructuralElements(self, element: ET.Element, details: CouplingPortDetails):
+        items = details.getCouplingPortStructuralElements()
+        if len(items) > 0:
+            child_element = ET.SubElement(element, "COUPLING-PORT-STRUCTURAL-ELEMENTS")
+            for item in items:
+                if isinstance(item, CouplingPortFifo):
+                    self.writeCouplingPortFifo(child_element, item)
+                elif isinstance(item, CouplingPortScheduler):
+                    self.writeCouplingPortScheduler(child_element, item)
+                else:
+                    self.notImplemented("Unsupported CouplingPortStructuralElement <%s>" % type(item))
+    
+    def writeEthernetPriorityRegeneration(self, element: ET.Element, regeneration: EthernetPriorityRegeneration):
+        if regeneration is not None:
+            child_element = ET.SubElement(element, "ETHERNET-PRIORITY-REGENERATION")
+            self.writeReferrable(child_element, regeneration)
+            self.setChildElementOptionalPositiveInteger(child_element, "INGRESS-PRIORITY", regeneration.getIngressPriority())
+            self.setChildElementOptionalPositiveInteger(child_element, "REGENERATED-PRIORITY", regeneration.getRegeneratedPriority())
+
+    def writeCouplingPortDetailsEthernetPriorityRegenerations(self, element: ET.Element, details: CouplingPortDetails):
+        regenerations = details.getEthernetPriorityRegenerations()
+        if len(regenerations) > 0:
+            child_element = ET.SubElement(element, "ETHERNET-PRIORITY-REGENERATIONS")
+            for regeneration in regenerations:
+                if isinstance(regeneration, EthernetPriorityRegeneration):
+                    self.writeEthernetPriorityRegeneration(child_element, regeneration)
+                else:
+                    self.notImplemented("Unsupported EthernetPriorityRegeneration <%s>" % type(regeneration))
+
+    def setCouplingPortDetails(self, element: ET.Element, key: str, details: CouplingPortDetails):
+        if details is not None:
+             child_element = ET.SubElement(element, key)
+             self.writeCouplingPortDetailsCouplingPortStructuralElements(child_element, details)
+             self.writeCouplingPortDetailsEthernetPriorityRegenerations(child_element, details)
+             self.setChildElementOptionalRefType(child_element, "LAST-EGRESS-SCHEDULER-REF", details.getLastEgressSchedulerRef())
+
+    def writeVlanMembership(self, element: ET.Element, membership: VlanMembership):
+        if membership is not None:
+            child_element = ET.SubElement(element, "VLAN-MEMBERSHIP")
+            self.setChildElementOptionalLiteral(child_element, "SEND-ACTIVITY", membership.getSendActivity())
+            self.setChildElementOptionalRefType(child_element, "VLAN-REF", membership.getVlanRef())
+    
+    def writeCouplingPortVlanMemberships(self, element: ET.Element, port: CouplingPort):
+        memberships = port.getVlanMemberships()
+        if len(memberships) > 0:
+            child_element = ET.SubElement(element, "VLAN-MEMBERSHIPS")
+            for membership in memberships:
+                if isinstance(membership, VlanMembership):
+                    self.writeVlanMembership(child_element, membership)
+                else:
+                    self.notImplemented("Unsupported VlanMembership <%s>" % type(membership))
+
+    def writeCouplingPort(self, element: ET.Element, port: CouplingPort):
+        child_element = ET.SubElement(element, "COUPLING-PORT")
+        self.writeIdentifiable(child_element, port)
+        self.setCouplingPortDetails(child_element, "COUPLING-PORT-DETAILS", port.getCouplingPortDetails())
+        self.setChildElementOptionalLiteral(child_element, "MAC-LAYER-TYPE", port.getMacAddressVlanAssignments())
+        self.writeCouplingPortVlanMemberships(child_element, port)
+
+    def writeEthernetCommunicationControllerCouplingPorts(self, element: ET.Element, controller: EthernetCommunicationController):
+        ports = controller.getCouplingPorts()
+        if len(ports) > 0:
+            child_element = ET.SubElement(element, "COUPLING-PORTS")
+            for port in ports:
+                if isinstance(port, CouplingPort):
+                    self.writeCouplingPort(child_element, port)
+                else:
+                    self.notImplemented("Unsupported Coupling Port <%s>" % type(port))
 
     def writeEthernetCommunicationController(self, element: ET.Element, controller: EthernetCommunicationController):
         child_element = ET.SubElement(element, "ETHERNET-COMMUNICATION-CONTROLLER")
         self.logger.debug("Write EthernetCommunicationController %s" % controller.getShortName())
         self.writeIdentifiable(child_element, controller)
+        variants_tag = ET.SubElement(child_element, "ETHERNET-COMMUNICATION-CONTROLLER-VARIANTS")
+        cond_tag = ET.SubElement(variants_tag, "ETHERNET-COMMUNICATION-CONTROLLER-CONDITIONAL")
+        self.writeCommunicationController(cond_tag, controller)
+        self.writeEthernetCommunicationControllerCouplingPorts(cond_tag, controller)
 
     def writeEcuInstanceCommControllers(self, element: ET.Element, instance: EcuInstance):
         controllers = instance.getCommControllers()
@@ -2964,14 +3559,24 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.writeIdentifiable(element, connector)
         self.setChildElementOptionalRefType(element, "COMM-CONTROLLER-REF", connector.getCommControllerRef())
         self.writeCommunicationConnectorEcuCommPortInstances(element, connector)
+        self.setChildElementOptionalLiteral(element, "PNC-GATEWAY-TYPE", connector.getPncGatewayType())
 
     def writeCanCommunicationConnector(self, element: ET.Element, connector: CanCommunicationConnector):
         self.logger.debug("Write CanCommunicationConnector %s" % connector.getShortName())
         self.writeCommunicationConnector(element, connector)
 
+    def writeEthernetCommunicationConnectorNetworkEndpointRefs(self, element: ET.Element, connector: EthernetCommunicationConnector):
+        refs = connector.getNetworkEndpointRefs()
+        if len(refs) > 0:
+            child_element = ET.SubElement(element, "NETWORK-ENDPOINT-REFS")
+            for ref in refs:
+                self.setChildElementOptionalRefType(child_element, "NETWORK-ENDPOINT-REF", ref)
+
     def writeEthernetCommunicationConnector(self, element: ET.Element, connector: EthernetCommunicationConnector):
         self.logger.debug("Write EthernetCommunicationConnector %s" % connector.getShortName())
         self.writeCommunicationConnector(element, connector)
+        self.setChildElementOptionalPositiveInteger(element, "MAXIMUM-TRANSMISSION-UNIT", connector.getMaximumTransmissionUnit())
+        self.writeEthernetCommunicationConnectorNetworkEndpointRefs(element, connector)
 
     def writeLinCommunicationConnector(self, element: ET.Element, connector: LinCommunicationConnector):
         self.logger.debug("Write LinCommunicationConnector %s" % connector.getShortName())
@@ -2994,16 +3599,25 @@ class ARXMLWriter(AbstractARXMLWriter):
                 else:
                     self._raiseError("Unsupported Communication connector <%s>" % type(connector))
 
+    def writeEcuInstanceAssociatedComIPduGroupRefs(self, element: ET.Element, instance: EcuInstance):
+        refs = instance.getAssociatedComIPduGroupRefs()
+        if len(refs) > 0:
+            child_element = ET.SubElement(element, "ASSOCIATED-COM-I-PDU-GROUP-REFS")
+            for ref in refs:
+                self.setChildElementOptionalRefType(child_element, "ASSOCIATED-COM-I-PDU-GROUP-REF", ref)
+
     def writeEcuInstance(self, element: ET.Element, instance: EcuInstance):
         self.logger.debug("EcuInstance %s" % instance.getShortName())
         child_element = ET.SubElement(element, "ECU-INSTANCE")
         self.writeIdentifiable(child_element, instance)
+        self.writeEcuInstanceAssociatedComIPduGroupRefs(child_element, instance)
         self.setChildElementOptionalTimeValue(child_element, "COM-CONFIGURATION-GW-TIME-BASE", instance.getComConfigurationGwTimeBase())
         self.setChildElementOptionalTimeValue(child_element, "COM-CONFIGURATION-RX-TIME-BASE", instance.getComConfigurationRxTimeBase())
         self.setChildElementOptionalTimeValue(child_element, "COM-CONFIGURATION-TX-TIME-BASE", instance.getComConfigurationTxTimeBase())
         self.setChildElementOptionalBooleanValue(child_element, "COM-ENABLE-MDT-FOR-CYCLIC-TRANSMISSION", instance.getComEnableMDTForCyclicTransmission())
         self.writeEcuInstanceCommControllers(child_element, instance)
         self.writeEcuInstanceConnectors(child_element, instance)
+        self.setChildElementOptionalIntegerValue(child_element, "DIAGNOSTIC-ADDRESS", instance.getDiagnosticAddress())
         self.setChildElementOptionalBooleanValue(child_element, "SLEEP-MODE-SUPPORTED", instance.getSleepModeSupported())
         self.setChildElementOptionalBooleanValue(child_element, "WAKE-UP-OVER-BUS-SUPPORTED", instance.getWakeUpOverBusSupported())
 
@@ -3060,11 +3674,52 @@ class ARXMLWriter(AbstractARXMLWriter):
                 else:
                     self.notImplemented("Unsupported Sw Mapping %s" % type(sw_mapping))
 
+    def writeEcuMapping(self, element: ET.Element, mapping: ECUMapping):
+        self.logger.debug("Write ECUMapping <%s>" % mapping.getShortName())
+        if mapping is not None:
+            child_element = ET.SubElement(element, "ECU-MAPPING")
+            self.writeIdentifiable(child_element, mapping)
+            self.setChildElementOptionalRefType(child_element, "ECU-INSTANCE-REF", mapping.getEcuInstanceRef())
+            self.setChildElementOptionalRefType(child_element, "ECU-REF", mapping.getEcuRef())
+
+    def writeSystemMappingEcuResourceMappings(self, element: ET.Element, mapping: SystemMapping):
+        ecu_resource_mappings = mapping.getEcuResourceMappings()
+        if len(ecu_resource_mappings) > 0:
+            child_element = ET.SubElement(element, "ECU-RESOURCE-MAPPINGS")
+            for ecu_resource_mapping in ecu_resource_mappings:
+                if isinstance(ecu_resource_mapping, ECUMapping):
+                    self.writeEcuMapping(child_element, ecu_resource_mapping)
+                else:
+                    self.notImplemented("Unsupported Sw Mapping %s" % type(ecu_resource_mapping))
+
+    def writeSwcToImplMapping(self, element: ET.Element, mapping: SwcToImplMapping):
+        if mapping is not None:
+            child_element = ET.SubElement(element, "SWC-TO-IMPL-MAPPING")
+            self.writeIdentifiable(child_element, mapping)
+            self.setChildElementOptionalRefType(child_element, "COMPONENT-IMPLEMENTATION-REF", mapping.getComponentImplementationRef())
+            irefs = mapping.getComponentIRefs()
+            if len(irefs) > 0:
+                irefs_tag = ET.SubElement(child_element, "COMPONENT-IREFS")
+                for iref in irefs:
+                    self.setComponentInSystemInstanceRef(irefs_tag, "COMPONENT-IREF", iref)
+
+    def writeSystemMappingSwImplMappings(self, element: ET.Element, mapping: SystemMapping):
+        sw_impl_mappings = mapping.getSwImplMappings()
+        if len(sw_impl_mappings) > 0:
+            child_element = ET.SubElement(element, "SW-IMPL-MAPPINGS")
+            for sw_impl_mapping in sw_impl_mappings:
+                if isinstance(sw_impl_mapping, SwcToImplMapping):
+                    self.writeSwcToImplMapping(child_element, sw_impl_mapping)
+                else:
+                    self.notImplemented("Unsupported SwImplMapping <%s>" % type(sw_impl_mapping))
+
     def writeSystemMapping(self, element: ET.Element, mapping: SystemMapping):
-        self.logger.debug("Write SystemMapping %s" % mapping.getShortName())
+        self.logger.debug("Write SystemMapping <%s>" % mapping.getShortName())
         child_element = ET.SubElement(element, "SYSTEM-MAPPING")
         self.writeIdentifiable(child_element, mapping)
         self.writeSystemMappingDataMappings(child_element, mapping)
+        self.writeSystemMappingEcuResourceMappings(child_element, mapping)
+        self.writeSystemMappingSwImplMappings(child_element, mapping)
         self.writeSystemMappingSwMappings(child_element, mapping)
 
     def writeSystemMappings(self, element: ET.Element, system: System):
@@ -3086,20 +3741,21 @@ class ARXMLWriter(AbstractARXMLWriter):
             self.writeIdentifiable(child_element, prototype)
             self.setChildElementOptionalRefType(child_element, "FLAT-MAP-REF", prototype.getFlatMapRef())
             self.setChildElementOptionalRefType(child_element, "SOFTWARE-COMPOSITION-TREF", prototype.getSoftwareCompositionTRef())
+
+    def writeSystemFibexElementRefs(self, element: ET.Element, system: System):
+        refs = system.getFibexElementRefs()
+        if len(refs) > 0:
+            fibex_elements_tag = ET.SubElement(element, "FIBEX-ELEMENTS")
+            for ref in refs:
+                child_element = ET.SubElement(fibex_elements_tag, "FIBEX-ELEMENT-REF-CONDITIONAL")
+                self.setChildElementOptionalRefType(child_element, "FIBEX-ELEMENT-REF", ref)
                 
     def writeSystem(self, element: ET.Element, system: System):
         self.logger.debug("Write System %s" % system.getShortName())
         child_element = ET.SubElement(element, "SYSTEM")
-        self.setARElement(child_element, system)
-
+        self.writeARElement(child_element, system)
         self.setChildElementOptionalLiteral(child_element, "ECU-EXTRACT-VERSION", system.getEcuExtractVersion())
-        refs = system.getFibexElementRefs()
-        if len(refs) > 0:
-            fibex_elements_tag = ET.SubElement(child_element, "FIBEX-ELEMENTS")
-            for ref in refs:
-                fibex_element_ref_conditional_tag = ET.SubElement(fibex_elements_tag, "FIBEX-ELEMENT-REF-CONDITIONAL")
-                self.setChildElementOptionalRefType(fibex_element_ref_conditional_tag, "FIBEX-ELEMENT-REF", ref)
-
+        self.writeSystemFibexElementRefs(child_element, system)
         self.writeSystemMappings(child_element, system)
         self.writeRootSwCompositionPrototype(child_element, system)
         self.setChildElementOptionalRevisionLabelString(child_element, "SYSTEM-VERSION", system.getSystemVersion())
@@ -3107,10 +3763,13 @@ class ARXMLWriter(AbstractARXMLWriter):
     def writePhysicalDimension(self, element: ET.Element, dimension: PhysicalDimension):
         self.logger.debug("Set PhysicalDimension %s" % dimension.getShortName())
         child_element = ET.SubElement(element, "PHYSICAL-DIMENSION")
-        self.setARElement(child_element, dimension)
-        self.setChildElementOptionalNumericalValue(child_element, "CURRENT-EXP", dimension.getCurrentExp())
+        self.writeARElement(child_element, dimension)
         self.setChildElementOptionalNumericalValue(child_element, "LENGTH-EXP", dimension.getLengthExp())
+        self.setChildElementOptionalNumericalValue(child_element, "LUMINOUS-INTENSITY-EXP", dimension.getLuminousIntensityExp())
+        self.setChildElementOptionalNumericalValue(child_element, "MASS-EXP", dimension.getMassExp())
+        self.setChildElementOptionalNumericalValue(child_element, "TEMPERATURE-EXP", dimension.getTemperatureExp())
         self.setChildElementOptionalNumericalValue(child_element, "TIME-EXP", dimension.getTimeExp())
+        self.setChildElementOptionalNumericalValue(child_element, "CURRENT-EXP", dimension.getCurrentExp())
 
     def setFlatInstanceDescriptor(self, element: ET.Element, desc: FlatInstanceDescriptor):
         self.logger.debug("Set FlatInstanceDescriptor %s" % desc.getShortName())
@@ -3132,7 +3791,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     def writeFlatMap(self, element: ET.Element, map: FlatMap):
         self.logger.debug("Set FlatMap %s" % map.getShortName())
         child_element = ET.SubElement(element, "FLAT-MAP")
-        self.setARElement(child_element, map)
+        self.writeARElement(child_element, map)
         self.writeFlatMapInstances(child_element, map)
 
     def setDataPrototypeMapping(self, element: ET.Element, mapping: DataPrototypeMapping):
@@ -3165,7 +3824,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     def writePortInterfaceMappingSet(self, element: ET.Element, mapping_set: PortInterfaceMappingSet):
         self.logger.debug("Set PortInterfaceMappingSet %s" % mapping_set.getShortName())
         child_element = ET.SubElement(element, "PORT-INTERFACE-MAPPING-SET")
-        self.setARElement(child_element, mapping_set)
+        self.writeARElement(child_element, mapping_set)
         self.writePortInterfaceMappings(child_element, mapping_set)
 
     def setISignalMappings(self, element: ET.Element, mappings: List[ISignalMapping]):
@@ -3173,14 +3832,28 @@ class ARXMLWriter(AbstractARXMLWriter):
             mappings_tag = ET.SubElement(element, "SIGNAL-MAPPINGS")
             for mapping in mappings:
                 child_element = ET.SubElement(mappings_tag, "I-SIGNAL-MAPPING")
-                self.setChildElementOptionalRefType(child_element, "SOURCE-SIGNAL-REF", mapping.sourceSignalRef)
-                self.setChildElementOptionalRefType(child_element, "TARGET-SIGNAL-REF", mapping.targetSignalRef)
+                self.setChildElementOptionalRefType(child_element, "SOURCE-SIGNAL-REF", mapping.getSourceSignalRef())
+                self.setChildElementOptionalRefType(child_element, "TARGET-SIGNAL-REF", mapping.getTargetSignalRef())
+
+    def setTargetIPduRef(self, element: ET.Element, key: str, i_pdu_ref: TargetIPduRef):
+        if i_pdu_ref is not None:
+            child_element = ET.SubElement(element, key)
+            self.setChildElementOptionalRefType(child_element, "TARGET-I-PDU-REF", i_pdu_ref.getTargetIPdu())
+
+    def setIPduMappings(self, element: ET.Element, mappings: List[IPduMapping]):
+        if len(mappings) > 0:
+            mappings_tag = ET.SubElement(element, "I-PDU-MAPPINGS")
+            for mapping in mappings:
+                child_element = ET.SubElement(mappings_tag, "I-PDU-MAPPING")
+                self.setChildElementOptionalRefType(child_element, "SOURCE-I-PDU-REF", mapping.getSourceIpduRef())
+                self.setTargetIPduRef(child_element, "TARGET-I-PDU", mapping.getTargetIPdu())
 
     def writeGateway(self, element: ET.Element, gateway: Gateway):
         self.logger.debug("Gateway %s" % gateway.getShortName())
         child_element = ET.SubElement(element, "GATEWAY")
         self.writeIdentifiable(child_element, gateway)
         self.setChildElementOptionalRefType(child_element, "ECU-REF", gateway.ecuRef)
+        self.setIPduMappings(child_element, gateway.getIPduMappings())
         self.setISignalMappings(child_element, gateway.getSignalMappings())
 
     def writeISignal(self, element: ET.Element, signal: ISignal):
@@ -3371,55 +4044,227 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.setChildElementOptionalRefType(child_element, "PHYSICAL-REQUEST-REF", connection.getPhysicalRequestRef())
         self.setChildElementOptionalRefType(child_element, "RESPONSE-REF", connection.getResponseOnEventRef())
 
+    def writeDiagnosticServiceTableDiagnosticConnectionRefs(self, element: ET.Element, table: DiagnosticServiceTable):
+        refs = table.getDiagnosticConnectionRefs()
+        if len(refs) > 0:
+            refs_tag = ET.SubElement(element, "DIAGNOSTIC-CONNECTIONS")
+            for ref in refs:
+                child_element = ET.SubElement(refs_tag, "DIAGNOSTIC-CONNECTION-REF-CONDITIONAL")
+                self.setChildElementOptionalRefType(child_element, "DIAGNOSTIC-CONNECTION-REF", ref)
+
     def writeDiagnosticServiceTable(self, element: ET.Element, table: DiagnosticServiceTable):
         self.logger.debug("Write DiagnosticServiceTable %s" % table.getShortName())
         child_element = ET.SubElement(element, "DIAGNOSTIC-SERVICE-TABLE")
         self.writeIdentifiable(child_element, table)
+        self.writeDiagnosticServiceTableDiagnosticConnectionRefs(child_element, table)
+        self.setChildElementOptionalRefType(child_element, "ECU-INSTANCE-REF", table.getEcuInstanceRef())
 
-    def writeMultiplexedIPdu(self, element: ET.Element, i_pdu: MultiplexedIPdu):
-        self.logger.debug("Write MultiplexedIPdu %s" % i_pdu.getShortName())
-        child_element = ET.SubElement(element, "MULTIPLEXED-I-PDU")
-        self.writeIdentifiable(child_element, i_pdu)
+    def writePdu(self, element: ET.Element, pdu: Pdu):
+        self.writeIdentifiable(element, pdu)
+        self.setChildElementOptionalBooleanValue(element, "HAS-DYNAMIC-LENGTH", pdu.getHasDynamicLength())
+        self.setChildElementOptionalNumericalValue(element, "LENGTH", pdu.getLength())
 
-    def writeUserDefinedIPdu(self, element: ET.Element, i_pdu: UserDefinedIPdu):
-        self.logger.debug("Write UserDefinedIPdu %s" % i_pdu.getShortName())
+    def writeIPdu(self, element: ET.Element, pdu: IPdu):
+        self.writePdu(element, pdu)
+
+    def writeSegmentPosition(self, element: ET.Element, position: SegmentPosition):
+        if position is not None:
+            child_element = ET.SubElement(element, "SEGMENT-POSITION")
+            self.setChildElementOptionalLiteral(child_element, "SEGMENT-BYTE-ORDER", position.getSegmentByteOrder())
+            self.setChildElementOptionalIntegerValue(child_element, "SEGMENT-LENGTH", position.getSegmentLength())
+            self.setChildElementOptionalIntegerValue(child_element, "SEGMENT-POSITION", position.getSegmentPosition())
+
+    def writeMultiplexedPartSegmentPositions(self, element: ET.Element, part: MultiplexedPart):
+        positions = part.getSegmentPositions()
+        if len(positions) > 0:
+            child_element = ET.SubElement(element, "SEGMENT-POSITIONS")
+            for position in positions:
+                if isinstance(position, SegmentPosition):
+                    self.writeSegmentPosition(child_element, position)
+                else:
+                    self.notImplemented("Unsupported DynamicPart <%s>" % type(position))
+
+    def writeMultiplexedPart(self, element: ET.Element, part: MultiplexedPart):
+        self.writeMultiplexedPartSegmentPositions(element, part)
+
+    def writeDynamicPartAlternative(self, element: ET.Element, alternative: DynamicPartAlternative):
+        if alternative is not None:
+            child_element = ET.SubElement(element, "DYNAMIC-PART-ALTERNATIVE")
+            self.setChildElementOptionalRefType(child_element, "I-PDU-REF", alternative.getIPduRef())
+            self.setChildElementOptionalBooleanValue(child_element, "INITIAL-DYNAMIC-PART", alternative.getInitialDynamicPart())
+            self.setChildElementOptionalIntegerValue(child_element, "SELECTOR-FIELD-CODE", alternative.getSelectorFieldCode())
+
+    def writeDynamicPartDynamicPartAlternatives(self, element: ET.Element, part: DynamicPart):
+        alternatives = part.getDynamicPartAlternatives()
+        if len(alternatives) > 0:
+            child_element = ET.SubElement(element, "DYNAMIC-PART-ALTERNATIVES")
+            for alternative in alternatives:
+                if isinstance(alternative, DynamicPartAlternative):
+                    self.writeDynamicPartAlternative(child_element, alternative)
+                else:
+                    self.notImplemented("Unsupported DynamicPartAlternative <%s>" % type(alternative))
+
+    def writeDynamicPart(self, element: ET.Element, part: DynamicPart):
+        child_element = ET.SubElement(element, "DYNAMIC-PART")
+        self.writeMultiplexedPart(child_element, part)
+        self.writeDynamicPartDynamicPartAlternatives(child_element, part)
+
+    def writeMultiplexedIPduDynamicParts(self, element: ET.Element, ipdu: MultiplexedIPdu):
+        part = ipdu.getDynamicPart()
+        if part is not None:
+            child_element = ET.SubElement(element, "DYNAMIC-PARTS")
+            if isinstance(part, DynamicPart):
+                self.writeDynamicPart(child_element, part)
+            else:
+                self.notImplemented("Unsupported DynamicPart <%s>" % type(part))
+
+    def writeStaticPart(self, element: ET.Element, part: StaticPart):
+        child_element = ET.SubElement(element, "STATIC-PART")
+        self.writeMultiplexedPart(child_element, part)
+        self.setChildElementOptionalRefType(child_element, "I-PDU-REF", part.getIPduRef())
+
+    def writeMultiplexedIPduStaticParts(self, element: ET.Element, ipdu: MultiplexedIPdu):
+        part = ipdu.getStaticPart()
+        if part is not None:
+            child_element = ET.SubElement(element, "STATIC-PARTS")
+            if isinstance(part, StaticPart):
+                self.writeStaticPart(child_element, part)
+            else:
+                self.notImplemented("Unsupported StaticPart <%s>" % type(part))
+
+    def writeMultiplexedIPdu(self, element: ET.Element, ipdu: MultiplexedIPdu):
+        self.logger.debug("Write MultiplexedIPdu <%s>" % ipdu.getShortName())
+        child_element = ET.SubElement(element, "MULTIPLEXED-I-PDU")
+        self.writeIPdu(child_element, ipdu)
+        self.writeMultiplexedIPduDynamicParts(child_element, ipdu)
+        self.setChildElementOptionalLiteral(child_element, "SELECTOR-FIELD-BYTE-ORDER", ipdu.getSelectorFieldByteOrder())
+        self.setChildElementOptionalIntegerValue(child_element, "SELECTOR-FIELD-LENGTH", ipdu.getSelectorFieldLength())
+        self.setChildElementOptionalIntegerValue(child_element, "SELECTOR-FIELD-START-POSITION", ipdu.getSelectorFieldStartPosition())
+        self.writeMultiplexedIPduStaticParts(child_element, ipdu)
+        self.setChildElementOptionalLiteral(child_element, "TRIGGER-MODE", ipdu.getTriggerMode())
+        self.setChildElementOptionalIntegerValue(child_element, "UNUSED-BIT-PATTERN", ipdu.getUnusedBitPattern())
+
+    def writeUserDefinedIPdu(self, element: ET.Element, ipdu: UserDefinedIPdu):
+        self.logger.debug("Write UserDefinedIPdu <%s>" % ipdu.getShortName())
         child_element = ET.SubElement(element, "USER-DEFINED-I-PDU")
-        self.writeIdentifiable(child_element, i_pdu)
+        self.writeIPdu(child_element, ipdu)
+        self.setChildElementOptionalLiteral(child_element, "CDD-TYPE", ipdu.getCddType())
 
     def writeUserDefinedPdu(self, element: ET.Element, pdu: UserDefinedPdu):
-        self.logger.debug("Write UserDefinedPdu %s" % pdu.getShortName())
+        self.logger.debug("Write UserDefinedPdu <%s>" % pdu.getShortName())
         child_element = ET.SubElement(element, "USER-DEFINED-PDU")
-        self.writeIdentifiable(child_element, pdu)
+        self.writePdu(child_element, pdu)
+        self.setChildElementOptionalLiteral(child_element, "CDD-TYPE", pdu.getCddType())
 
     def writeGeneralPurposePdu(self, element: ET.Element, pdu: GeneralPurposePdu):
-        self.logger.debug("Write GeneralPurposePdu %s" % pdu.getShortName())
+        self.logger.debug("Write GeneralPurposePdu <%s>" % pdu.getShortName())
         child_element = ET.SubElement(element, "GENERAL-PURPOSE-PDU")
-        self.writeIdentifiable(child_element, pdu)
+        self.writePdu(child_element, pdu)
 
     def writeGeneralPurposeIPdu(self, element: ET.Element, i_pdu: GeneralPurposeIPdu):
-        self.logger.debug("Write GeneralPurposeIPdu %s" % i_pdu.getShortName())
+        self.logger.debug("Write GeneralPurposeIPdu <%s>" % i_pdu.getShortName())
         child_element = ET.SubElement(element, "GENERAL-PURPOSE-I-PDU")
-        self.writeIdentifiable(child_element, i_pdu)
+        self.writeIPdu(child_element, i_pdu)
+
+    def writeSecureCommunicationAuthenticationProps(self, element: ET.Element, props: SecureCommunicationAuthenticationProps):
+        chile_element = ET.SubElement(element, "SECURE-COMMUNICATION-AUTHENTICATION-PROPS")
+        self.writeIdentifiable(chile_element, props)
+        self.setChildElementOptionalLiteral(chile_element, "AUTH-ALGORITHM", props.getAuthAlgorithm())
+        self.setChildElementOptionalPositiveInteger(chile_element, "AUTH-INFO-TX-LENGTH", props.getAuthInfoTxLength())
+
+    def writeSecureCommunicationPropsSetAuthenticationProps(self, element: ET.Element, props_set: SecureCommunicationPropsSet):
+        propses = props_set.getAuthenticationProps()
+        if len(propses) > 0:
+            child_element = ET.SubElement(element, "AUTHENTICATION-PROPSS")
+            for props in propses:
+                if isinstance(props, SecureCommunicationAuthenticationProps):
+                    self.writeSecureCommunicationAuthenticationProps(child_element, props)
+                else:
+                    self.notImplemented("Unsupported AuthenticationProps <%s>" % type(props))
+
+    def writeSecureCommunicationFreshnessProps(self, element: ET.Element, props: SecureCommunicationFreshnessProps):
+        child_element = ET.SubElement(element, "SECURE-COMMUNICATION-FRESHNESS-PROPS")
+        self.writeIdentifiable(child_element, props)
+        self.setChildElementOptionalLiteral(child_element, "FRESHNESS-VALUE-LENGTH", props.getFreshnessValueLength())
+        self.setChildElementOptionalPositiveInteger(child_element, "FRESHNESS-VALUE-TX-LENGTH", props.getFreshnessValueTxLength())
+
+    def writeSecureCommunicationPropsSetFreshnessProps(self, element: ET.Element, props_set: SecureCommunicationPropsSet):
+        propses = props_set.getFreshnessProps()
+        if len(propses) > 0:
+            child_element = ET.SubElement(element, "FRESHNESS-PROPSS")
+            for props in propses:
+                if isinstance(props, SecureCommunicationFreshnessProps):
+                    self.writeSecureCommunicationFreshnessProps(child_element, props)
+                else:
+                    self.notImplemented("Unsupported FreshnessProps <%s>" % type(props))
 
     def writeSecureCommunicationPropsSet(self, element: ET.Element, set: SecureCommunicationPropsSet):
         self.logger.debug("Write SecureCommunicationPropsSet %s" % set.getShortName())
         child_element = ET.SubElement(element, "SECURE-COMMUNICATION-PROPS-SET")
         self.writeIdentifiable(child_element, set)
+        self.writeSecureCommunicationPropsSetAuthenticationProps(child_element, set)
+        self.writeSecureCommunicationPropsSetFreshnessProps(child_element, set)
 
     def writeSoAdRoutingGroup(self, element: ET.Element, group: SoAdRoutingGroup):
-        self.logger.debug("Write SoAdRoutingGroup %s" % group.getShortName())
+        self.logger.debug("Write SoAdRoutingGroup <%s>" % group.getShortName())
         child_element = ET.SubElement(element, "SO-AD-ROUTING-GROUP")
         self.writeIdentifiable(child_element, group)
+        self.setChildElementOptionalLiteral(child_element, "EVENT-GROUP-CONTROL-TYPE", group.getEventGroupControlType())
+
+    def writeDoIpLogicAddress(self, element: ET.Element, address: DoIpLogicAddress):
+        if address is not None:
+            child_element = ET.SubElement(element, "DO-IP-LOGIC-ADDRESS")
+            self.writeIdentifiable(child_element, address)
+            self.setChildElementOptionalIntegerValue(child_element, "ADDRESS", address.getAddress())
+
+    def writeDoIpTpConfigDoIpLogicAddresses(self, element: ET.Element, config: DoIpTpConfig):
+        addresses = config.getDoIpLogicAddresses()
+        if len(addresses) > 0:
+            child_element = ET.SubElement(element, "DO-IP-LOGIC-ADDRESSS")
+            for address in addresses:
+                if isinstance(address, DoIpLogicAddress):
+                    self.writeDoIpLogicAddress(child_element, address)
+                else:
+                    self.notImplemented("Unsupported DoIpLogicAddress <%s>" % type(address))
+
+    def writeDoIpTpConnection(self, element: ET.Element, connection: DoIpTpConnection):
+        if connection is not None:
+            child_element = ET.SubElement(element, "DO-IP-TP-CONNECTION")
+            self.writeTpConnection(child_element, connection)
+            self.setChildElementOptionalRefType(child_element, "DO-IP-SOURCE-ADDRESS-REF", connection.getDoIpSourceAddressRef())
+            self.setChildElementOptionalRefType(child_element, "DO-IP-TARGET-ADDRESS-REF", connection.getDoIpTargetAddressRef())
+            self.setChildElementOptionalRefType(child_element, "TP-SDU-REF", connection.getTpSduRef())
+
+    def writeDoIpTpConfigTpConnections(self, element: ET.Element, config: DoIpTpConfig):
+        connections = config.getTpConnections()
+        if len(connections) > 0:
+            child_element = ET.SubElement(element, "TP-CONNECTIONS")
+            for address in connections:
+                if isinstance(address, DoIpTpConnection):
+                    self.writeDoIpTpConnection(child_element, address)
+                else:
+                    self.notImplemented("Unsupported TpConnection <%s>" % type(address))
 
     def writeDoIpTpConfig(self, element: ET.Element, config: DoIpTpConfig):
-        self.logger.debug("Write DoIpTpConfig %s" % config.getShortName())
+        self.logger.debug("Write DoIpTpConfig <%s>" % config.getShortName())
         child_element = ET.SubElement(element, "DO-IP-TP-CONFIG")
-        self.writeIdentifiable(child_element, config)
+        self.writeTpConfig(child_element, config)
+        self.writeDoIpTpConfigDoIpLogicAddresses(child_element, config)
+        self.writeDoIpTpConfigTpConnections(child_element, config)
 
-    def writeLinMaster(self, element: ET.Element, master: LinMaster):
-        self.logger.debug("Write LinMaster %s" % master.getShortName())
+    def writeLinCommunicationController(self, element: ET.Element, controller: LinCommunicationController):
+        self.writeCommunicationController(element, controller)
+        self.setChildElementOptionalLiteral(element, "PROTOCOL-VERSION", controller.getProtocolVersion())
+
+    def writeLinMaster(self, element: ET.Element, controller: LinMaster):
+        self.logger.debug("Write LinMaster <%s>" % controller.getShortName())
         child_element = ET.SubElement(element, "LIN-MASTER")
-        self.writeIdentifiable(child_element, master)
+        self.writeIdentifiable(child_element, controller)
+        variants_tag = ET.SubElement(child_element, "LIN-MASTER-VARIANTS")
+        cond_tag = ET.SubElement(variants_tag, "LIN-MASTER-CONDITIONAL")
+        self.writeLinCommunicationController(cond_tag, controller)
+        self.setChildElementOptionalTimeValue(cond_tag, "TIME-BASE", controller.getTimeBase())
+        self.setChildElementOptionalTimeValue(cond_tag, "TIME-BASE-JITTER", controller.getTimeBaseJitter())
 
     def writeISignalToPduMappings(self, element: ET.Element, parent: ISignalIPdu):
         mappings = parent.getISignalToPduMappings()
@@ -3439,10 +4284,12 @@ class ARXMLWriter(AbstractARXMLWriter):
         if filter is not None:
             child_element = ET.SubElement(element, key)
             self.setChildElementOptionalLiteral(child_element, "DATA-FILTER-TYPE", filter.getDataFilterType())
+            self.setChildElementOptionalIntegerValue(child_element, "MASK", filter.getMask())
+            self.setChildElementOptionalIntegerValue(child_element, "X", filter.getX())
 
-    def setTransmissionModeConditions(self, element: ET.Element, conditions: List[TransmissionModeCondition]):
+    def setTransmissionModeConditions(self, element: ET.Element, key: str, conditions: List[TransmissionModeCondition]):
         if len(conditions) > 0:
-            conditions_tag = ET.SubElement(element, "TRANSMISSION-MODE-CONDITIONS")
+            conditions_tag = ET.SubElement(element, key)
             for condition in conditions:
                 child_element = ET.SubElement(conditions_tag, "TRANSMISSION-MODE-CONDITION")
                 self.setDataFilter(child_element, "DATA-FILTER", condition.getDataFilter())
@@ -3480,7 +4327,8 @@ class ARXMLWriter(AbstractARXMLWriter):
     def setTransmissionModeDeclaration(self, element: ET.Element, key: str, decl : TransmissionModeDeclaration):
         if decl is not None:
             child_element = ET.SubElement(element, key)
-            self.setTransmissionModeConditions(child_element, decl.getTransmissionModeConditions())
+            self.setTransmissionModeConditions(child_element, "TRANSMISSION-MODE-CONDITIONS", decl.getTransmissionModeConditions())
+            self.setTransmissionModeTiming(child_element, "TRANSMISSION-MODE-FALSE-TIMING", decl.getTransmissionModeFalseTiming())
             self.setTransmissionModeTiming(child_element, "TRANSMISSION-MODE-TRUE-TIMING", decl.getTransmissionModeTrueTiming())
 
     def setISignalIPduIPduTimingSpecification(self, element: ET.Element, timing: IPduTiming):
@@ -3490,14 +4338,14 @@ class ARXMLWriter(AbstractARXMLWriter):
             self.setChildElementOptionalTimeValue(child_element, "MINIMUM-DELAY", timing.getMinimumDelay())
             self.setTransmissionModeDeclaration(child_element, "TRANSMISSION-MODE-DECLARATION", timing.getTransmissionModeDeclaration())
 
-    def writeISignalIPdu(self, element: ET.Element, i_pdu: ISignalIPdu):
-        self.logger.debug("ISignalIPdu %s" % i_pdu.getShortName())
+    def writeISignalIPdu(self, element: ET.Element, ipdu: ISignalIPdu):
+        self.logger.debug("ISignalIPdu %s" % ipdu.getShortName())
         child_element = ET.SubElement(element, "I-SIGNAL-I-PDU")
-        self.writeIdentifiable(child_element, i_pdu)
-        self.setChildElementOptionalNumericalValue(child_element, "LENGTH", i_pdu.getLength())
-        self.setISignalIPduIPduTimingSpecification(child_element, i_pdu.getIPduTimingSpecification())
-        self.writeISignalToPduMappings(child_element, i_pdu)
-        self.setChildElementOptionalLiteral(child_element, "UNUSED-BIT-PATTERN", i_pdu.getUnusedBitPattern())
+        self.writeIdentifiable(child_element, ipdu)
+        self.setChildElementOptionalNumericalValue(child_element, "LENGTH", ipdu.getLength())
+        self.setISignalIPduIPduTimingSpecification(child_element, ipdu.getIPduTimingSpecification())
+        self.writeISignalToPduMappings(child_element, ipdu)
+        self.setChildElementOptionalIntegerValue(child_element, "UNUSED-BIT-PATTERN", ipdu.getUnusedBitPattern())
 
     def writeARPackageElement(self, element: ET.Element, ar_element: ARElement):
         if isinstance(ar_element, ComplexDeviceDriverSwComponentType):
@@ -3572,6 +4420,8 @@ class ARXMLWriter(AbstractARXMLWriter):
             self.writeSecuredIPdu(element, ar_element)
         elif isinstance(ar_element, CanTpConfig):
             self.writeCanTpConfig(element, ar_element)
+        elif isinstance(ar_element, LinTpConfig):
+            self.writeLinTpConfig(element, ar_element)
         elif isinstance(ar_element, LinCluster):
             self.writeLinCluster(element, ar_element)
         elif isinstance(ar_element, CanCluster):
@@ -3664,7 +4514,7 @@ class ARXMLWriter(AbstractARXMLWriter):
                 
 
     def save(self, filename, document: AUTOSAR):
-        self.logger.info("Save %s ..." % filename)
+        self.logger.info("Saving %s ..." % filename)
 
         root = ET.Element("AUTOSAR", self.nsmap)
         root.attrib["xmlns:xsi"] = "http://www.w3.org/2001/XMLSchema-instance"