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

armodel/writer/arxml_writer.py

@@ -1,9 +1,6 @@
 import xml.etree.cElementTree as ET
-
 from typing import List
 
-
-
 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
@@ -36,7 +33,7 @@ from ..models.M2.AUTOSARTemplates.CommonStructure.SwcBswMapping import SwcBswMap
 from ..models.M2.AUTOSARTemplates.CommonStructure.Implementation import Code, Implementation
 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, DiagnosticEventNeeds, DiagnosticRoutineNeeds, DiagnosticValueNeeds, EcuStateMgrUserNeeds, NvBlockNeeds, RoleBasedDataAssignment, RoleBasedDataTypeAssignment, ServiceDependency
+from ..models.M2.AUTOSARTemplates.CommonStructure.ServiceNeeds import CryptoServiceNeeds, DiagEventDebounceMonitorInternal, DiagnosticCommunicationManagerNeeds, DiagnosticEventInfoNeeds, DiagnosticEventNeeds, DiagnosticRoutineNeeds, DiagnosticValueNeeds, EcuStateMgrUserNeeds, NvBlockNeeds, RoleBasedDataAssignment, RoleBasedDataTypeAssignment, ServiceDependency
 from ..models.M2.AUTOSARTemplates.CommonStructure.InternalBehavior import ExecutableEntity
 from ..models.M2.AUTOSARTemplates.CommonStructure.ImplementationDataTypes import ImplementationDataType
 from ..models.M2.AUTOSARTemplates.CommonStructure.InternalBehavior import InternalBehavior
@@ -60,12 +57,13 @@ from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Communication import Compo
 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.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
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.ServerCall import ServerCallPoint
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.DataElements import ParameterAccess, VariableAccess
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Composition import AssemblySwConnector, DelegationSwConnector, SwComponentPrototype, SwConnector
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Composition.InstanceRefs import POperationInAtomicSwcInstanceRef, PPortInCompositionInstanceRef, ROperationInAtomicSwcInstanceRef, RPortInCompositionInstanceRef
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.PortInterface.InstanceRefs import ApplicationCompositeElementInPortInterfaceInstanceRef
-from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.InstanceRefsUsage import AutosarParameterRef, AutosarVariableRef, VariableInAtomicSWCTypeInstanceRef
+from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.InstanceRefsUsage import AutosarParameterRef, VariableInAtomicSWCTypeInstanceRef
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Communication import ClientComSpec, ModeSwitchReceiverComSpec, ModeSwitchSenderComSpec, NonqueuedReceiverComSpec, NonqueuedSenderComSpec, PPortComSpec, ParameterRequireComSpec,  QueuedReceiverComSpec, QueuedSenderComSpec, RPortComSpec, ReceiverComSpec, SenderComSpec, ServerComSpec
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.Components.InstanceRefs import PModeGroupInAtomicSwcInstanceRef, RModeGroupInAtomicSWCInstanceRef
 from ..models.M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.ServiceMapping import RoleBasedPortAssignment, SwcServiceDependency
@@ -80,13 +78,17 @@ from ..models.M2.AUTOSARTemplates.SystemTemplate import SwcToEcuMapping, System,
 from ..models.M2.AUTOSARTemplates.SystemTemplate.DataMapping import SenderReceiverToSignalGroupMapping, SenderReceiverToSignalMapping
 from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.CoreCommunication import FrameTriggering, IPdu, IPduTiming, ISignalGroup, ISignalIPdu, ISignalIPduGroup, ISignalTriggering, PduTriggering, SecuredIPdu, SystemSignal, DcmIPdu, Frame, ISignal, NPdu, NmPdu, SystemSignalGroup
 from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.EcuInstance import EcuInstance
-from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.Timing import EventControlledTiming, TimeRangeType, TransmissionModeCondition, TransmissionModeDeclaration, TransmissionModeTiming
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.Timing import CyclicTiming, EventControlledTiming, TimeRangeType, TransmissionModeCondition, TransmissionModeDeclaration, TransmissionModeTiming
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Ethernet.EthernetCommunication import 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
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Ethernet.NetworkEndpoint import Ipv6Configuration, NetworkEndpoint, NetworkEndpointAddress
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Ethernet.ServiceInstances import SoAdConfig
 from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Multiplatform import Gateway, ISignalMapping
 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.Fibex4Lin.LinCommunication import LinFrameTriggering, LinUnconditionalFrame
-from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.CoreTopology import AbstractCanCluster, CanCluster, CanPhysicalChannel, CommConnectorPort, CommunicationCluster, CommunicationConnector, FramePort, IPduPort, ISignalPort, LinCluster, LinPhysicalChannel, PhysicalChannel
+from ..models.M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.CoreTopology import AbstractCanCluster, CanCluster, CanPhysicalChannel, CommConnectorPort, CommunicationCluster, CommunicationConnector, EthernetPhysicalChannel, FramePort, IPduPort, ISignalPort, LinCluster, LinPhysicalChannel, PhysicalChannel
 from ..models.M2.AUTOSARTemplates.SystemTemplate.InstanceRefs import ComponentInSystemInstanceRef, VariableDataPrototypeInSystemInstanceRef
 from ..models.M2.AUTOSARTemplates.SystemTemplate.NetworkManagement import CanNmCluster, CanNmClusterCoupling, CanNmNode, NmCluster, NmConfig, NmNode
 from ..models.M2.AUTOSARTemplates.SystemTemplate.TransportProtocols import CanTpConfig
@@ -402,11 +404,13 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.setChildElementOptionalRefType(child_element, "PARAMETER-REF", com_spec.getParameterRef())
         self.setValueSpecification(child_element, "INIT-VALUE", com_spec.getInitValue())
 
-    def writeModeSwitchReceiverComSpec(self, element: ET.Element, com_spec: ModeSwitchReceiverComSpec):
+    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.setChildElementOptionalRefType(child_element, "MODE-GROUP-REF", com_spec.modeGroupRef)
+        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())
 
     def writeRPortComSpec(self, element: ET.Element, com_spec: RPortComSpec):
         if isinstance(com_spec, NonqueuedReceiverComSpec):
@@ -416,7 +420,7 @@ class ARXMLWriter(AbstractARXMLWriter):
         elif isinstance(com_spec, ClientComSpec):
             self.writeClientComSpec(element, com_spec)
         elif isinstance(com_spec, ModeSwitchReceiverComSpec):
-            self.writeModeSwitchReceiverComSpec(element, com_spec)
+            self.setModeSwitchReceiverComSpec(element, com_spec)
         elif isinstance(com_spec, ParameterRequireComSpec):
             self.writeParameterRequireComSpec(element, com_spec)
         else:
