armodel 1.4.3__py3-none-any.whl → 1.5.0__py3-none-any.whl

armodel/cli/arxml_dump_cli.py

@@ -32,7 +32,7 @@ def show_port(indent:int, port_prototype: PortPrototype):
         raise ValueError("Unsupported Port prototype")
 
 def show_type(indent: int, data_type: ImplementationDataType):
-    print("%s-Implementation Type: %s (%s)" % (" " * indent, data_type.short_name, data_type.parent.full_name))
+    print("%s-Implementation Type: %s (%s)" % (" " * indent, data_type.short_name, data_type._parent.full_name))
     print("%s                    : %s" % (" " * indent, data_type.category))
     if (data_type.sw_data_def_props != None):
         if (data_type.sw_data_def_props.baseTypeRef != None):

armodel/models/ar_package.py

@@ -1,5 +1,14 @@
 from typing import Dict, List
 
+from armodel.models.fibex.can_communication import CanFrame
+from armodel.models.fibex.fibex_4_multiplatform import Gateway
+
+from .system_template.transport_protocols import CanTpConfig
+from .system_template.network_management import NmConfig
+from .fibex.fibex_core import DcmIPdu, ISignal, NPdu, NmPdu
+from .fibex.lin_communication import LinUnconditionalFrame
+from .fibex.lin_topology import LinCluster
+from .timing import SwcTiming
 from .data_dictionary import SwAddrMethod
 from .record_layout import SwRecordLayout
 from .end_to_end_protection import EndToEndProtectionSet
@@ -153,8 +162,8 @@ class ARPackage(Identifiable, CollectableElement):
 
     def createSwcBswMapping(self, short_name: str) -> SwcBswMapping:
         if (short_name not in self.elements):
-            sw_component = SwcBswMapping(self, short_name)
-            self.elements[short_name] = sw_component
+            mapping = SwcBswMapping(self, short_name)
+            self.elements[short_name] = mapping
         return self.elements[short_name]
     
     def createConstantSpecification(self, short_name: str) -> ConstantSpecification:
@@ -165,14 +174,14 @@ class ARPackage(Identifiable, CollectableElement):
     
     def createDataConstr(self, short_name: str) -> DataConstr:
         if (short_name not in self.elements):
-            spec = DataConstr(self, short_name)
-            self.elements[short_name] = spec
+            constr = DataConstr(self, short_name)
+            self.elements[short_name] = constr
         return self.elements[short_name]
     
     def createUnit(self, short_name: str) -> Unit:
         if (short_name not in self.elements):
-            spec = Unit(self, short_name)
-            self.elements[short_name] = spec
+            unit = Unit(self, short_name)
+            self.elements[short_name] = unit
         return self.elements[short_name]
     
     def createEndToEndProtectionSet(self, short_name: str) -> EndToEndProtectionSet:
@@ -183,48 +192,114 @@ class ARPackage(Identifiable, CollectableElement):
     
     def createApplicationArrayDataType(self, short_name: str) -> ApplicationArrayDataType:
         if (short_name not in self.elements):
-            spec = ApplicationArrayDataType(self, short_name)
-            self.elements[short_name] = spec
+            data_type = ApplicationArrayDataType(self, short_name)
+            self.elements[short_name] = data_type
         return self.elements[short_name]
     
     def createSwRecordLayout(self, short_name: str) -> SwRecordLayout:
         if (short_name not in self.elements):
-            spec = SwRecordLayout(self, short_name)
-            self.elements[short_name] = spec
+            layout = SwRecordLayout(self, short_name)
+            self.elements[short_name] = layout
         return self.elements[short_name]
     
     def createSwAddrMethod(self, short_name: str) -> SwAddrMethod:
         if (short_name not in self.elements):
-            spec = SwAddrMethod(self, short_name)
-            self.elements[short_name] = spec
+            method = SwAddrMethod(self, short_name)
+            self.elements[short_name] = method
         return self.elements[short_name]
     
     def createTriggerInterface(self, short_name: str) -> TriggerInterface:
         if (short_name not in self.elements):
-            spec = TriggerInterface(self, short_name)
-            self.elements[short_name] = spec
+            trigger_interface = TriggerInterface(self, short_name)
+            self.elements[short_name] = trigger_interface
         return self.elements[short_name]
     
     def createModeDeclarationGroup(self, short_name: str) -> ModeDeclarationGroup:
         if (short_name not in self.elements):
