armodel 1.6.3__py3-none-any.whl → 1.7.0__py3-none-any.whl

armodel/models/M2/AUTOSARTemplates/SWComponentTemplate/SwcInternalBehavior/RTEEvents.py

@@ -0,0 +1,174 @@
+from .....M2.AUTOSARTemplates.SWComponentTemplate.Components.InstanceRefs import RVariableInAtomicSwcInstanceRef, RModeInAtomicSwcInstanceRef
+from .....M2.AUTOSARTemplates.SWComponentTemplate.Composition.InstanceRefs import POperationInAtomicSwcInstanceRef
+from .....M2.AUTOSARTemplates.CommonStructure.InternalBehavior import AbstractEvent
+from .....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
+from .....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import RefType, TimeValue
+from typing import List
+
+class RTEEvent(AbstractEvent):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+        
+        self.disabledModeIRefs = []                                     # type: List[RModeInAtomicSwcInstanceRef]
+        self.startOnEventRef = None                                     # type: RefType
+
+    def getDisabledModeIRefs(self):
+        return self.disabledModeIRefs
+
+    def addDisabledModeIRef(self, value):
+        self.disabledModeIRefs.append(value)
+        return self
+
+    def getStartOnEventRef(self):
+        return self.startOnEventRef
+
+    def setStartOnEventRef(self, value):
+        self.startOnEventRef = value
+        return self
+
+class AsynchronousServerCallReturnsEvent(RTEEvent):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self.eventSourceRef = None                                      # type: RefType
+
+    def getEventSourceRef(self):
+        return self.eventSourceRef
+
+    def setEventSourceRef(self, value):
+        self.eventSourceRef = value
+        return self
+
+
+class DataSendCompletedEvent(RTEEvent):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self.eventSourceRef = None                                      # type: RefType
+
+    def getEventSourceRef(self):
+        return self.eventSourceRef
+
+    def setEventSourceRef(self, value):
+        self.eventSourceRef = value
+        return self
+
+class DataWriteCompletedEvent(RTEEvent):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self.eventSourceRef = None                                      # type: RefType
+
+    def getEventSourceRef(self):
+        return self.eventSourceRef
+
+    def setEventSourceRef(self, value):
+        self.eventSourceRef = value
+        return self
+
+class DataReceivedEvent(RTEEvent):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self.dataIRef = None                   # type: RVariableInAtomicSwcInstanceRef
+
+    def getDataIRef(self):
+        return self.dataIRef
+
+    def setDataIRef(self, value):
+        self.dataIRef = value
+        return self
+
+
+class SwcModeSwitchEvent(RTEEvent):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self.activation = None              # type: ModeActivationKind
+        self.modeIRefs = []                 # type: List[RModeInAtomicSwcInstanceRef]
+
+    def getActivation(self):
+        return self.activation
+
+    def setActivation(self, value):
+        self.activation = value
+        return self
+
+    def getModeIRefs(self):
+        return self.modeIRefs
+
+    def addModeIRef(self, value):
+        self.modeIRefs.append(value)
+        return self
+
+class DataReceiveErrorEvent(RTEEvent):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self.dataIRef = None
+
+    def getDataIRef(self):
+        return self.dataIRef
+
+    def setDataIRef(self, value):
+        self.dataIRef = value
+        return self
+
+class OperationInvokedEvent(RTEEvent):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self.operationIRef = None      # type: POperationInAtomicSwcInstanceRef
+
+    def getOperationIRef(self):
+        return self.operationIRef
+
+    def setOperationIRef(self, value):
+        self.operationIRef = value
+        return self
+
+class InitEvent(RTEEvent):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+
+class TimingEvent(RTEEvent):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self.offset = None                              # type: TimeValue
+        self.period = None                              # type: TimeValue
+
+    @property
+    def periodMs(self):
+        if (self.period < 0.001):
+            return self.period * 1000
+        else:
+            return (int)(self.period * 1000)
+        
+    def getOffset(self):
+        return self.offset
+
+    def setOffset(self, value):
+        self.offset = value
+        return self
+
+    def getPeriod(self):
+        return self.period
+
+    def setPeriod(self, value):
+        self.period = value
+        return self
+
+class InternalTriggerOccurredEvent(RTEEvent):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self.eventSourceRef = None                      # type: RefType
+
+    def getEventSourceRef(self):
+        return self.eventSourceRef
+
+    def setEventSourceRef(self, value):
+        self.eventSourceRef = value
+        return self

