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

armodel/writer/arxml_writer.py

@@ -30,7 +30,7 @@ from ..models.M2.AUTOSARTemplates.CommonStructure import ApplicationValueSpecifi
 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
@@ -55,7 +55,7 @@ from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Datatype.Datatypes import
 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.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
@@ -83,18 +83,18 @@ from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.EcuInstance imp
 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.TransportProtocols import CanTpConfig, DoIpTpConfig, LinTpConfig
 
 from .abstract_arxml_writer import AbstractARXMLWriter
 class ARXMLWriter(AbstractARXMLWriter):
@@ -144,7 +144,7 @@ class ARXMLWriter(AbstractARXMLWriter):
                 limit_tag.attrib['INTERVAL-TYPE'] = limit.intervalType
             limit_tag.text = limit.value
     
-    def setReferable(self, element: ET.Element, referrable: Referrable):
+    def writeReferrable(self, element: ET.Element, referrable: Referrable):
         self.setARObjectAttributes(element, referrable)
         self.setShortName(element, referrable.getShortName())
 
@@ -175,8 +175,8 @@ class ARXMLWriter(AbstractARXMLWriter):
             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)
 
@@ -198,14 +198,14 @@ 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):
@@ -728,7 +728,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):
@@ -1989,12 +1989,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):
@@ -2387,20 +2400,20 @@ class ARXMLWriter(AbstractARXMLWriter):
                     self.notImplemented("Unsupported Nm Cluster <%s>" % type(cluster))
 
     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)
 
     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)
 
     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)
@@ -2409,23 +2422,28 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.setChildElementOptionalLiteral(element, "LENGTH", pdu.getLength())
 
     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())
+        self.logger.debug("Write SecuredIPdu <%s>" % pdu.getShortName())
         child_element = ET.SubElement(element, "SECURED-I-PDU")
         self.writeIdentifiable(child_element, pdu)
         self.writeIPdu(child_element, pdu)
 
     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)
 
+    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.writeIdentifiable(child_element, config)
+
     def writeFrameTriggering(self, element: ET.Element, triggering: FrameTriggering):
         ref_list = triggering.getFramePortRefs()
         if len(ref_list) > 0:
@@ -2666,7 +2684,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 +2768,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 +2787,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 +2804,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 +2880,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 +2980,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 +3022,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 +3044,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,6 +3213,7 @@ 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())
@@ -2972,6 +3222,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     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())
 
     def writeLinCommunicationConnector(self, element: ET.Element, connector: LinCommunicationConnector):
         self.logger.debug("Write LinCommunicationConnector %s" % connector.getShortName())
@@ -2994,10 +3245,18 @@ 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())
@@ -3086,20 +3345,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,7 +3367,7 @@ 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.writeARElement(child_element, dimension)
         self.setChildElementOptionalNumericalValue(child_element, "CURRENT-EXP", dimension.getCurrentExp())
         self.setChildElementOptionalNumericalValue(child_element, "LENGTH-EXP", dimension.getLengthExp())
         self.setChildElementOptionalNumericalValue(child_element, "TIME-EXP", dimension.getTimeExp())
@@ -3132,7 +3392,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 +3425,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 +3433,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,10 +3645,20 @@ 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())
@@ -3416,10 +3700,19 @@ class ARXMLWriter(AbstractARXMLWriter):
         child_element = ET.SubElement(element, "DO-IP-TP-CONFIG")
         self.writeIdentifiable(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()
@@ -3572,6 +3865,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):