-            spec = ModeDeclarationGroup(self, short_name)
-            self.elements[short_name] = spec
+            group = ModeDeclarationGroup(self, short_name)
+            self.elements[short_name] = group
         return self.elements[short_name]
     
     def createModeSwitchInterface(self, short_name: str) -> ModeSwitchInterface:
         if (short_name not in self.elements):
-            spec = ModeSwitchInterface(self, short_name)
-            self.elements[short_name] = spec
+            switch_interface = ModeSwitchInterface(self, short_name)
+            self.elements[short_name] = switch_interface
         return self.elements[short_name]
-
+    
+    def createSwcTiming(self, short_name: str) -> SwcTiming:
+        if (short_name not in self.elements):
+            timing = SwcTiming(self, short_name)
+            self.elements[short_name] = timing
+        return self.elements[short_name]
+    
+    def createLinCluster(self, short_name: str) -> LinCluster:
+        if (short_name not in self.elements):
+            cluster = LinCluster(self, short_name)
+            self.elements[short_name] = cluster
+        return self.elements[short_name]
+    
+    def createLinUnconditionalFrame(self, short_name: str) -> LinUnconditionalFrame:
+        if (short_name not in self.elements):
+            frame = LinUnconditionalFrame(self, short_name)
+            self.elements[short_name] = frame
+        return self.elements[short_name]
+    
+    def createNmPdu(self, short_name: str) -> NmPdu:
+        if (short_name not in self.elements):
+            pdu = NmPdu(self, short_name)
+            self.elements[short_name] = pdu
+        return self.elements[short_name]
+    
+    def createNPdu(self, short_name: str) -> NPdu:
+        if (short_name not in self.elements):
+            pdu = NPdu(self, short_name)
+            self.elements[short_name] = pdu
+        return self.elements[short_name]
+    
+    def createDcmIPdu(self, short_name: str) -> DcmIPdu:
+        if (short_name not in self.elements):
+            pdu = DcmIPdu(self, short_name)
+            self.elements[short_name] = pdu
+        return self.elements[short_name]
+    
+    def createNmConfig(self, short_name: str) -> NmConfig:
+        if (short_name not in self.elements):
+            config = NmConfig(self, short_name)
+            self.elements[short_name] = config
+        return self.elements[short_name]
+    
+    def createCanTpConfig(self, short_name: str) -> CanTpConfig:
+        if (short_name not in self.elements):
+            config = CanTpConfig(self, short_name)
+            self.elements[short_name] = config
+        return self.elements[short_name]
+    
+    def createCanFrame(self, short_name: str) -> CanFrame:
+        if (short_name not in self.elements):
+            frame = CanFrame(self, short_name)
+            self.elements[short_name] = frame
+        return self.elements[short_name]
+    
+    def createGateway(self, short_name: str) -> Gateway:
+        if (short_name not in self.elements):
+            gateway = Gateway(self, short_name)
+            self.elements[short_name] = gateway
+        return self.elements[short_name]
+    
+    def createISignal(self, short_name: str) -> ISignal:
+        if (short_name not in self.elements):
+            signal = ISignal(self, short_name)
+            self.elements[short_name] = signal
+        return self.elements[short_name]
+    
     def getApplicationPrimitiveDataTypes(self) -> List[ApplicationPrimitiveDataType]:
-        return list(filter(lambda a: isinstance(a, ApplicationPrimitiveDataType), self.elements.values()))
+        return list(sorted(filter(lambda a: isinstance(a, ApplicationPrimitiveDataType), self.elements.values()), key= lambda o:o.short_name))
     
     def getApplicationDataType(self) -> List[ApplicationDataType]:
         return list(sorted(filter(lambda a: isinstance(a, ApplicationDataType), self.elements.values()), key= lambda o:o.short_name))
 
     def getImplementationDataTypes(self) -> List[ImplementationDataType]:
-        return list(filter(lambda a: isinstance(a, ImplementationDataType), self.elements.values()))
+        return list(sorted(filter(lambda a: isinstance(a, ImplementationDataType), self.elements.values()), key= lambda o:o.short_name))
 
     def getSwBaseTypes(self) -> List[SwBaseType]:
         return list(filter(lambda a: isinstance(a, SwBaseType), self.elements.values()))
@@ -300,8 +375,41 @@ class ARPackage(Identifiable, CollectableElement):
     
     def getModeSwitchInterfaces(self) -> List[ModeSwitchInterface]:
         return list(sorted(filter(lambda a : isinstance(a, ModeSwitchInterface), self.elements.values()), key = lambda a: a.short_name))