armodel/models/M2/AUTOSARTemplates/SWComponentTemplate/SwcInternalBehavior/ServerCall.py

@@ -1,8 +1,7 @@
 from abc import ABCMeta
-from ...GenericStructure.GeneralTemplateClasses.ArObject import ARObject
-from ..Composition.InstanceRefs import ROperationInAtomicSwcInstanceRef
-from .AccessCount import AbstractAccessPoint
-
+from .....M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.AccessCount import AbstractAccessPoint
+from .....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
+from .....M2.AUTOSARTemplates.SWComponentTemplate.Composition.InstanceRefs import ROperationInAtomicSwcInstanceRef
 
 class ServerCallPoint(AbstractAccessPoint, metaclass = ABCMeta):
 

armodel/models/M2/AUTOSARTemplates/SWComponentTemplate/SwcInternalBehavior/ServiceMapping.py

@@ -1,6 +1,8 @@
-from ....AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
-from ....AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import RefType
-
+from typing import List
+from .....M2.AUTOSARTemplates.CommonStructure.ServiceNeeds import NvBlockNeeds, RoleBasedDataAssignment, ServiceNeeds
+from .....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
+from .....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import Identifier, RefType
+from .....M2.AUTOSARTemplates.CommonStructure.ServiceNeeds import ServiceDependency
 class RoleBasedPortAssignment(ARObject):
     def __init__(self):
         super().__init__()
@@ -21,3 +23,35 @@ class RoleBasedPortAssignment(ARObject):
     def setRole(self, value):
         self.role = value
         return self
+
+
+class SwcServiceDependency(ServiceDependency):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self._assigned_data = []
+        self._assigned_ports = []
+
+    def AddAssignedData(self, data: RoleBasedDataAssignment):
+        self._assigned_data.append(data)
+
+    def getAssignedData(self) -> List[RoleBasedDataAssignment]:
+        return self._assigned_data
+
+    def AddAssignedPort(self, data: RoleBasedPortAssignment):
+        self._assigned_ports.append(data)
+
+    def getAssignedPorts(self) -> List[RoleBasedPortAssignment]:
+        return self._assigned_ports
+
+    def createNvBlockNeeds(self, short_name: str) -> NvBlockNeeds:
+        if (short_name not in self.elements):
+            event = NvBlockNeeds(self, short_name)
+            self.elements[short_name] = event
+        return self.elements[short_name]
+
+    def getNvBlockNeeds(self) -> List[NvBlockNeeds]:
+        return sorted(filter(lambda c: isinstance(c, NvBlockNeeds), self.elements.values()), key=lambda e: e.short_name)
+
+    def getServiceNeeds(self) -> List[ServiceNeeds]:
+        return sorted(filter(lambda c: isinstance(c, ServiceNeeds), self.elements.values()), key=lambda e: e.short_name)

armodel/models/M2/AUTOSARTemplates/SWComponentTemplate/SwcInternalBehavior/Trigger.py

@@ -1,7 +1,5 @@
-
-from .AccessCount import AbstractAccessPoint
-from ...GenericStructure.GeneralTemplateClasses.ArObject import ARObject
-
+from .....M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.AccessCount import AbstractAccessPoint
+from .....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
 
 class InternalTriggeringPoint(AbstractAccessPoint):
     def __init__(self, parent: ARObject, short_name: str):

armodel/models/M2/AUTOSARTemplates/SWComponentTemplate/SwcInternalBehavior/__init__.py

@@ -1,15 +1,19 @@
-
-from .ServiceMapping import *
-
 from typing import Dict, List
 