@@ -652,11 +656,11 @@ 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.setChildElementOptionalRefType(child_element, "INPUT-VARIABLE-TYPE-REF", props.inputVariableTypeRef)
-        self.setChildElementOptionalRefType(child_element, "COMPU-METHOD-REF", props.compuMethodRef)
-        self.setChildElementOptionalNumericalValue(child_element, "SW-MAX-AXIS-POINTS", props.swMaxAxisPoints) 
-        self.setChildElementOptionalNumericalValue(child_element, "SW-MIN-AXIS-POINTS", props.swMinAxisPoints)
-        self.setChildElementOptionalRefType(child_element, "DATA-CONSTR-REF", props.dataConstrRef)
+        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()) 
+        self.setChildElementOptionalNumericalValue(child_element, "SW-MIN-AXIS-POINTS", props.getSwMinAxisPoints())
+        self.setChildElementOptionalRefType(child_element, "DATA-CONSTR-REF", props.getDataConstrRef())
 
     def setSwAxisGrouped(self, element: ET.Element, props: SwAxisGrouped):
         child_element = ET.SubElement(element, "SW-AXIS-GROUPED")
@@ -699,12 +703,13 @@ class ARXMLWriter(AbstractARXMLWriter):
             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.setChildElementOptionalRefType(conditional_tag, "DATA-CONSTR-REF", props.getDataConstrRef())
+            
             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.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())
@@ -723,7 +728,7 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.setARElement(element, data_type)
         self.setSwDataDefProps(element, "SW-DATA-DEF-PROPS", data_type.getSwDataDefProps())
 
-    def setApplicationPrimitiveDataType(self, element: ET.Element, data_type: ApplicationPrimitiveDataType):
+    def writeApplicationPrimitiveDataType(self, element: ET.Element, data_type: ApplicationPrimitiveDataType):
         self.logger.debug("writeApplicationPrimitiveDataType %s" % data_type.getShortName())
         data_type_tag = ET.SubElement(element, "APPLICATION-PRIMITIVE-DATA-TYPE")
         self.setApplicationDataType(data_type_tag, data_type)
@@ -732,6 +737,7 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.setSwDataDefProps(element, "SW-DATA-DEF-PROPS", prototype.getSwDataDefProps())
 
     def setApplicationCompositeElementDataPrototype(self, element: ET.Element, prototype: ApplicationCompositeElementDataPrototype):
+        self.setIdentifiable(element, prototype)
         self.setDataPrototype(element, prototype)
         self.setChildElementOptionalRefType(element, "TYPE-TREF", prototype.typeTRef)
 
@@ -746,7 +752,7 @@ class ARXMLWriter(AbstractARXMLWriter):
                 child_element = ET.SubElement(elements_tag, "APPLICATION-RECORD-ELEMENT")
                 self.setApplicationRecordElement(child_element, record)
 
-    def setApplicationRecordDataType(self, element: ET.Element, data_type: ApplicationRecordDataType):
+    def writeApplicationRecordDataType(self, element: ET.Element, data_type: ApplicationRecordDataType):
         data_type_tag = ET.SubElement(element, "APPLICATION-RECORD-DATA-TYPE")
         self.setApplicationDataType(data_type_tag, data_type)
         self.writeApplicationRecordElements(data_type_tag, data_type)
@@ -754,22 +760,23 @@ class ARXMLWriter(AbstractARXMLWriter):
     def writeApplicationDataTypes(self, parent: ET.Element, ar_package: ARPackage):
         for data_type in ar_package.getApplicationDataType():
             if isinstance(data_type, ApplicationPrimitiveDataType):
-                self.setApplicationPrimitiveDataType(parent, data_type)
+                self.writeApplicationPrimitiveDataType(parent, data_type)
             elif isinstance(data_type, ApplicationRecordDataType):
-                self.setApplicationRecordDataType(parent, data_type)
+                self.writeApplicationRecordDataType(parent, data_type)
             else:
                 self.notImplemented("Unsupported ApplicationDataType <%s>" % type(data_type))
 
-    def writeBaseTypeDirectDefinition(self, element: ET.Element, base_type_definition: BaseTypeDirectDefinition):
-        self.setChildElementOptionalNumericalValue(element, "BASE-TYPE-SIZE", base_type_definition.baseTypeSize)
-        self.setChildElementOptionalLiteral(element, "BASE-TYPE-ENCODING", base_type_definition.baseTypeEncoding)
-        self.setChildElementOptionalNumericalValue(element, "MEM-ALIGNMENT", base_type_definition.memAlignment)
-        self.setChildElementOptionalLiteral(element, "NATIVE-DECLARATION", base_type_definition.nativeDeclaration)
+    def setBaseTypeDirectDefinition(self, element: ET.Element, base_type_definition: BaseTypeDirectDefinition):
+        self.setChildElementOptionalNumericalValue(element, "BASE-TYPE-SIZE", base_type_definition.getBaseTypeSize())
+        self.setChildElementOptionalLiteral(element, "BASE-TYPE-ENCODING", base_type_definition.getBaseTypeEncoding())
+        self.setChildElementOptionalLiteral(element, "BYTE-ORDER", base_type_definition.getByteOrder())
+        self.setChildElementOptionalNumericalValue(element, "MEM-ALIGNMENT", base_type_definition.getMemAlignment())
+        self.setChildElementOptionalLiteral(element, "NATIVE-DECLARATION", base_type_definition.getNativeDeclaration())
 
-    def setSwBaseType(self, element: ET.Element, base_type: SwBaseType):
+    def writeSwBaseType(self, element: ET.Element, base_type: SwBaseType):
         data_type_tag = ET.SubElement(element, "SW-BASE-TYPE")
         self.setIdentifiable(data_type_tag, base_type)
-        self.writeBaseTypeDirectDefinition(data_type_tag, base_type.baseTypeDefinition)
+        self.setBaseTypeDirectDefinition(data_type_tag, base_type.getBaseTypeDefinition())
 
     def writeCompuScaleConstantContents(self, element: ET.Element, contents: CompuScaleConstantContents):
         compu_const_tag = ET.SubElement(element, "COMPU-CONST")
@@ -834,7 +841,7 @@ class ARXMLWriter(AbstractARXMLWriter):
             self.setCompuScales(child_element, compu.getCompuContent())
             self.setCompuConst(child_element, "COMPU-DEFAULT-VALUE", compu.getCompuDefaultValue())
 
-    def setCompuMethod(self, element: ET.Element, compu_method: CompuMethod):
+    def writeCompuMethod(self, element: ET.Element, compu_method: CompuMethod):
         child_element = ET.SubElement(element, "COMPU-METHOD")
         self.logger.debug("write CompuMethods %s" % compu_method.getShortName())
         self.setIdentifiable(child_element, compu_method)
@@ -1032,22 +1039,15 @@ class ARXMLWriter(AbstractARXMLWriter):
             for ref in refs:
                 self.setChildElementOptionalRefType(refs_tag, "DATA-TYPE-MAPPING-REF", ref)
 