-
-class AUTOSAR (CollectableElement):
+    
+    def getSwcTimings(self) -> List[SwcTiming]:
+        return list(sorted(filter(lambda a : isinstance(a, SwcTiming), self.elements.values()), key = lambda a: a.short_name))
+    
+    def getLinClusters(self) -> List[LinCluster]:
+        return list(sorted(filter(lambda a : isinstance(a, LinCluster), self.elements.values()), key = lambda a: a.short_name))
+    
+    def getLinUnconditionalFrames(self) -> List[LinUnconditionalFrame]:
+        return list(sorted(filter(lambda a : isinstance(a, LinUnconditionalFrame), self.elements.values()), key = lambda a: a.short_name))
+    
+    def getNmPdus(self) -> List[NmPdu]:
+        return list(sorted(filter(lambda a : isinstance(a, NmPdu), self.elements.values()), key = lambda a: a.short_name))
+    
+    def getNPdus(self) -> List[NPdu]:
+        return list(sorted(filter(lambda a : isinstance(a, NPdu), self.elements.values()), key = lambda a: a.short_name))
+    
+    def getDcmIPdus(self) -> List[DcmIPdu]:
+        return list(sorted(filter(lambda a : isinstance(a, DcmIPdu), self.elements.values()), key = lambda a: a.short_name))
+    
+    def getNmConfigs(self) -> List[NmConfig]:
+        return list(sorted(filter(lambda a : isinstance(a, NmConfig), self.elements.values()), key = lambda a: a.short_name))
+    
+    def getCanTpConfigs(self) -> List[CanTpConfig]:
+        return list(sorted(filter(lambda a : isinstance(a, CanTpConfig), self.elements.values()), key = lambda a: a.short_name))
+    
+    def getCanFrames(self) -> List[CanFrame]:
+        return list(sorted(filter(lambda a : isinstance(a, CanFrame), self.elements.values()), key = lambda a: a.short_name))
+    
+    def getGateways(self) -> List[Gateway]:
+        return list(sorted(filter(lambda a : isinstance(a, Gateway), self.elements.values()), key = lambda a: a.short_name))
+    
+    def getISignals(self) -> List[ISignal]:
+        return list(sorted(filter(lambda a : isinstance(a, ISignal), self.elements.values()), key = lambda a: a.short_name))
+    
+class AUTOSAR (CollectableElement):        
     __instance = None
 
     @staticmethod

armodel/models/ar_ref.py

@@ -150,8 +150,31 @@ class VariableDataPrototypeInSystemInstanceRef(AtpInstanceRef):
     def __init__(self):
         super().__init__()
 
-        self.baseRef = None                                        # type: RefType
-        self.contextComponentRef = []                              # type: List[RefType]
-        self.contextCompositionRef = None                          # type: RefType
-        self.contextPortRef = None                                 # type: RefType
-        self.targetDataPrototypeRef = None                         # type: RefType 
+        self.base_ref = None                                        # type: RefType
+        self.context_component_refs = []                            # type: List[RefType]
+        self.context_composition_ref = None                         # type: RefType
+        self.context_port_ref = None                                # type: RefType
+        self.target_data_prototype_ref = None                       # type: RefType 
+
+class RModeGroupInAtomicSWCInstanceRef(AtpInstanceRef):
+    def __init__(self):
+        super().__init__()
+
+        self.context_r_port = None                                  # type: RefType
+        self.target_mode_group = None                               # type: RefType
+
+    @property
+    def contextRPort(self) -> RefType:
+        return self.context_r_port
+    
+    @contextRPort.setter
+    def contextRPort(self, value: RefType):
+        self.context_r_port = value
+
+    @property
+    def targetModeGroup(self) -> RefType:
+        return self.target_mode_group
+    
+    @targetModeGroup.setter
+    def targetModeGroup(self, value: RefType):
+        self.target_mode_group = value

armodel/models/bsw_module_template.py

@@ -1,8 +1,10 @@
 from abc import ABCMeta
 from typing import Dict, List
+
+from .internal_behavior import IncludedDataTypeSet, InternalBehavior
 from .general_structure import AtpStructureElement, ARObject, ARElement
 from .ar_object import ARBoolean, ARFloat, ARLiteral, ARNumerical, ARPositiveInteger
