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

armodel/models/bsw_module_template.py

@@ -1,8 +1,10 @@
 from abc import ABCMeta
-from typing import List
+from typing import Dict, List
+
+from .internal_behavior import IncludedDataTypeSet, InternalBehavior
 from .general_structure import AtpStructureElement, ARObject, ARElement
-from .ar_object import ARBoolean
-from .common_structure import ExecutableEntity, ModeDeclarationGroupPrototype, InternalBehavior, Identifiable
+from .ar_object import ARBoolean, ARFloat, ARLiteral, ARNumerical, ARPositiveInteger
+from .common_structure import ExecutableEntity, IncludedModeDeclarationGroupSet, ModeDeclarationGroupPrototype, Identifiable
 from .ar_ref import RefType
 
 class BswModuleEntity(ExecutableEntity, metaclass=ABCMeta):
@@ -11,10 +13,16 @@ class BswModuleEntity(ExecutableEntity, metaclass=ABCMeta):
             raise NotImplementedError("BswModuleEntity is an abstract class.")
         super().__init__(parent, short_name)
 
-        self.accessed_mode_group_refs = []          # Ref ModeDeclarationGroupPrototype     *
-        self.activation_point_refs = []             # Ref BswInternalTriggeringPoint        *
-        self.implemented_entry_ref = None           # type: RefType
-        self.managed_mode_group_refs = []           # Ref ModeDeclarationGroupPrototype     *
+        self.accessedModeGroupRefs = []                 # type: List[RefType]
+        self.activationPointRefs = []                   # type: List[RefType]
+        self.implemented_entry_ref = None                 # type: RefType
+        self._managedModeGroupRefs = []                 # type: List[RefType]
+
+    def addManagedModeGroupRef(self, ref: RefType):
+        self._managedModeGroupRefs.append(ref)
+
+    def getManagedModeGroupRefs(self) -> List[RefType]:
+        return self._managedModeGroupRefs
 
 class BswCalledEntity(BswModuleEntity):
     def __init__(self, parent: ARObject, short_name: str):
@@ -47,7 +55,7 @@ class BswEvent(Identifiable, metaclass=ABCMeta):
             raise NotImplementedError("BswEvent is an abstract class.")
         super().__init__(parent, short_name)
 
-        self.starts_on_event_ref = None         # type: RefType 
+        self.startsOnEventRef = None                    # type: RefType 
 
 class BswOperationInvokedEvent(BswEvent):
     def __init__(self, parent: ARObject, short_name: str):
@@ -79,11 +87,13 @@ class BswTimingEvent(BswScheduleEvent):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
         
-        self.period = 0.0
+        self.period = None          # type: ARFloat
 
     @property
-    def period_ms(self) -> int:
-        return int(self.period * 1000)
+    def periodMs(self) -> int:
+        if self.period is not None:
+            return int(self.period.value * 1000)
+        return None
 
 class BswDataReceivedEvent(BswScheduleEvent):
     def __init__(self, parent: ARObject, short_name: str):
@@ -95,16 +105,63 @@ class BswInternalTriggerOccurredEvent(BswScheduleEvent):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
-        self.event_source_ref = None        # type: RefType
+        self.event_source_ref = None                # type: RefType
+
+class BswModeSwitchAckRequest(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self.timeout = None                         # type: ARFloat
+
+class BswModeSenderPolicy(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self.ack_request = None                     # type: BswModeSwitchAckRequest
+        self.enhanced_mode_api = None               # type: ARBoolean
+        self._provided_mode_group_ref = None        # type: RefType
+        self._queue_length = None                   # type: ARNumerical
+
+    def setProvidedModeGroupRef(self, ref: RefType):
+        self._provided_mode_group_ref = ref
+        return self
+
+    def getProvidedModeGroupRef(self) -> RefType:
+        return self._provided_mode_group_ref
+    
+    def setQueueLength(self, length: any):
+        if isinstance(length, ARNumerical):
+            self._queue_length = length
+        elif isinstance(length, int):
+            self._queue_length = ARNumerical()
+            self._queue_length.setValue(length)
+        else:
+            raise ValueError("Unsupported type <%s>" % type(length))
+        
+    def getQueueLength(self) -> ARNumerical:
+        return self._queue_length
 
 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.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)
+
+    def getModeSenderPolicies(self) -> List[BswModeSenderPolicy]:
+        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)
         return self.elements[short_name]
 
     def getBswCalledEntities(self) -> List[BswCalledEntity]:
@@ -114,24 +171,30 @@ class BswInternalBehavior(InternalBehavior):
         if (short_name not in self.elements):
             event = BswSchedulableEntity(self, short_name)
             self.elements[short_name] = event
+            self.entities.append(event)
         return self.elements[short_name]
 
     def getBswSchedulableEntities(self) -> List[BswSchedulableEntity]:
         return list(filter(lambda a: isinstance(a, BswSchedulableEntity), self.elements.values()))
+    
+    def getBswModuleEntities(self) -> List[BswModuleEntity]:
+        return list(filter(lambda a: isinstance(a, BswModuleEntity), self.elements.values()))
 
     def createBswModeSwitchEvent(self, short_name: str) -> BswModeSwitchEvent:
         if (short_name not in self.elements):
             event = BswModeSwitchEvent(self, short_name)
             self.elements[short_name] = event
+            self.events.append(event)
         return self.elements[short_name]
 
     def getBswModeSwitchEvents(self) -> List[BswModeSwitchEvent]:
         return list(filter(lambda a: isinstance(a, BswModeSwitchEvent), self.elements.values()))
-
+    
     def createBswTimingEvent(self, short_name: str) -> BswTimingEvent:
         if (short_name not in self.elements):
             event = BswTimingEvent(self, short_name)
             self.elements[short_name] = event
+            self.events.append(event)
         return self.elements[short_name]
 
     def getBswTimingEvents(self) -> List[BswTimingEvent]:
@@ -141,6 +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)
         return self.elements[short_name]
 
     def getBswDataReceivedEvents(self) -> List[BswDataReceivedEvent]:
@@ -150,10 +214,26 @@ class BswInternalBehavior(InternalBehavior):
         if (short_name not in self.elements):
             event = BswInternalTriggerOccurredEvent(self, short_name)
             self.elements[short_name] = event
+            self.events.append(event)
         return self.elements[short_name]
 
     def getBswInternalTriggerOccurredEvents(self) -> List[BswInternalTriggerOccurredEvent]:
         return list(filter(lambda a: isinstance(a, BswInternalTriggerOccurredEvent), self.elements.values()))
+    
+    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):
     '''
@@ -169,12 +249,18 @@ class BswModuleDescription(AtpStructureElement):
         super().__init__(parent, short_name)
 
         # MODULE-ID
-        self.module_id = 0
+        self.module_id = None                           # type: ARPositiveInteger           
         # PROVIDED-ENTRYS
-        self.implemented_entry_refs = []                # type: List[RefType]
+        self._implementedEntryRefs = []                 # type: List[RefType]
+
+        self.providedModeGroups   = {}                  # type: Dict[str, ModeDeclarationGroupPrototype]
+        self.requiredModeGroups   = {}                  # type: Dict[str, ModeDeclarationGroupPrototype] 
+
+    def addImplementedEntry(self, entry_ref: RefType):
+        self._implementedEntryRefs.append(entry_ref)
 
-        self.provided_mode_groups   = {}                # ModeDeclarationGroupPrototype         *
-        self.required_mode_groups   = {}                # ModeDeclarationGroupPrototype         * 
+    def getImplementedEntries(self) -> List[RefType]:
+        return self._implementedEntryRefs
 
     @property
     def category(self) -> str:
@@ -190,21 +276,21 @@ class BswModuleDescription(AtpStructureElement):
         if (short_name not in self.elements):
             prototype = ModeDeclarationGroupPrototype(self, short_name)
             self.elements[short_name] = prototype
-            self.provided_mode_groups[short_name] = prototype
+            self.providedModeGroups[short_name] = prototype
         return self.elements[short_name]
 
     def getProvidedModeGroups(self) -> List[ModeDeclarationGroupPrototype]:
-        return sorted(self.provided_mode_groups.values(), key=lambda v: v.short_name) 
+        return sorted(self.providedModeGroups.values(), key=lambda v: v.short_name) 
 
     def createRequiredModeGroup(self, short_name: str) -> ModeDeclarationGroupPrototype:
         if (short_name not in self.elements):
             prototype = ModeDeclarationGroupPrototype(self, short_name)
             self.elements[short_name] = prototype
-            self.required_mode_groups[short_name] = property
+            self.requiredModeGroups[short_name] = property
         return self.elements[short_name]
 
     def getRequiredModeGroups(self) -> List[ModeDeclarationGroupPrototype]:
-        return sorted(self.required_mode_groups.values(), key=lambda v: v.short_name) 
+        return sorted(self.requiredModeGroups.values(), key=lambda v: v.short_name) 
 
     def createBswInternalBehavior(self, short_name: str) -> BswInternalBehavior:
         '''