-from ...GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARLiteral, RefType, ARBoolean
-from ...SWComponentTemplate.SwcInternalBehavior.DataElements import ParameterAccess, VariableAccess
-from ...SWComponentTemplate.SwcInternalBehavior.ServerCall import ServerCallPoint
-from ...SWComponentTemplate.SwcInternalBehavior.ModeDeclarationGroup import ModeAccessPoint, ModeSwitchPoint
-from ...SWComponentTemplate.SwcInternalBehavior.Trigger import InternalTriggeringPoint
-from ...GenericStructure.GeneralTemplateClasses.ArObject import ARObject
-from ...CommonStructure.InternalBehavior import ExecutableEntity
+from .....M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.PortAPIOptions import PortAPIOption
+from .....M2.AUTOSARTemplates.CommonStructure.InternalBehavior import InternalBehavior
+from .....M2.AUTOSARTemplates.SWComponentTemplate.Datatype.DataPrototypes import ParameterDataPrototype, VariableDataPrototype
+from .....M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.IncludedDataTypes import IncludedDataTypeSet
+from .....M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.PerInstanceMemory import PerInstanceMemory
+from .....M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.RTEEvents import DataReceivedEvent, InitEvent, InternalTriggerOccurredEvent, OperationInvokedEvent, RTEEvent, SwcModeSwitchEvent, TimingEvent
+from .....M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.ServiceMapping import SwcServiceDependency
+from .....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARLiteral, RefType, ARBoolean
+from .....M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.DataElements import ParameterAccess, VariableAccess
+from .....M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.ServerCall import ServerCallPoint
+from .....M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.ModeDeclarationGroup import ModeAccessPoint, ModeSwitchPoint
+from .....M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.Trigger import InternalTriggeringPoint
+from .....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
+from .....M2.AUTOSARTemplates.CommonStructure.InternalBehavior import ExecutableEntity
 
 class RunnableEntityArgument(ARObject):
     def __init__(self):
@@ -200,3 +204,155 @@ class RunnableEntity(ExecutableEntity):
         self.symbol = value
         return self
 