-from .common_structure import ExecutableEntity, ModeDeclarationGroupPrototype, InternalBehavior, Identifiable
+from .common_structure import ExecutableEntity, IncludedModeDeclarationGroupSet, ModeDeclarationGroupPrototype, Identifiable
 from .ar_ref import RefType
 
 class BswModuleEntity(ExecutableEntity, metaclass=ABCMeta):
@@ -105,7 +107,6 @@ class BswInternalTriggerOccurredEvent(BswScheduleEvent):
 
         self.event_source_ref = None                # type: RefType
 
-
 class BswModeSwitchAckRequest(ARObject):
     def __init__(self):
         super().__init__()
@@ -144,21 +145,23 @@ class BswInternalBehavior(InternalBehavior):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
-        self._entities = []                         # type: List[BswModuleEntity]
-        self._events = []                           # type: List[BswEvent]
-        self._mode_sender_policies = []             # type: List[BswModeSenderPolicy]
+        self.entities = []                                  # type: List[BswModuleEntity]
+        self.events = []                                    # type: List[BswEvent]
+        self.mode_sender_policies = []                      # type: List[BswModeSenderPolicy]
+        self.included_mode_declaration_group_sets = []      # type: List[IncludedModeDeclarationGroupSet]
+        self.included_data_type_sets = []                       # type: List[IncludedDataTypeSet]
 
     def addModeSenderPolicy(self, policy: BswModeSenderPolicy):
-        self._mode_sender_policies.append(policy)
+        self.mode_sender_policies.append(policy)
 
     def getModeSenderPolicies(self) -> List[BswModeSenderPolicy]:
-        return self._mode_sender_policies
+        return self.mode_sender_policies
 
     def createBswCalledEntity(self, short_name: str) -> BswCalledEntity:
         if (short_name not in self.elements):
             event = BswCalledEntity(self, short_name)
             self.elements[short_name] = event
-            self._entities.append(event)
+            self.entities.append(event)
         return self.elements[short_name]
 
     def getBswCalledEntities(self) -> List[BswCalledEntity]:
@@ -168,7 +171,7 @@ class BswInternalBehavior(InternalBehavior):
         if (short_name not in self.elements):
             event = BswSchedulableEntity(self, short_name)
             self.elements[short_name] = event
-            self._entities.append(event)
+            self.entities.append(event)
         return self.elements[short_name]
 
     def getBswSchedulableEntities(self) -> List[BswSchedulableEntity]:
@@ -181,7 +184,7 @@ class BswInternalBehavior(InternalBehavior):
         if (short_name not in self.elements):
             event = BswModeSwitchEvent(self, short_name)
             self.elements[short_name] = event
-            self._events.append(event)
+            self.events.append(event)
         return self.elements[short_name]
 
     def getBswModeSwitchEvents(self) -> List[BswModeSwitchEvent]:
@@ -191,7 +194,7 @@ class BswInternalBehavior(InternalBehavior):
         if (short_name not in self.elements):
             event = BswTimingEvent(self, short_name)
             self.elements[short_name] = event
-            self._events.append(event)
+            self.events.append(event)
         return self.elements[short_name]
 
     def getBswTimingEvents(self) -> List[BswTimingEvent]:
@@ -201,7 +204,7 @@ class BswInternalBehavior(InternalBehavior):
         if (short_name not in self.elements):
             event = BswDataReceivedEvent(self, short_name)
             self.elements[short_name] = event
-            self._events.append(event)
+            self.events.append(event)
         return self.elements[short_name]
 
     def getBswDataReceivedEvents(self) -> List[BswDataReceivedEvent]:
@@ -211,7 +214,7 @@ class BswInternalBehavior(InternalBehavior):
         if (short_name not in self.elements):
             event = BswInternalTriggerOccurredEvent(self, short_name)
             self.elements[short_name] = event
-            self._events.append(event)
+            self.events.append(event)
         return self.elements[short_name]
 
     def getBswInternalTriggerOccurredEvents(self) -> List[BswInternalTriggerOccurredEvent]:
@@ -219,6 +222,18 @@ class BswInternalBehavior(InternalBehavior):
     
     def getBswEvents(self) -> List[BswEvent]:
         return list(filter(lambda a: isinstance(a, BswEvent), self.elements.values()))