-    def writeInternalBehaviorConstantMemories(self, element: ET.Element, behavior: InternalBehavior):
-        memories = behavior.getConstantMemorys()
-        if len(memories) > 0:
-            child_element = ET.SubElement(element, "CONSTANT-MEMORYS")
-            for memory in memories:
-                self.writeParameterDataPrototype(child_element, memory)
-           
     def writeInternalBehavior(self, element: ET.Element, behavior: InternalBehavior):
         self.setIdentifiable(element, behavior)
-        self.writeInternalBehaviorConstantMemories(element, behavior)
+        self.setParameterDataPrototypes(element, "CONSTANT-MEMORYS", behavior.getConstantMemories())
         self.writeDataTypeMappingRefs(element, behavior)
         self.writeExclusiveAreas(element, behavior)
 
-    def setAutosarVariableRef(self, element: ET.Element, ref: AutosarVariableRef):
+    def setAutosarVariableRef(self, element: ET.Element, key: str, ref: AutosarVariableRef):
         if ref is not None:
-            child_element = ET.SubElement(element, "ACCESSED-VARIABLE")
+            child_element = ET.SubElement(element, key)
             self.setARObjectAttributes(child_element, ref)
             if ref.getAutosarVariableIRef() is not None:
                 child_element = ET.SubElement(child_element, "AUTOSAR-VARIABLE-IREF")
@@ -1067,19 +1067,17 @@ class ARXMLWriter(AbstractARXMLWriter):
     def setVariableAccess(self, element: ET.Element, access: VariableAccess):
         child_element = ET.SubElement(element, "VARIABLE-ACCESS")
         self.setIdentifiable(child_element, access)
-        self.setAutosarVariableRef(child_element, access.getAccessedVariableRef())
-
-    
+        self.setAutosarVariableRef(child_element, "ACCESSED-VARIABLE", access.getAccessedVariableRef())
 
     def setAutosarParameterRef(self, element: ET.Element, key: str, parameter_ref: AutosarParameterRef):
         if parameter_ref is not None:
             child_element = ET.SubElement(element, key)
-            self.setChildElementOptionalRefType(child_element, "LOCAL-PARAMETER-REF", parameter_ref.local_parameter_ref)
+            self.setChildElementOptionalRefType(child_element, "LOCAL-PARAMETER-REF", parameter_ref.getLocalParameterRef())
 
     def writeParameterAccess(self, element: ET.Element, parameter_access: ParameterAccess):
         child_element = ET.SubElement(element, "PARAMETER-ACCESS")
         self.setIdentifiable(child_element, parameter_access)
-        self.setAutosarParameterRef(child_element, "ACCESSED-PARAMETER", parameter_access.accessed_parameter)
+        self.setAutosarParameterRef(child_element, "ACCESSED-PARAMETER", parameter_access.getAccessedParameter())
 
     def writeParameterAccesses(self, element: ET.Element, entity: RunnableEntity):
         parameter_accesses = entity.getParameterAccesses()
@@ -1223,13 +1221,13 @@ class ARXMLWriter(AbstractARXMLWriter):
             self.writeRunnableEntityArguments(child_element, entity)
             self.writeAsynchronousServerCallResultPoint(child_element, entity)
             self.setChildElementOptionalBooleanValue(child_element, "CAN-BE-INVOKED-CONCURRENTLY", entity.getCanBeInvokedConcurrently())
-            self.writeParameterAccesses(child_element, entity)
             self.writeDataReadAccesses(child_element, entity)
             self.writeDataReceivePointByArguments(child_element, entity)
             self.writeDataSendPoints(child_element, entity)
             self.writeDataWriteAccesses(child_element, entity)
             self.writeModeAccessPoints(child_element, entity)
             self.writeModeSwitchPoints(child_element, entity)
+            self.writeParameterAccesses(child_element, entity)
             self.writeReadLocalVariables(child_element, entity)
             self.writeServerCallPoints(child_element, entity)
             self.setChildElementOptionalLiteral(child_element, "SYMBOL", entity.symbol)
@@ -1244,6 +1242,16 @@ class ARXMLWriter(AbstractARXMLWriter):
                     self.writeRunnableEntity(runnables_tag, entity)
                 else:
                     self.notImplemented("Unsupported RunnableEntity <%s>" % type(entity))
+
+    def writeSwcInternalBehaviorArTypedPerInstanceMemories(self, element: ET.Element, behavior: SwcInternalBehavior):
+        prototypes = behavior.getArTypedPerInstanceMemories()
+        if len(prototypes) > 0:
+            child_element = ET.SubElement(element, "AR-TYPED-PER-INSTANCE-MEMORYS")
+            for prototype in prototypes:
+                if isinstance(prototype, VariableDataPrototype):
+                    self.writeVariableDataPrototype(child_element, prototype)
+                else:
+                    self._raiseError("Unsupported ArTypedPerInstanceMemories <%s>" % type(prototype))
                 
     def writeExplicitInterRunnableVariables(self, element: ET.Element, behavior: SwcInternalBehavior):
         prototypes = behavior.getExplicitInterRunnableVariables()
@@ -1267,18 +1275,17 @@ class ARXMLWriter(AbstractARXMLWriter):
                 self.setChildElementOptionalLiteral(child_element, "TYPE", memory.getType())
                 self.setChildElementOptionalLiteral (child_element, "TYPE-DEFINITION", memory.getTypeDefinition())
 
-    def writeParameterDataPrototype(self, element: ET.Element, prototype: ParameterDataPrototype):
+    def setParameterDataPrototype(self, element: ET.Element, prototype: ParameterDataPrototype):
         child_element = ET.SubElement(element, "PARAMETER-DATA-PROTOTYPE")
         self.setIdentifiable(child_element, prototype)
         self.setAutosarDataPrototype(child_element, prototype)
         self.setValueSpecification(child_element, "INIT-VALUE", prototype.getInitValue())
 
-    def writePerInstanceParameters(self, element: ET.Element, behavior: SwcInternalBehavior):
-        prototypes = behavior.getPerInstanceParameters()
-        if len(prototypes) > 0:
-            child_element = ET.SubElement(element, "PER-INSTANCE-PARAMETERS")
-            for prototype in prototypes:
-                self.writeParameterDataPrototype(child_element, prototype)
+    def setParameterDataPrototypes(self, element: ET.Element, key: str, parameters: List[ParameterDataPrototype]):
+        if len(parameters) > 0:
+            child_element = ET.SubElement(element, key)
+            for parameter in parameters:
+                self.setParameterDataPrototype(child_element, parameter)
 
     def writePortDefinedArgumentValues(self, element: ET.Element, argument_values: List[PortDefinedArgumentValue]) :
         if len(argument_values) > 0:
@@ -1323,6 +1330,7 @@ class ARXMLWriter(AbstractARXMLWriter):
     def writeRoleBasedDataAssignment(self, element: ET.Element, assignment: RoleBasedDataAssignment):
         child_element = ET.SubElement(element, "ROLE-BASED-DATA-ASSIGNMENT")
         self.setChildElementOptionalLiteral(child_element, "ROLE", assignment.role)
+        self.setAutosarVariableRef(child_element, "USED-DATA-ELEMENT", assignment.getUsedDataElement())
         self.setAutosarParameterRef(child_element, "USED-PARAMETER-ELEMENT", assignment.getUsedParameterElement())
         self.setChildElementOptionalRefType(child_element, "USED-PIM-REF", assignment.getUsedPimRef())
 
@@ -1351,7 +1359,7 @@ class ARXMLWriter(AbstractARXMLWriter):
                 else:
                     self._raiseError("Unsupported Assigned Data <%s>" % type(data)) 
 
-    def writeNvBlockNeeds(self, element: ET.Element, needs: NvBlockNeeds):
+    def setNvBlockNeeds(self, element: ET.Element, needs: NvBlockNeeds):
         child_element = ET.SubElement(element, "NV-BLOCK-NEEDS")
         self.logger.debug("write NvBlockNeeds %s" % needs.getShortName())
         self.setIdentifiable(child_element, needs)
@@ -1372,22 +1380,23 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.setChildElementOptionalBooleanValue(child_element, "USE-CRC-COMP-MECHANISM", needs.getUseCRCCompMechanism())
         self.setChildElementOptionalBooleanValue(child_element, "WRITE-ONLY-ONCE", needs.getWriteOnlyOnce())
         self.setChildElementOptionalBooleanValue(child_element, "WRITE-VERIFICATION", needs.getWriteVerification())
+        self.setChildElementOptionalPositiveInteger(child_element, "WRITING-FREQUENCY", needs.getWritingFrequency())
         self.setChildElementOptionalLiteral(child_element, "WRITING-PRIORITY", needs.getWritingPriority())
 
-    def writeDiagnosticCommunicationManagerNeeds(self, element: ET.Element, needs: DiagnosticCommunicationManagerNeeds):
+    def setDiagnosticCommunicationManagerNeeds(self, element: ET.Element, needs: DiagnosticCommunicationManagerNeeds):
         child_element = ET.SubElement(element, "DIAGNOSTIC-COMMUNICATION-MANAGER-NEEDS")
         self.logger.debug("write DiagnosticCommunicationManagerNeeds %s" % needs.getShortName())
         self.setIdentifiable(child_element, needs)
         self.setChildElementOptionalLiteral(child_element, "SERVICE-REQUEST-CALLBACK-TYPE", needs.getServiceRequestCallbackType()) 
     
-    def writeDiagnosticRoutineNeeds(self, element: ET.Element, needs: DiagnosticRoutineNeeds):
+    def setDiagnosticRoutineNeeds(self, element: ET.Element, needs: DiagnosticRoutineNeeds):
         child_element = ET.SubElement(element, "DIAGNOSTIC-ROUTINE-NEEDS")
         self.logger.debug("write DiagnosticRoutineNeeds %s" % needs.getShortName())
         self.setIdentifiable(child_element, needs)
         self.setChildElementOptionalLiteral(child_element, "DIAG-ROUTINE-TYPE", needs.getDiagRoutineType())
         self.setChildElementOptionalIntegerValue(child_element, "RID-NUMBER", needs.getRidNumber())
 
-    def writeDiagnosticValueNeeds(self, element: ET.Element, needs: DiagnosticValueNeeds):
+    def setDiagnosticValueNeeds(self, element: ET.Element, needs: DiagnosticValueNeeds):
         child_element = ET.SubElement(element, "DIAGNOSTIC-VALUE-NEEDS")
         self.logger.debug("write DiagnosticValueNeeds %s" % needs.getShortName())
         self.setIdentifiable(child_element, needs)
@@ -1410,21 +1419,27 @@ class ARXMLWriter(AbstractARXMLWriter):
             else:
                 self.notImplemented("Unsupported DiagEventDebounceAlgorithm <%s>" % type(algorithm))
 
-    def writeDiagnosticEventNeeds(self, element: ET.Element, needs: DiagnosticEventNeeds):
+    def setDiagnosticEventNeeds(self, element: ET.Element, needs: DiagnosticEventNeeds):
         child_element = ET.SubElement(element, "DIAGNOSTIC-EVENT-NEEDS")
         self.logger.debug("write DiagnosticEventNeeds %s" % needs.getShortName())
         self.setIdentifiable(child_element, needs)
         self.writeDiagEventDebounceAlgorithm(child_element, needs)
         self.setChildElementOptionalLiteral(child_element, "DTC-KIND", needs.getDtcKind())
         self.setChildElementOptionalIntegerValue(child_element, "UDS-DTC-NUMBER", needs.getUdsDtcNumber())
+
+    def setDiagnosticEventInfoNeeds(self, element: ET.Element, needs: DiagnosticEventInfoNeeds):
+        child_element = ET.SubElement(element, "DIAGNOSTIC-EVENT-INFO-NEEDS")
+        self.logger.debug("write DiagnosticEventNeeds %s" % needs.getShortName())
+        self.setIdentifiable(child_element, needs)
+        self.setChildElementOptionalPositiveInteger(child_element, "UDS-DTC-NUMBER", needs.getUdsDtcNumber())
     
-    def writeCryptoServiceNeeds(self, element: ET.Element, needs: CryptoServiceNeeds):
+    def setCryptoServiceNeeds(self, element: ET.Element, needs: CryptoServiceNeeds):
         child_element = ET.SubElement(element, "CRYPTO-SERVICE-NEEDS")
         self.logger.debug("write CryptoServiceNeeds %s" % needs.getShortName())
         self.setIdentifiable(child_element, needs)
         self.setChildElementOptionalPositiveInteger(child_element, "MAXIMUM-KEY-LENGTH", needs.getMaximumKeyLength())
 
-    def writeEcuStateMgrUserNeeds(self, element: ET.Element, needs: EcuStateMgrUserNeeds):
+    def setEcuStateMgrUserNeeds(self, element: ET.Element, needs: EcuStateMgrUserNeeds):
         child_element = ET.SubElement(element, "ECU-STATE-MGR-USER-NEEDS")
         self.logger.debug("write EcuStateMgrUserNeeds %s" % needs.getShortName())
         self.setIdentifiable(child_element, needs)
@@ -1435,21 +1450,23 @@ class ARXMLWriter(AbstractARXMLWriter):
             child_element = ET.SubElement(element, "SERVICE-NEEDS")
             for need in needs:
                 if isinstance(need, NvBlockNeeds):