@@ -222,12 +308,12 @@ class BswModuleEntry(ARElement):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
-        self.service_id = None                  # type: int
-        self.is_reentrant = None                # type: ARBoolean
-        self.is_synchronous = None              # type: ARBoolean
-        self.call_type = None                   # type: str
-        self._execution_context = None          # type: str
-        self._sw_service_impl_policy = None     # type: str
+        self.service_id = None                      # type: ARNumerical
+        self.is_reentrant = None                    # type: ARBoolean
+        self.is_synchronous = None                  # type: ARBoolean
+        self.call_type = None                       # type: ARLiteral
+        self._execution_context = None              # type: ARLiteral
+        self._sw_service_impl_policy = None         # type: ARLiteral
 
     @property
     def execution_context(self):

armodel/models/calibration.py

@@ -1,16 +1,119 @@
-from .ar_object import ARObject
+from abc import ABCMeta
+from typing import List
+
+from .ar_object import ARFloat, ARNumerical, ARObject
 from .ar_ref import RefType
+from .data_def_properties import ValueList
 
 class SwValues(ARObject):
     def __init__(self):
         super().__init__()
 
-        self.v = None                   # type: float
+        self._v = []                    # type: List[ARNumerical]
+        self.vt = None                  # type: float
+
+    def addV(self, v: ARNumerical):
+        self._v.append(v)
 
+    def getVs(self) -> List[ARNumerical]:
+        return self._v
+    
 class SwValueCont(ARObject):
     def __init__(self):
         super().__init__()
 