+    
+    def addIncludedModeDeclarationGroupSet(self, group_set: IncludedModeDeclarationGroupSet):
+        self.included_mode_declaration_group_sets.append(group_set)
+
+    def getIncludedModeDeclarationGroupSets(self) -> List[IncludedModeDeclarationGroupSet]:
+        return self.included_mode_declaration_group_sets
+    
+    def addIncludedDataTypeSet(self, type_set: IncludedDataTypeSet):
+        self.included_data_type_sets.append(type_set)
+
+    def getIncludedDataTypeSets(self) -> List[IncludedDataTypeSet]:
+        return self.included_data_type_sets
 
 class BswModuleDescription(AtpStructureElement):
     '''
@@ -239,7 +254,7 @@ class BswModuleDescription(AtpStructureElement):
         self._implementedEntryRefs = []                 # type: List[RefType]
 
         self.providedModeGroups   = {}                  # type: Dict[str, ModeDeclarationGroupPrototype]
-        self.requiredModeGroups   = {}                  # tyep: Dict[str, ModeDeclarationGroupPrototype] 
+        self.requiredModeGroups   = {}                  # type: Dict[str, ModeDeclarationGroupPrototype] 
 
     def addImplementedEntry(self, entry_ref: RefType):
         self._implementedEntryRefs.append(entry_ref)

armodel/models/common_structure.py

@@ -152,29 +152,27 @@ class ExclusiveArea(Identifiable):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
-class InternalBehavior(Identifiable, metaclass=ABCMeta):
-    def __init__(self, parent: ARObject, short_name: str):
-        if type(self) == InternalBehavior:
-            raise NotImplementedError("InternalBehavior is an abstract class.")
-        super().__init__(parent, short_name)
-
-        self._dataTypeMappingRefs = []      # type: List[RefType]
-
-    def addDataTypeMappingRef(self, ref: RefType):
-        self._dataTypeMappingRefs.append(ref)
+class IncludedModeDeclarationGroupSet(ARObject):
+    def __init__(self):
+        super().__init__()
 
-    def getDataTypeMappingRefs(self) -> List[RefType]:
-        return self._dataTypeMappingRefs
+        self.mode_declaration_group_refs = []           # type: List[RefType]
+        self.prefix = None                              # type: ARLiteral
 
-    def createExclusiveArea(self, short_name: str) -> ExclusiveArea:
-        if (short_name not in self.elements):
-            event = ExclusiveArea(self, short_name)
-            self.elements[short_name] = event
-        return self.elements[short_name]
+    def addModeDeclarationGroupRef(self, ref: RefType):
+        self.mode_declaration_group_refs.append(ref)
+        return self
 
-    def getExclusiveAreas(self) -> List[ExclusiveArea]:
-        return list(filter(lambda c: isinstance(c, ExclusiveArea), self.elements.values()))
+    def getModeDeclarationGroupRefs(self) -> List[RefType]:
+        return self.mode_declaration_group_refs
 
+    def setPrefix(self, prefix: str):
+        self.prefix = prefix
+        return self
+    
+    def getPrefix(self) -> ARLiteral:
+        return self.prefix
+    
 class ModeDeclaration(Identifiable):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
@@ -197,19 +195,36 @@ class ExecutableEntity(Identifiable, metaclass=ABCMeta):
         self.activation_reason = None               # *
         self.minimum_start_interval = None          # type: ARFloat
         self.reentrancy_level = None                # 
-        self._can_enter_exclusive_area_refs = []    # type: List[RefType]  
+        self.can_enter_exclusive_area_refs = []     # type: List[RefType]  
+        self.sw_addr_method_ref = None              # type: RefType
 
     @property
-    def minimum_start_interval_ms(self) -> int:
+    def minimumStartIntervalMs(self) -> int:
         if self.minimum_start_interval is not None:
             return int(self.minimum_start_interval.getValue() * 1000)
         return None
 
+    @property
+    def minimumStartInterval(self) -> ARFloat:
+        return self.minimum_start_interval
+    
+    @minimumStartInterval.setter
+    def minimumStartInterval(self, value: ARFloat):
+        self.minimum_start_interval = value
+    
+    @property
+    def swAddrMethodRef(self) -> RefType:
+        return self.sw_addr_method_ref
+    
+    @swAddrMethodRef.setter
+    def swAddrMethodRef(self, ref: RefType):
+        self.sw_addr_method_ref = ref
+
     def addCanEnterExclusiveAreaRef(self, ref: RefType):
-        self._can_enter_exclusive_area_refs.append(ref)
+        self.can_enter_exclusive_area_refs.append(ref)
 
     def getCanEnterExclusiveAreaRefs(self):
-        return self._can_enter_exclusive_area_refs
+        return self.can_enter_exclusive_area_refs
     
 class ModeDeclarationGroupPrototype(Identifiable):
     """

armodel/models/fibex/can_communication.py

@@ -0,0 +1,6 @@
+from ..ar_object import ARObject
+from .fibex_core import Frame
+
+class CanFrame(Frame):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)

armodel/models/fibex/fibex_4_multiplatform.py

@@ -0,0 +1,145 @@
+from typing import List
+
+from ..ar_ref import RefType
+from ..ar_object import ARObject, ARPositiveInteger
+from .fibex_core import FibexElement
+
+class FrameMapping(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self._introduction = None             # type: DocumentationBlock
+        self._source_frame_ref = None         # type: RefType
+        self._target_frame_ref = None         # type: RefType
+
+    @property
+    def introduction(self):
+        return self._introduction
+
+    @introduction.setter
+    def introduction(self, value):
+        self._introduction = value
+
+    @property
+    def sourceFrameRef(self):
+        return self._source_frame_ref
+
+    @sourceFrameRef.setter
+    def sourceFrameRef(self, value):
+        self._source_frame_ref = value
+
+    @property
+    def targetFrameRef(self):
+        return self._target_frame_ref
+
+    @targetFrameRef.setter
+    def targetFrameRef(self, value):
+        self._target_frame_ref = value
+
+class ISignalMapping(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self._introduction = None           # type: DocumentationBlock
+        self._source_signal_ref = None      # type: RefType
+        self._target_signal_ref = None      # type: RefType
+
+    @property
+    def introduction(self):
+        return self._introduction
+
+    @introduction.setter
+    def introduction(self, value):
+        self._introduction = value
+
+    @property
+    def sourceSignalRef(self):
+        return self._source_signal_ref
+
+    @sourceSignalRef.setter
+    def sourceSignalRef(self, value):
+        self._source_signal_ref = value
+
+    @property
+    def targetSignalRef(self):
+        return self._target_signal_ref
+
+    @targetSignalRef.setter
+    def targetSignalRef(self, value):
+        self._target_signal_ref = value
+
+class IPduMapping(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self._introduction = None           # type: DocumentationBlock
+        self._pdur_tp_chunk_size = None     # type: ARPositiveInteger
+        self._source_ipdu_ref = None        # type: RefType
+        self._target_ipdu_ref = None        # type: RefType
+
+    @property
+    def introduction(self):
+        return self._introduction
+
+    @introduction.setter
+    def introduction(self, value):
+        self._introduction = value
+
+    @property
+    def pdurTpChunkSize(self):
+        return self._pdur_tp_chunk_size
+
+    @pdurTpChunkSize.setter
+    def pdurTpChunkSize(self, value):
+        self._pdur_tp_chunk_size = value
+
+    @property
+    def sourceIPduRef(self):
+        return self._source_ipdu_ref
+
+    @sourceIPduRef.setter
+    def sourceIPduRef(self, value):
+        self._source_ipdu_ref = value
+
+    @property
+    def targetIPduRef(self):
+        return self._target_ipdu_ref
+
+    @targetIPduRef.setter
+    def targetIPduRef(self, value):
+        self._target_ipdu_ref = value
+
+class Gateway(FibexElement):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self._ecu_ref = None                # type: RefType
+        self._frame_mappings = []           # type: List[FrameMapping]
+        self._i_pdu_mappings = []           # type: List[IPduMapping]
+        self._signal_mappings = []          # type: List[ISignalMapping]
+
+    @property
+    def ecuRef(self) -> RefType:
+        return self._ecu_ref
+
+    @ecuRef.setter
+    def ecuRef(self, value: RefType):
+        self._ecu_ref = value
+
+    def getFrameMappings(self) -> List[FrameMapping]:
+        return self._frame_mappings
+
+    def addFrameMapping(self, mapping: FrameMapping):
+        self._frame_mappings.append(mapping)
+
+    def getIPduMappings(self) -> List[FrameMapping]:
+        return self._i_pdu_mappings
+
+    def addIPduMappings(self, mapping: FrameMapping):
+        self._i_pdu_mappings.append(mapping)
+
+    def getSignalMappings(self) -> List[FrameMapping]:
+        return self._signal_mappings
+
+    def addSignalMapping(self, mapping: FrameMapping):
+        self._signal_mappings.append(mapping)