-                    self.writeNvBlockNeeds(child_element, need)
+                    self.setNvBlockNeeds(child_element, need)
                 elif isinstance(need, DiagnosticCommunicationManagerNeeds):
-                    self.writeDiagnosticCommunicationManagerNeeds(child_element, need)
+                    self.setDiagnosticCommunicationManagerNeeds(child_element, need)
                 elif isinstance(need, DiagnosticRoutineNeeds):
-                    self.writeDiagnosticRoutineNeeds(child_element, need)
+                    self.setDiagnosticRoutineNeeds(child_element, need)
                 elif isinstance(need, DiagnosticValueNeeds):
-                    self.writeDiagnosticValueNeeds(child_element, need)
+                    self.setDiagnosticValueNeeds(child_element, need)
                 elif isinstance(need, DiagnosticEventNeeds):
-                    self.writeDiagnosticEventNeeds(child_element, need)
+                    self.setDiagnosticEventNeeds(child_element, need)
+                elif isinstance(need, DiagnosticEventInfoNeeds):
+                    self.setDiagnosticEventInfoNeeds(child_element, need)
                 elif isinstance(need, CryptoServiceNeeds):
-                    self.writeCryptoServiceNeeds(child_element, need)
+                    self.setCryptoServiceNeeds(child_element, need)
                 elif isinstance(need, EcuStateMgrUserNeeds):
-                    self.writeEcuStateMgrUserNeeds(child_element, need)
+                    self.setEcuStateMgrUserNeeds(child_element, need)
                 else:
-                    self._raiseError("Unsupported service needs <%s>" % type(need))                  
+                    self.notImplemented("Unsupported service needs <%s>" % type(need))                  
 
     def writeSwcServiceDependency(self, element: ET.Element, dependency: SwcServiceDependency):
         child_element = ET.SubElement(element, "SWC-SERVICE-DEPENDENCY")
@@ -1480,21 +1497,24 @@ class ARXMLWriter(AbstractARXMLWriter):
                     for type_ref in type_refs:
                         self.setChildElementOptionalRefType(data_type_refs_tag, "DATA-TYPE-REF", type_ref)
 
+
     def writeSwcInternalBehavior(self, element: ET.Element, behavior: SwcInternalBehavior):
         self.logger.debug("writeSwInternalBehavior %s" % behavior.getShortName())
 
         child_element = ET.SubElement(element, "SWC-INTERNAL-BEHAVIOR")
         self.writeInternalBehavior(child_element, behavior)
+        self.writeSwcInternalBehaviorArTypedPerInstanceMemories(child_element, behavior)
         self.writeRTEEvents(child_element, behavior)
         self.writeExplicitInterRunnableVariables(child_element, behavior)
-        self.setChildElementOptionalLiteral(child_element, "HANDLE-TERMINATION-AND-RESTART", behavior.handleTerminationAndRestart)
+        self.setChildElementOptionalLiteral(child_element, "HANDLE-TERMINATION-AND-RESTART", behavior.getHandleTerminationAndRestart())
         self.setIncludedDataTypeSets(child_element, behavior.getIncludedDataTypeSets())
         self.writePerInstanceMemories(child_element, behavior)
-        self.writePerInstanceParameters(child_element, behavior)
+        self.setParameterDataPrototypes(child_element, "PER-INSTANCE-PARAMETERS", behavior.getPerInstanceParameters())
         self.writePortAPIOptions(child_element, behavior)
         self.writeSwcInternalBehaviorRunnableEntities(child_element, behavior)
         self.writeSwcInternalBehaviorServiceDependencies(child_element, behavior)
-        self.setChildElementOptionalBooleanValue(child_element, "SUPPORTS-MULTIPLE-INSTANTIATION", behavior.supportsMultipleInstantiation)
+        self.setParameterDataPrototypes(child_element, "SHARED-PARAMETERS", behavior.getSharedParameters())
+        self.setChildElementOptionalBooleanValue(child_element, "SUPPORTS-MULTIPLE-INSTANTIATION", behavior.getSupportsMultipleInstantiation())
 
     def writeAtomicSwComponentTypeInternalBehaviors(self, element: ET.Element, behavior: InternalBehavior):
         if behavior is not None:
@@ -1909,7 +1929,7 @@ class ARXMLWriter(AbstractARXMLWriter):
                 else:
                     self._raiseError("Unsupported Runnable Mapping <%s>" % type(mapping))
 
-    def setSwcBswMapping(self, element: ET.Element, mapping: SwcBswMapping):
+    def writeSwcBswMapping(self, element: ET.Element, mapping: SwcBswMapping):
         self.logger.debug("writeBswModuleDescription %s" % mapping.getShortName())
         child_element = ET.SubElement(element, "SWC-BSW-MAPPING")
         self.setIdentifiable(child_element, mapping)
@@ -2031,18 +2051,11 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.setChildElementOptionalBooleanValue(element, "IS-SERVICE", port_interface.isService)
         self.setChildElementOptionalLiteral(element, "SERVICE-KIND", port_interface.serviceKind)
 
-    def writeParameterInterfaceParameters(self, element: ET.Element, param_interface: ParameterInterface):
-        parameters = param_interface.getParameters()
-        if len(parameters) > 0:
-            child_element = ET.SubElement(element, "PARAMETERS")
-            for prototype in parameters:
-                self.writeParameterDataPrototype(child_element, prototype)
-
     def writeParameterInterface(self, element: ET.Element, param_interface: ParameterInterface):
         self.logger.debug("Write ParameterInterface %s" % param_interface.getShortName())
         child_element = ET.SubElement(element, "PARAMETER-INTERFACE")
         self.setPortInterface(child_element, param_interface)
-        self.writeParameterInterfaceParameters(child_element, param_interface)
+        self.setParameterDataPrototypes(child_element, "PARAMETERS", param_interface.getParameters())
 
     def writeClientServerInterface(self, element: ET.Element, cs_interface: ClientServerInterface):
         self.logger.debug("writeClientServerInterface %s" % cs_interface.getShortName())
@@ -2492,27 +2505,129 @@ class ARXMLWriter(AbstractARXMLWriter):
                 else:
                     self.notImplemented("Unsupported PduTriggering <%s>" % type(triggering))
 
-    def writeCanPhysicalChannel(self, element: ET.Element, channel: CanPhysicalChannel):
-        self.logger.debug("CanPhysicalChannel %s" % channel.getShortName())
+    def setCanPhysicalChannel(self, element: ET.Element, channel: CanPhysicalChannel):
+        self.logger.debug("Set CanPhysicalChannel %s" % channel.getShortName())
         child_element = ET.SubElement(element, "CAN-PHYSICAL-CHANNEL")
         self.setIdentifiable(child_element, channel)
         self.writePhysicalChannel(child_element, channel)
 
     def writeLinPhysicalChannel(self, element: ET.Element, channel: LinPhysicalChannel):