-        self.unit_ref = None            # type: RefType
-        self.sw_values_phys = None      # type: SwValues
+        self.sw_arraysize = None         # type: ValueList
+        self.unit_ref = None             # type: RefType
+        self.sw_values_phys = None        # type: SwValues
+
+class SwGenericAxisParam(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self.swGenericAxisParamTypeRef = None   # type: RefType
+        self.vf = []                            # type: List[ARFloat]
+class SwAxisGeneric(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self.swAxisTypeRef = None               # type: RefType
+        self.swGenericAxisParam = []            # type: List[SwGenericAxisParam]
+
+class SwCalprmAxisTypeProps(ARObject, metaclass = ABCMeta):
+    def __init__(self):
+        if type(self) == SwCalprmAxisTypeProps:
+            raise NotImplementedError("SwCalprmAxisTypeProps is an abstract class.")
+        
+        super().__init__()
+        
+        self.maxGradient = None         # type: ARFloat
+        self.monotony = None            # type: MonotonyEnum
+
+class SwAxisIndividual(SwCalprmAxisTypeProps):
+    def __init__(self):
+        super().__init__()
+
+        self.compuMethodRef = None              # type: RefType
+        self.dataConstrRef = None               # type: RefType
+        self.inputVariableTypeRef = None        # type: RefType
+        self.swAxisGeneric = None               # type: SwAxisGeneric
+        self.swMaxAxisPoints = None             # type: ARNumerical
+        self.swMinAxisPoints = None             # type: ARNumerical
+        self.swVariableRefs = []                # type: List
+        self.unitRef = None                     # type: RefType
+
+    def setInputVariableTypeRef(self, ref: RefType):
+        self.inputVariableTypeRef = ref
+        return self
+    
+    def setCompuMethodRef(self, ref: RefType):
+        self.compuMethodRef = ref
+        return self
+    
+    def setSwMaxAxisPoints(self, points: int):
+        self.swMaxAxisPoints = points
+        return self
+    
+    def setSwMinAxisPoints(self, points: int):
+        self.swMinAxisPoints = points
+        return self
+    
+    def setDataConstrRef(self, ref: RefType):
+        self.dataConstrRef = ref
+        return self
+
+class SwAxisGrouped(SwCalprmAxisTypeProps):
+    def __init__(self):
+        super().__init__()
+
+        self.sharedAxisTypeRef = None           # type: RefType
+        self.swAxisIndex = None                 # type: ARNumerical
+        self.swCalprmRef = None                 # type: SwCalprmRefProxy
+
+    def setSharedAxisTypeRef(self, ref: RefType):
+        self.sharedAxisTypeRef = ref
+        return self
+
+class SwCalprmAxis(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self.category = None                # type: CalprmAxisCategoryEnum
+        self.displayFormat = None           # type: DisplayFormatString
+        self.sw_axis_index = None             # type: AxisIndexType   
+        self.swCalibrationAccess = None     # type: SwCalibrationAccessEnum
+        self.sw_calprm_axis_type_props = None   # type: SwCalprmAxisTypeProps
+
+class SwCalprmAxisSet(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self._swCalprmAxis = []          # type: List[SwCalprmAxis]
+
+    def addSwCalprmAxis(self, axis: SwCalprmAxis):
+        self._swCalprmAxis.append(axis)
+
+    def getSwCalprmAxises(self) -> List[SwCalprmAxis]:
+        return self._swCalprmAxis
+    
 

armodel/models/common_structure.py

@@ -3,9 +3,10 @@
 from abc import ABCMeta
 from typing import List
 
+from .ar_object import ARFloat, ARLiteral, ARNumerical
 from .general_structure import ARObject, ARElement, Identifiable
 from .data_dictionary import SwDataDefProps
-from .ar_ref import RefType
+from .ar_ref import RefType, TRefType
 
 import re
 
@@ -96,7 +97,7 @@ class NumericalValueSpecification(ValueSpecification):
     def __init__(self):
         super().__init__()
 
-        self.value = None        # type: float  
+        self.value = None        # type: ARFloat  
 
 class ArrayValueSpecification(ValueSpecification):
     def __init__(self):
@@ -133,10 +134,10 @@ class ImplementationDataTypeElement(AbstractImplementationDataTypeElement):
     def __init__(self, parent, short_name: str):
         super().__init__(parent, short_name)
 
-        self.array_size = None              # type: int
-        self.array_size_semantics = None    # type: str
-        self.is_optional = None             # type: bool
-        self.sw_data_def_props = None       # type: SwDataDefProps
+        self.arraySize = None               # type: int
+        self.array_size_semantics = None      # type: str
+        self.isOptional = None              # type: bool
+        self.sw_data_def_props = None          # type: SwDataDefProps
     
     def createImplementationDataTypeElement(self, short_name: str): # type: (...) -> ImplementationDataTypeElement
         if (short_name not in self.elements):
@@ -144,41 +145,46 @@ class ImplementationDataTypeElement(AbstractImplementationDataTypeElement):
             self.elements[short_name] = event
         return self.elements[short_name]
     
-    def getImplementationDataTypeElements(self):                    # type：(...) -> List[ImplementationDataTypeElement]:
+    def getImplementationDataTypeElements(self):                    # type：(...) -> List[ImplementationDataTypeElement]
         return list(filter(lambda c: isinstance(c, ImplementationDataTypeElement), self.elements.values()))
 
 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._data_type_mapping_refs = []      # type: List[RefType]
-
-    def addDataTypeMappingRef(self, ref: RefType):
-        self._data_type_mapping_refs.append(ref)
+class IncludedModeDeclarationGroupSet(ARObject):
+    def __init__(self):
+        super().__init__()
 
-    def getDataTypeMappingRefs(self) -> List[RefType]:
-        return self._data_type_mapping_refs
+        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)
 
-        self.value = 0
+        self.value = None                           # type: ARNumerical
+
+    def setValue(self, value):
+        self.value = value
+        return self
+
+    def getValue(self) -> ARNumerical:
+        return self.value
 
 class ExecutableEntity(Identifiable, metaclass=ABCMeta):
     def __init__(self, parent: ARObject, short_name: str):
@@ -186,14 +192,33 @@ class ExecutableEntity(Identifiable, metaclass=ABCMeta):
             raise NotImplementedError("ExecutableEntity is an abstract class.")
         super().__init__(parent, short_name)
     
-        self.activation_reason = None           # *
-        self.minimum_start_interval = 0.0       # 0..1
-        self.reentrancy_level = None            # 
-        self.can_enter_exclusive_area_refs = [] # type: List[RefType]  
+        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.sw_addr_method_ref = None              # type: RefType
 
     @property
-    def minimum_start_interval_ms(self) -> int:
-        return int(self.minimum_start_interval * 1000)
+    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)
@@ -208,44 +233,55 @@ class ModeDeclarationGroupPrototype(Identifiable):
 
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
-        self._sw_calibration_access = ""    # 0..1
-        self.type_tref = None                    # tref 0..1
+
+        self._swCalibrationAccess = None        # type: str
+        self.typeTRef = None                    # type: TRefType
 
     @property
     def sw_calibration_access(self):
-        return self._sw_calibration_access
+        return self._swCalibrationAccess
 
     @sw_calibration_access.setter
     def sw_calibration_access(self, value):
         if (value not in ("notAccessible", "readOnly", "readWrite")):
             raise ValueError("Invalid SwCalibrationAccess <%s> of ModeDeclarationGroupPrototype <%s>" % (value, self.short_name))
-        self._sw_calibration_access = value
+        self._swCalibrationAccess = value
 
 class MemorySection(Identifiable):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
         
-        self._alignment = None
-        self.sw_addr_method_ref = None  # type: RefType
+        self._alignment = None              # type: ARLiteral
+        self.size = None
+        self._options = []                  # type: List[ARLiteral]
+        self.swAddrMethodRef = None         # type: RefType
+        self.symbol = None                  # type: ARLiteral
+
+    def addOption(self, option: ARLiteral):
+        self._options.append(option)
+
+    def getOptions(self) -> List[ARLiteral]:
+        return self._options
 
     @property
-    def alignment(self) -> str:
+    def alignment(self) -> ARLiteral:
         return self._alignment
 
     @alignment.setter
-    def alignment(self, value:str):
-        match = False
-        if value in ("UNKNOWN", "UNSPECIFIED", "BOOLEAN", "PTR"):
-            self._alignment = value
-            match = True
-        else:
-            m = re.match(r'^\d+', value)
-            if m:
+    def alignment(self, value: ARLiteral):
+        if value is not None:
+            match = False
+            if value.value in ("UNKNOWN", "UNSPECIFIED", "BOOLEAN", "PTR"):
                 self._alignment = value
                 match = True
-                
-        if not match:
-            raise ValueError("Invalid alignment <%s> of memory section <%s>" % (value, self.short_name))
+            else:
+                m = re.match(r'^\d+', value.value)
+                if m:
+                    self._alignment = value
+                    match = True
+                    
+            if not match:
+                raise ValueError("Invalid alignment <%s> of memory section <%s>" % (value, self.short_name))
         
 
 class ResourceConsumption(Identifiable):
@@ -262,4 +298,58 @@ class ResourceConsumption(Identifiable):
         return list(filter(lambda a : isinstance(a, MemorySection), self.elements.values()))
 
     def getMemorySection(self, short_name: str) -> MemorySection:
-        return next(filter(lambda o: isinstance(o, MemorySection) and (o.short_name == short_name), self.elements.values()), None)
+        return next(filter(lambda o: isinstance(o, MemorySection) and (o.short_name == short_name), self.elements.values()), None)
+    
+class Trigger(Identifiable):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self.swImplPolicy = None    # type: str
+        self.triggerPeriod = None   # type: float
+
+class ModeRequestTypeMap(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self.implementation_data_type_ref = None           # type: RefType
+        self.mode_group_ref = None                        # type: RefType
+
+class ModeDeclarationGroup(Identifiable):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self._initial_mode_ref = None                      # type: RefType
+        self._on_transition_value = None                   # type: ARNumerical
+
+    def createModeDeclaration(self, short_name: str) -> ModeDeclaration:
+        if (short_name not in self.elements):
+            spec = ModeDeclaration(self, short_name)
+            self.elements[short_name] = spec
+        return self.elements[short_name]
+    
+    def getModeDeclarations(self) -> List[ModeDeclaration]:
+        return list(sorted(filter(lambda a: isinstance(a, ModeDeclaration), self.elements.values()), key= lambda o:o.short_name))
+    
+    def setInitialModeRef(self, ref: RefType):
+        self._initial_mode_ref = ref
+        return self
+    
+    def getInitialModeRef(self) -> RefType:
+        return self._initial_mode_ref
+
+    def setOnTransitionValue(self, value):
+        if isinstance(value, int):
+            value = ARNumerical()
+            value.setValue(value)
+        self._on_transition_value = value
+        return self
+    
+    def getOnTransitionValue(self) -> ARNumerical:
+        return self._on_transition_value
+    
+class ModeDeclarationGroupPrototype(Identifiable):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self.swCalibrationAccess = None                 # type: str
+        self.type_tref = None                            # type: TRefType

armodel/models/communication.py

@@ -1,4 +1,7 @@
-from . import ARObject
+
+from .data_dictionary import SwDataDefProps
+from .ar_ref import ApplicationCompositeElementInPortInterfaceInstanceRef
+from .ar_object import ARObject
 
 class TransmissionAcknowledgementRequest(ARObject):
     def __init__(self):
@@ -6,3 +9,9 @@ class TransmissionAcknowledgementRequest(ARObject):
 
         self.timeout = None     # type: float
 
+class CompositeNetworkRepresentation(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self.leaf_element_iref = None           # type: ApplicationCompositeElementInPortInterfaceInstanceRef
+        self.network_representation = None      # type: SwDataDefProps