+
+class SwcInternalBehavior(InternalBehavior):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        self.handle_termination_and_restart = None      # type: str
+        self.supports_multiple_instantiation = None     # type: ARBoolean
+        self.explicit_inter_runnable_variables = []     # type: List[VariableDataPrototype]
+        self.implicit_inter_runnable_variables = []     # type: List[VariableDataPrototype]
+        self.per_instance_memories = []                 # type: List[PerInstanceMemory]
+        self.per_instance_parameters = []               # type: List[ParameterDataPrototype]
+        self.port_api_options = []                      # type: List[PortAPIOption]
+        self.included_data_type_sets = []               # type: List[IncludedDataTypeSet]
+
+    def getExplicitInterRunnableVariables(self) -> List[VariableDataPrototype]:
+        return self.explicit_inter_runnable_variables
+
+    def getImplicitInterRunnableVariables(self) -> List[VariableDataPrototype]:
+        return self.implicit_inter_runnable_variables
+
+    def getPerInstanceMemories(self) -> List[PerInstanceMemory]:
+        return self.per_instance_memories
+
+    def getPerInstanceParameters(self) -> List[ParameterDataPrototype]:
+        return self.per_instance_parameters
+
+    def addPortAPIOption(self, option: PortAPIOption):
+        self.port_api_options.append(option)
+
+    def getPortAPIOptions(self) -> List[PortAPIOption]:
+        return self.port_api_options
+
+    def addIncludedDataTypeSet(self, set: IncludedDataTypeSet):
+        self.included_data_type_sets.append(set)
+
+    def getIncludedDataTypeSets(self) -> List[IncludedDataTypeSet]:
+        return self.included_data_type_sets
+
+    def createOperationInvokedEvent(self, short_name: str) -> OperationInvokedEvent:
+        if (short_name not in self.elements):
+            event = OperationInvokedEvent(self, short_name)
+            self.elements[short_name] = event
+        return self.elements[short_name]
+
+    def createTimingEvent(self, short_name: str) -> TimingEvent:
+        if (short_name not in self.elements):
+            event = TimingEvent(self, short_name)
+            self.elements[short_name] = event
+        return self.elements[short_name]
+
+    def createInitEvent(self, short_name: str) -> InitEvent:
+        if (short_name not in self.elements):
+            event = InitEvent(self, short_name)
+            self.elements[short_name] = event
+        return self.elements[short_name]
+
+    def createDataReceivedEvent(self, short_name: str) -> DataReceivedEvent:
+        if (short_name not in self.elements):
+            event = DataReceivedEvent(self, short_name)
+            self.elements[short_name] = event
+        return self.elements[short_name]
+
+    def createSwcModeSwitchEvent(self, short_name: str) -> SwcModeSwitchEvent:
+        if (short_name not in self.elements):
+            event = SwcModeSwitchEvent(self, short_name)
+            self.elements[short_name] = event
+        return self.elements[short_name]
+
+    def createInternalTriggerOccurredEvent(self, short_name: str) -> InternalTriggerOccurredEvent:
+        if (short_name not in self.elements):
+            event = InternalTriggerOccurredEvent(self, short_name)
+            self.elements[short_name] = event
+        return self.elements[short_name]
+
+    def createSwcServiceDependency(self, short_name: str) -> SwcServiceDependency:
+        if (short_name not in self.elements):
+            event = SwcServiceDependency(self, short_name)
+            self.elements[short_name] = event
+        return self.elements[short_name]
+
+    def getRteEvents(self) -> List[RTEEvent]:
+        return sorted(filter(lambda c: isinstance(c, RTEEvent), self.elements.values()), key=lambda e: e.short_name)
+
+    def getOperationInvokedEvents(self) -> List[OperationInvokedEvent]:
+        return sorted(filter(lambda c: isinstance(c, OperationInvokedEvent), self.elements.values()), key=lambda e: e.short_name)
+
+    def getInitEvents(self) -> List[InitEvent]:
+        return sorted(filter(lambda c: isinstance(c, InitEvent), self.elements.values()), key=lambda e: e.short_name)
+
+    def getTimingEvents(self) -> List[TimingEvent]:
+        return sorted(filter(lambda c: isinstance(c, TimingEvent), self.elements.values()), key=lambda e: e.short_name)
+
+    def getDataReceivedEvents(self) -> List[DataReceivedEvent]:
+        return sorted(filter(lambda c: isinstance(c, DataReceivedEvent), self.elements.values()), key=lambda e: e.short_name)
+
+    def getSwcModeSwitchEvents(self) -> List[SwcModeSwitchEvent]:
+        return sorted(filter(lambda c: isinstance(c, SwcModeSwitchEvent), self.elements.values()), key=lambda e: e.short_name)
+
+    def getInternalTriggerOccurredEvents(self) -> List[InternalTriggerOccurredEvent]:
+        return sorted(filter(lambda c: isinstance(c, InternalTriggerOccurredEvent), self.elements.values()), key= lambda e: e.short_name)
+
+    def getSwcServiceDependencies(self) -> List[SwcServiceDependency]:
+        return sorted(filter(lambda c: isinstance(c, SwcServiceDependency), self.elements.values()), key= lambda e: e.short_name)
+
+    def getEvent(self, short_name: str) -> RTEEvent:
+        if (not isinstance(self.elements[short_name], RTEEvent)):
+            raise ValueError("Invalid Event Type <%s> of <%s>" % type(self.elements[short_name]), short_name)
+        return self.elements[short_name]
+
+    def createExplicitInterRunnableVariable(self, short_name: str) -> VariableDataPrototype:
+        if (short_name not in self.elements):
+            prototype = VariableDataPrototype(self, short_name)
+            self.elements[short_name] = prototype
+            self.explicit_inter_runnable_variables.append(prototype)
+        return self.elements[short_name]
+
+    def createImplicitInterRunnableVariable(self, short_name: str) -> VariableDataPrototype:
+        if (short_name not in self.elements):
+            prototype = VariableDataPrototype(self, short_name)
+            self.elements[short_name] = prototype
+            self.implicit_inter_runnable_variables.append(prototype)
+        return self.elements[short_name]
+
+    def createPerInstanceMemory(self, short_name: str) -> PerInstanceMemory:
+        if (short_name not in self.elements):
+            memory = PerInstanceMemory(self, short_name)
+            self.elements[short_name] = memory
+            self.per_instance_memories.append(memory)
+        return self.elements[short_name]
+
+    def createPerInstanceParameter(self, short_name: str) -> ParameterDataPrototype:
+        if (short_name not in self.elements):
+            prototype = ParameterDataPrototype(self, short_name)
+            self.elements[short_name] = prototype
+            self.per_instance_parameters.append(prototype)
+        return self.elements[short_name]
+
+    def getVariableDataPrototypes(self) -> List[VariableDataPrototype]:
+        return sorted(filter(lambda c: isinstance(c, VariableDataPrototype), self.elements.values()), key=lambda e: e.short_name)
+
+    def createRunnableEntity(self, short_name: str) -> RunnableEntity:
+        if (short_name not in self.elements):
+            runnable = RunnableEntity(self, short_name)
+            self.elements[short_name] = runnable
+        return self.elements[short_name]
+
+    def getRunnableEntities(self) -> List[RunnableEntity]:
+        return sorted(filter(lambda c: isinstance(c, RunnableEntity), self.elements.values()), key=lambda r: r.short_name)
+
+    def getRunnableEntity(self, short_name) -> RunnableEntity:
+        return self.elements[short_name]
+