-        self.logger.debug("LinPhysicalChannel %s" % channel.getShortName())
+        self.logger.debug("Set LinPhysicalChannel %s" % channel.getShortName())
         child_element = ET.SubElement(element, "LIN-PHYSICAL-CHANNEL")
         self.setIdentifiable(child_element, channel)
         self.writePhysicalChannel(child_element, channel)
 
+    def setIpv6Configuration(self, element: ET.Element, configuration: Ipv6Configuration):
+        if configuration is not None:
+            child_element = ET.SubElement(element, "IPV-6-CONFIGURATION")
+            self.setChildElementOptionalPositiveInteger(child_element, "ASSIGNMENT-PRIORITY", configuration.getAssignmentPriority())
+            self.setChildElementOptionalLiteral(child_element, "DEFAULT-ROUTER", configuration.getDefaultRouter())
+            self.setChildElementOptionalBooleanValue(child_element, "ENABLE-ANYCAST", configuration.getEnableAnycast())
+            self.setChildElementOptionalPositiveInteger(child_element, "HOP-COUNT", configuration.getHopCount())
+            self.setChildElementOptionalPositiveInteger(child_element, "IP-ADDRESS-PREFIX-LENGTH", configuration.getIpAddressPrefixLength())
+            self.setChildElementOptionalLiteral(child_element, "IPV-6-ADDRESS", configuration.getIpv6Address())
+            self.setChildElementOptionalLiteral(child_element, "IPV-6-ADDRESS-SOURCE", configuration.getIpv6AddressSource())
+
+    def writeNetworkEndPointNetworkEndPointAddresses(self, element: ET.Element, addresses: List[NetworkEndpointAddress]):
+        if len(addresses) > 0:
+            child_element = ET.SubElement(element, "NETWORK-ENDPOINT-ADDRESSES")
+            for address in addresses:
+                if isinstance(address, Ipv6Configuration):
+                    self.setIpv6Configuration(child_element, address)
+                else:
+                    self.notImplemented("Unsupported Network EndPoint Address <%s>" % type(address))
+
+    def writeNetworkEndPoint(self, element: ET.Element, end_point: NetworkEndpoint):
+        self.logger.debug("Set NetworkEndpoint %s" % end_point.getShortName())
+        child_element = ET.SubElement(element, "NETWORK-ENDPOINT")
+        self.setIdentifiable(child_element, end_point)
+        self.writeNetworkEndPointNetworkEndPointAddresses(child_element, end_point.getNetworkEndpointAddresses())
+        self.setChildElementOptionalPositiveInteger(child_element, "PRIORITY", end_point.getPriority())
+
+    def writeEthernetPhysicalChannelNetworkEndPoints(self, element: ET.Element, end_points: List[NetworkEndpoint]):
+        if len(end_points) > 0:
+            child_element = ET.SubElement(element, "NETWORK-ENDPOINTS")
+            for end_point in end_points:
+                self.writeNetworkEndPoint(child_element, end_point)
+
+    def setSocketConnectionIpduIdentifier(self, element: ET.Element,identifier: SocketConnectionIpduIdentifier):
+        if identifier is not None:
+            child_element = ET.SubElement(element, "SOCKET-CONNECTION-IPDU-IDENTIFIER")
+            self.setChildElementOptionalPositiveInteger(child_element, "HEADER-ID", identifier.getHeaderId())
+            self.setChildElementOptionalLiteral(child_element, "PDU-COLLECTION-SEMANTICS", identifier.getPduCollectionSemantics())
+            self.setChildElementOptionalLiteral(child_element, "PDU-COLLECTION-TRIGGER", identifier.getPduCollectionTrigger())
+            self.setChildElementOptionalRefType(child_element, "PDU-REF", identifier.getPduRef())
+            self.setChildElementOptionalRefType(child_element, "PDU-TRIGGERING-REF", identifier.getPduTriggeringRef())
+
+    def setSocketConnectionPdus(self, element: ET.Element, key: str, pdus: List[SocketConnectionIpduIdentifier]):
+        if len(pdus) > 0:
+            child_element = ET.SubElement(element, key)
+            for pdu in pdus:
+                if isinstance(pdu, SocketConnectionIpduIdentifier):
+                    self.setSocketConnectionIpduIdentifier(child_element, pdu)
+                else:
+                    self.notImplemented("Unsupported Pdu <%s>" % type(pdu))
+
+    def setSocketConnection(self, element: ET.Element, connection: SocketConnection):
+        if connection is not None:
+            child_element = ET.SubElement(element, "SOCKET-CONNECTION")
+            self.setChildElementOptionalRefType(child_element, "CLIENT-PORT-REF", connection.getClientPortRef())
+            self.setSocketConnectionPdus(child_element, "PDUS", connection.getPdus())
+            self.setChildElementOptionalPositiveInteger(child_element, "PDU-COLLECTION-MAX-BUFFER-SIZE", connection.getPduCollectionMaxBufferSize())
+            self.setChildElementOptionalTimeValue(child_element, "PDU-COLLECTION-TIMEOUT", connection.getPduCollectionTimeout())
+            self.setChildElementOptionalLiteral(child_element, "SHORT-LABEL", connection.getShortLabel())
+
+    def writeSocketConnectionBundleConnections(self, element: ET.Element, bundle: SocketConnectionBundle):
+        connections = bundle.getBundledConnections()
+        if len(connections) > 0:
+            child_element = ET.SubElement(element, "BUNDLED-CONNECTIONS")
+            for connection in connections:
+                if isinstance(connection, SocketConnection):
+                    self.setSocketConnection(child_element, connection)
+                else:
+                    self.notImplemented("Unsupported Bundled Connection <%s>" % type(connection))
+
+    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.writeSocketConnectionBundleConnections(child_element, bundle)
+            self.setChildElementOptionalRefType(child_element, "SERVER-PORT-REF", bundle.getServerPortRef())
+
+    def writeSoAdConfigConnectionBundles(self, element: ET.Element, config: SoAdConfig):
+        bundles = config.getConnectionBundles()
+        if len(bundles) > 0:
+            child_element = ET.SubElement(element, "CONNECTION-BUNDLES")
+            for bundle in bundles:
+                if isinstance(bundle, SocketConnectionBundle):
+                    self.writeSocketConnectionBundle(child_element, bundle)
+                else:
+                    self.notImplemented("Unsupported Connection Bundle <%s>" % type(bundle))
+
+    def setSoAdConfig(self, element: ET.Element, key: str, config: SoAdConfig):
+        if config is not None:
+            child_element = ET.SubElement(element, key)
+            self.writeSoAdConfigConnectionBundles(child_element, config)
+
+    def setEthernetPhysicalChannel(self, element: ET.Element, channel: EthernetPhysicalChannel):
+        self.logger.debug("Set EthernetPhysicalChannel %s" % channel.getShortName())
+        child_element = ET.SubElement(element, "ETHERNET-PHYSICAL-CHANNEL")
+        self.setIdentifiable(child_element, channel)
+        self.writePhysicalChannel(child_element, channel)
+        self.writeEthernetPhysicalChannelNetworkEndPoints(child_element, channel.getNetworkEndpoints())
+        self.setSoAdConfig(child_element, "SO-AD-CONFIG", channel.getSoAdConfig())
+
     def writeCommunicationClusterPhysicalChannels(self, element: ET.Element, cluster: CommunicationCluster):
         channels = cluster.getPhysicalChannels()
         if len(channels) > 0:
             child_element = ET.SubElement(element, "PHYSICAL-CHANNELS")
             for channel in channels:
                 if isinstance(channel, CanPhysicalChannel):
-                    self.writeCanPhysicalChannel(child_element, channel)
+                    self.setCanPhysicalChannel(child_element, channel)
                 elif isinstance(channel, LinPhysicalChannel):
                     self.writeLinPhysicalChannel(child_element, channel)
+                elif isinstance(channel, EthernetPhysicalChannel):
+                    self.setEthernetPhysicalChannel(child_element, channel)
                 else:
                     self.notImplemented("Unsupported Physical Channel <%s>" % type(channel))
 
@@ -2544,6 +2659,15 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.writeCommunicationCluster(child_element, cluster)
         self.readAbstractCanCluster(child_element, cluster)
 
+    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)
+
+        child_element = ET.SubElement(child_element, "ETHERNET-CLUSTER-VARIANTS")
+        child_element = ET.SubElement(child_element, "ETHERNET-CLUSTER-CONDITIONAL")
+        self.writeCommunicationCluster(child_element, cluster)
+
     def writeCanFrame(self, element: ET.Element, frame: CanFrame):
         self.logger.debug("Write CanFrame %s" % frame.getShortName())
         child_element = ET.SubElement(element, "CAN-FRAME")
@@ -2580,10 +2704,14 @@ class ARXMLWriter(AbstractARXMLWriter):
                 else:
                     self._raiseError("Unsupported CommConnectorPort <%s>" % type(port))      
 
-    def writeCanCommunicationController(self, element: ET.Element, controller: CanCommunicationController):
+    def setCanCommunicationController(self, element: ET.Element, controller: CanCommunicationController):
         self.logger.debug("Write CanCommunicationController %s" % controller.getShortName())
         self.setIdentifiable(element, controller)
 
+    def setEthernetCommunicationController(self, element: ET.Element, controller: EthernetCommunicationController):
+        self.logger.debug("Write EthernetCommunicationController %s" % controller.getShortName())
+        self.setIdentifiable(element, controller)
+
     def writeEcuInstanceCommControllers(self, element: ET.Element, instance: EcuInstance):
         controllers = instance.getCommControllers()
         if len(controllers) > 0:
@@ -2591,19 +2719,25 @@ class ARXMLWriter(AbstractARXMLWriter):
             for controller in controllers:
                 if isinstance(controller, CanCommunicationController):
                     child_element = ET.SubElement(controllers_tag, "CAN-COMMUNICATION-CONTROLLER")
-                    self.writeCanCommunicationController(child_element, controller)
+                    self.setCanCommunicationController(child_element, controller)
+                elif isinstance(controller, EthernetCommunicationController):
+                    child_element = ET.SubElement(controllers_tag, "ETHERNET-COMMUNICATION-CONTROLLER")
+                    self.setEthernetCommunicationController(child_element, controller)
                 else:
-                    self._raiseError("Unsupported Communication Controller <%s>" % type(controller))
+                    self.notImplemented("Unsupported Communication Controller <%s>" % type(controller))
 
     def writeCommunicationConnector(self, element: ET.Element, connector: CommunicationConnector):
         self.setIdentifiable(element, connector)
         self.setChildElementOptionalRefType(element, "COMM-CONTROLLER-REF", connector.getCommControllerRef())
         self.writeCommunicationConnectorEcuCommPortInstances(element, connector)
 
-
     def writeCanCommunicationConnector(self, element: ET.Element, connector: CanCommunicationConnector):
         self.logger.debug("Write CanCommunicationConnector %s" % connector.getShortName())
-        self.writeCommunicationConnector(element, connector)                
+        self.writeCommunicationConnector(element, connector)
+
+    def writeEthernetCommunicationConnector(self, element: ET.Element, connector: EthernetCommunicationConnector):
+        self.logger.debug("Write EthernetCommunicationConnector %s" % connector.getShortName())
+        self.writeCommunicationConnector(element, connector)
 
     def writeEcuInstanceConnectors(self, element: ET.Element, instance: EcuInstance):
         connectors = instance.getConnectors()
@@ -2613,6 +2747,9 @@ class ARXMLWriter(AbstractARXMLWriter):
                 if isinstance(connector, CanCommunicationConnector):
                     child_element = ET.SubElement(connectors_tag, "CAN-COMMUNICATION-CONNECTOR")
                     self.writeCanCommunicationConnector(child_element, connector)
+                elif isinstance(connector, EthernetCommunicationConnector):
+                    child_element = ET.SubElement(connectors_tag, "ETHERNET-COMMUNICATION-CONNECTOR")
+                    self.writeEthernetCommunicationConnector(child_element, connector)
                 else:
                     self._raiseError("Unsupported Communication connector <%s>" % type(connector))
 
@@ -2726,7 +2863,7 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.writeRootSwCompositionPrototype(child_element, system)
         self.setChildElementOptionalRevisionLabelString(child_element, "SYSTEM-VERSION", system.getSystemVersion())
 
-    def setPhysicalDimension(self, element: ET.Element, dimension: PhysicalDimension):
+    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)
@@ -2751,7 +2888,7 @@ class ARXMLWriter(AbstractARXMLWriter):
                 else:
                     self.notImplemented("Unsupported Flat Map Instances <%s>" % type(instance))
 
-    def setFlatMap(self, element: ET.Element, map: FlatMap):
+    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)
@@ -2784,7 +2921,7 @@ class ARXMLWriter(AbstractARXMLWriter):
                 else:
                     self.notImplemented("Unsupported PortInterfaceMapping <%s>" % type(mapping))
 
-    def setPortInterfaceMappingSet(self, element: ET.Element, mapping_set: PortInterfaceMappingSet):
+    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)
@@ -2810,7 +2947,8 @@ class ARXMLWriter(AbstractARXMLWriter):
         child_element = ET.SubElement(element, "I-SIGNAL")
         self.setIdentifiable(child_element, signal)
         self.setChildElementOptionalLiteral(child_element, "DATA-TYPE-POLICY", signal.getDataTypePolicy())