armodel/models/M2/AUTOSARTemplates/SystemTemplate/{data_mapping.py → DataMapping.py}

@@ -1,7 +1,6 @@
 from abc import ABCMeta
-
-from ..GenericStructure.GeneralTemplateClasses.PrimitiveTypes import RefType
-from ..GenericStructure.GeneralTemplateClasses.ArObject import ARObject
+from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import RefType
+from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
 
 class DataMapping(ARObject, metaclass = ABCMeta):
     def __init__(self):

armodel/models/{fibex/can_communication.py → M2/AUTOSARTemplates/SystemTemplate/Fibex/Fibex4Can/CanCommunication.py}

@@ -1,7 +1,6 @@
-from ..M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
-from ..M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import Identifiable
-from ..M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARPositiveInteger
-from .fibex_core.core_communication import Frame, FrameTriggering
+from ......M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.CoreCommunication import Frame, FrameTriggering
+from ......M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
+from ......M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARPositiveInteger
 
 class RxIdentifierRange(ARObject):
     def __init__(self):

armodel/models/M2/AUTOSARTemplates/SystemTemplate/Fibex/Fibex4Can/CanTopology.py

@@ -0,0 +1,173 @@
+from abc import ABCMeta
+
+from ......M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import Boolean, Float, Integer, PositiveInteger, PositiveUnlimitedInteger
+from ......M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
+from ......M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.CoreTopology import CommunicationConnector, CommunicationController
+
+class AbstractCanCommunicationControllerAttributes(ARObject, metaclass = ABCMeta):
+    def __init__(self):
+        super().__init__()
+
+        self.canControllerFdAttributes = None                           # type: CanControllerFdConfiguration
+        self.canControllerFdRequirements = None                         # type: CanControllerFdConfigurationRequirements
+        self.canControllerXlAttributes = None                           # type: CanControllerXlConfiguration
+        self.canControllerXlRequirements = None                         # type: CanControllerXlConfigurationRequirements
+
+    def getCanControllerFdAttributes(self):
+        return self.canControllerFdAttributes
+
+    def setCanControllerFdAttributes(self, value):
+        self.canControllerFdAttributes = value
+        return self
+
+    def getCanControllerFdRequirements(self):
+        return self.canControllerFdRequirements
+
+    def setCanControllerFdRequirements(self, value):
+        self.canControllerFdRequirements = value
+        return self
+
+    def getCanControllerXlAttributes(self):
+        return self.canControllerXlAttributes
+
+    def setCanControllerXlAttributes(self, value):
+        self.canControllerXlAttributes = value
+        return self
+
+    def getCanControllerXlRequirements(self):
+        return self.canControllerXlRequirements
+
+    def setCanControllerXlRequirements(self, value):
+        self.canControllerXlRequirements = value
+        return self
+
+class CanControllerConfigurationRequirements(AbstractCanCommunicationControllerAttributes):
+    def __init__(self):
+        super().__init__()
+
+        self.maxNumberOfTimeQuantaPerBit = None                         # type: Integer
+        self.maxSamplePoint = None                                      # type: Float
+        self.maxSyncJumpWidth = None                                    # type: Float
+        self.minNumberOfTimeQuantaPerBit = None                         # type: Integer
+        self.minSamplePoint = None                                      # type: Float
+        self.minSyncJumpWidth = None                                    # type: Float
+
+    def getMaxNumberOfTimeQuantaPerBit(self):
+        return self.maxNumberOfTimeQuantaPerBit
+
+    def setMaxNumberOfTimeQuantaPerBit(self, value):
+        self.maxNumberOfTimeQuantaPerBit = value
+        return self
+
+    def getMaxSamplePoint(self):
+        return self.maxSamplePoint
+
+    def setMaxSamplePoint(self, value):
+        self.maxSamplePoint = value
+        return self
+
+    def getMaxSyncJumpWidth(self):
+        return self.maxSyncJumpWidth
+
+    def setMaxSyncJumpWidth(self, value):
+        self.maxSyncJumpWidth = value
+        return self
+
+    def getMinNumberOfTimeQuantaPerBit(self):
+        return self.minNumberOfTimeQuantaPerBit
+
+    def setMinNumberOfTimeQuantaPerBit(self, value):
+        self.minNumberOfTimeQuantaPerBit = value
+        return self
+
+    def getMinSamplePoint(self):
+        return self.minSamplePoint
+
+    def setMinSamplePoint(self, value):
+        self.minSamplePoint = value
+        return self
+
+    def getMinSyncJumpWidth(self):
+        return self.minSyncJumpWidth
+
+    def setMinSyncJumpWidth(self, value):
+        self.minSyncJumpWidth = value
+        return self
+
+
+
+class AbstractCanCommunicationController(CommunicationController, metaclass = ABCMeta):
+    def __init__(self, parent: ARObject, short_name: str):
+        if type(self) == AbstractCanCommunicationController:
+            raise NotImplementedError("AbstractCanCommunicationController is an abstract class.")
+        
+        super().__init__(parent, short_name)
+
+        self.canControllerAttributes = None                             # type: AbstractCanCommunicationControllerAttributes
+
+    def getCanControllerAttributes(self):
+        return self.canControllerAttributes
+
+    def setCanControllerAttributes(self, value):
+        self.canControllerAttributes = value
+        return self
+
+class CanCommunicationController(AbstractCanCommunicationController):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+class AbstractCanCommunicationConnector(CommunicationConnector, metaclass = ABCMeta):
+    def __init__(self, parent: ARObject, short_name: str):
+        if type(self) == AbstractCanCommunicationConnector:
+            raise NotImplementedError("AbstractCanCommunicationConnector is an abstract class.")
+        
+        super().__init__(parent, short_name)
+
+class CanCommunicationConnector(AbstractCanCommunicationConnector):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)  
+
+        # type: PositiveInteger
+        self.pncWakeupCanId = None
+        self.pncWakeupCanIdExtended = None                          # type: Boolean
+        # type: PositiveInteger
+        self.pncWakeupCanIdMask = None
+        # type: PositiveUnlimitedInteger
+        self.pncWakeupDataMask = None
+        # type: PositiveInteger
+        self.pncWakeupDlc = None
+
+    def getPncWakeupCanId(self):
+        return self.pncWakeupCanId
+
+    def setPncWakeupCanId(self, value):
+        self.pncWakeupCanId = value
+        return self
+
+    def getPncWakeupCanIdExtended(self):
+        return self.pncWakeupCanIdExtended
+
+    def setPncWakeupCanIdExtended(self, value):
+        self.pncWakeupCanIdExtended = value
+        return self
+
+    def getPncWakeupCanIdMask(self):
+        return self.pncWakeupCanIdMask
+
+    def setPncWakeupCanIdMask(self, value):
+        self.pncWakeupCanIdMask = value
+        return self
+
+    def getPncWakeupDataMask(self):
+        return self.pncWakeupDataMask
+
+    def setPncWakeupDataMask(self, value):
+        self.pncWakeupDataMask = value
+        return self
+
+    def getPncWakeupDlc(self):
+        return self.pncWakeupDlc
+
+    def setPncWakeupDlc(self, value):
+        self.pncWakeupDlc = value
+        return self

armodel/models/M2/AUTOSARTemplates/SystemTemplate/Fibex/Fibex4Ethernet/EthernetFrame.py

@@ -0,0 +1,14 @@
+from abc import ABCMeta
+from ......M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
+from ......M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.CoreCommunication import Frame
+
+class AbstractEthernetFrame(Frame, metaclass = ABCMeta):
+    def __init__(self, parent: ARObject, short_name: str):
+        if type(self) == AbstractEthernetFrame:
+            raise NotImplementedError("AbstractEthernetFrame is an abstract class.")
+        
+        super().__init__(parent, short_name)
+
+class GenericEthernetFrame(AbstractEthernetFrame):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)