-        self.setValueSpecification(element, "INIT-VALUE", signal.getInitValue())
+        self.setChildElementOptionalLiteral(child_element, "I-SIGNAL-TYPE", signal.getISignalType())
+        self.setValueSpecification(child_element, "INIT-VALUE", signal.getInitValue())
         self.setChildElementOptionalNumericalValue(child_element, "LENGTH", signal.getLength())
         self.setSwDataDefProps(child_element, "NETWORK-REPRESENTATION-PROPS", signal.getNetworkRepresentationProps())
         self.setChildElementOptionalRefType(child_element, "SYSTEM-SIGNAL-REF", signal.getSystemSignalRef())
@@ -2943,7 +3081,7 @@ class ARXMLWriter(AbstractARXMLWriter):
         self.setChildElementOptionalRefType(child_element, "SYSTEM-SIGNAL-GROUP-REF", group.getSystemSignalGroupRef())
 
     def writeISignalIPduGroup(self, element: ET.Element, group: ISignalIPduGroup):
-        self.logger.debug("ISignalIPduGroup %s" % group.getShortName())
+        self.logger.debug("Set ISignalIPduGroup %s" % group.getShortName())
         child_element = ET.SubElement(element, "I-SIGNAL-I-PDU-GROUP")
         self.setIdentifiable(child_element, group)
         self.setChildElementOptionalLiteral(child_element, "COMMUNICATION-DIRECTION", group.getCommunicationDirection())
@@ -2965,8 +3103,7 @@ class ARXMLWriter(AbstractARXMLWriter):
         child_element = ET.SubElement(element, "SYSTEM-SIGNAL")
         self.setIdentifiable(child_element, signal)
         self.setChildElementOptionalBooleanValue(child_element, "DYNAMIC-LENGTH", signal.getDynamicLength())
-
-    
+        self.setSwDataDefProps(child_element, "PHYSICAL-PROPS", signal.getPhysicalProps())
 
     def writeGenericEthernetFrame(self, element: ET.Element, signal: GenericEthernetFrame):
         self.logger.debug("Write GenericEthernetFrame %s" % signal.getShortName())
@@ -3016,11 +3153,22 @@ class ARXMLWriter(AbstractARXMLWriter):
             self.setChildElementOptionalIntegerValue(child_element, "NUMBER-OF-REPETITIONS", timing.getNumberOfRepetitions())
             self.setTimeRangeType(child_element, "REPETITION-PERIOD", timing.getRepetitionPeriod())
 
+    def setTimeRangeType(self, element: ET.Element, key: str, time_range: TimeRangeType):
+        if time_range is not None:
+            child_element = ET.SubElement(element, key)
+            self.setChildElementOptionalTimeValue(child_element, "VALUE", time_range.getValue())
+    
+    def setCyclicTiming(self, element: ET.Element, key: str, timing: CyclicTiming):
+        if timing is not None:
+            child_element = ET.SubElement(element, key)
+            self.setTimeRangeType(child_element, "TIME-OFFSET", timing.getTimeOffset())
+            self.setTimeRangeType(child_element, "TIME-PERIOD", timing.getTimePeriod())
+
     def setTransmissionModeTiming(self, element: ET.Element, key: str, timing: TransmissionModeTiming):
         if timing is not None:
             self.logger.debug("Set TransmissionModeTiming of <%s>" % key)
             child_element = ET.SubElement(element, key)
-            #timing.getCyclicTiming(child_element, "")
+            self.setCyclicTiming(child_element, "CYCLIC-TIMING", timing.getCyclicTiming())
             self.setEventControlledTiming(child_element, "EVENT-CONTROLLED-TIMING", timing.getEventControlledTiming())
 
     def setTransmissionModeDeclaration(self, element: ET.Element, key: str, decl : TransmissionModeDeclaration):
@@ -3033,6 +3181,7 @@ class ARXMLWriter(AbstractARXMLWriter):
         if timing is not None:
             spec_tag = ET.SubElement(element, "I-PDU-TIMING-SPECIFICATIONS")
             child_element = ET.SubElement(spec_tag, "I-PDU-TIMING")
+            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):
@@ -3052,13 +3201,13 @@ class ARXMLWriter(AbstractARXMLWriter):
         elif isinstance(ar_element, CompositionSwComponentType):
             self.writeCompositionSwComponentType(element, ar_element)
         elif isinstance(ar_element, ApplicationPrimitiveDataType):
-            self.setApplicationPrimitiveDataType(element, ar_element)
+            self.writeApplicationPrimitiveDataType(element, ar_element)
         elif isinstance(ar_element, ApplicationRecordDataType):
-            self.setApplicationRecordDataType(element, ar_element)
+            self.writeApplicationRecordDataType(element, ar_element)
         elif isinstance(ar_element, SwBaseType):
-            self.setSwBaseType(element, ar_element)
+            self.writeSwBaseType(element, ar_element)
         elif isinstance(ar_element, CompuMethod):
-            self.setCompuMethod(element, ar_element)
+            self.writeCompuMethod(element, ar_element)
         elif isinstance(ar_element, ConstantSpecification):
             self.writeConstantSpecification(element, ar_element)
         elif isinstance(ar_element, DataConstr):
@@ -3074,7 +3223,7 @@ class ARXMLWriter(AbstractARXMLWriter):
         elif isinstance(ar_element, BswModuleEntry):
             self.writeBswModuleEntry(element, ar_element)
         elif isinstance(ar_element, SwcBswMapping):
-            self.setSwcBswMapping(element, ar_element)
+            self.writeSwcBswMapping(element, ar_element)
         elif isinstance(ar_element, BswImplementation):
             self.writeBswImplementation(element, ar_element)
         elif isinstance(ar_element, ImplementationDataType):
@@ -3142,11 +3291,15 @@ class ARXMLWriter(AbstractARXMLWriter):
         elif isinstance(ar_element, LifeCycleInfoSet):
             self.writeLifeCycleInfoSet(element, ar_element)
         elif isinstance(ar_element, PhysicalDimension):
-            self.setPhysicalDimension(element, ar_element)
+            self.writePhysicalDimension(element, ar_element)
         elif isinstance(ar_element, FlatMap):
-            self.setFlatMap(element, ar_element)
+            self.writeFlatMap(element, ar_element)
         elif isinstance(ar_element, PortInterfaceMappingSet):
-            self.setPortInterfaceMappingSet(element, ar_element)
+            self.writePortInterfaceMappingSet(element, ar_element)
+        elif isinstance(ar_element, EthernetCluster):
+            self.writeEthernetCluster(element, ar_element)
+        elif isinstance(ar_element, ISignalIPduGroup):
+            self.writeISignalIPduGroup(element, ar_element)
         else:
             self.notImplemented("Unsupported Elements of ARPackage <%s>" % type(ar_element))