armodel 1.6.4__py3-none-any.whl → 1.7.1__py3-none-any.whl

armodel/models/M2/AUTOSARTemplates/SWComponentTemplate/Communication.py

@@ -1,14 +1,27 @@
 from abc import ABCMeta
 from typing import List
+from ....M2.MSR.DataDictionary.DataDefProperties import SwDataDefProps
+from ....M2.AUTOSARTemplates.CommonStructure import ValueSpecification
+from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
+from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import AREnum, ARLiteral, ARNumerical, ARPositiveInteger
+from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARBoolean
+from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import RefType
+from ....M2.AUTOSARTemplates.SWComponentTemplate.PortInterface.InstanceRefs import ApplicationCompositeElementInPortInterfaceInstanceRef
+
+class HandleInvalidEnum(AREnum):
+    DONT_INVALIDATE = "dontInvalidate"
+    EXTERNAL_REPLACEMENT = "externalReplacement"
+    KEEP = "keep"
+    REPLACE = "replace"
 
-from armodel.models.M2.AUTOSARTemplates.SWComponentTemplate.PortInterface.InstanceRefs import ApplicationCompositeElementInPortInterfaceInstanceRef
-
-from ..GenericStructure.GeneralTemplateClasses.ArObject import ARObject
-from ..GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARLiteral, ARNumerical, ARPositiveInteger
-from ..GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARBoolean
-from ..GenericStructure.GeneralTemplateClasses.PrimitiveTypes import RefType
-from ...MSR.DataDictionary.DataDefProperties import SwDataDefProps
-from ..CommonStructure import ValueSpecification
+    def __init__(self):
+        super().__init__((
+            HandleInvalidEnum.DONT_INVALIDATE,
+            HandleInvalidEnum.EXTERNAL_REPLACEMENT,
+            HandleInvalidEnum.KEEP,
+            HandleInvalidEnum.REPLACE
+        ))
+    
 
 class PPortComSpec(ARObject, metaclass = ABCMeta):
     """

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

@@ -1,3 +1,5 @@
+from armodel.models.M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARLiteral, RefType
+from typing import List
 from .....M2.AUTOSARTemplates.SWComponentTemplate.RPTScenario import ModeAccessPointIdent
 from .....M2.AUTOSARTemplates.SWComponentTemplate.Components.InstanceRefs import PModeGroupInAtomicSwcInstanceRef, RModeGroupInAtomicSWCInstanceRef
 from .....M2.AUTOSARTemplates.SWComponentTemplate.SwcInternalBehavior.AccessCount import AbstractAccessPoint
@@ -36,3 +38,25 @@ class ModeSwitchPoint(AbstractAccessPoint):
     def setModeGroupIRef(self, value):
         self.modeGroupIRef = value
         return self
+
+
+class IncludedModeDeclarationGroupSet(ARObject):
+    def __init__(self):
+        super().__init__()
+
+        self.mode_declaration_group_refs = []           # type: List[RefType]
+        self.prefix = None                              # type: ARLiteral
+
+    def addModeDeclarationGroupRef(self, ref: RefType):
+        self.mode_declaration_group_refs.append(ref)
+        return self
+
+    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

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

@@ -176,7 +176,7 @@ class RunnableEntity(ExecutableEntity):
         if (short_name not in self.elements):
             point = InternalTriggeringPoint(self, short_name)
             self.elements[point.short_name] = point
-        return self.elements[point.short_name]
+        return self.elements[short_name]
 
     def getInternalTriggeringPoints(self) -> List[InternalTriggeringPoint]:
         return filter(lambda o: isinstance(o, InternalTriggeringPoint), self.elements)

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/Fibex4Multiplatform.py

@@ -1,6 +1,6 @@
 from typing import List
 
-from .....M2.MSR.Documentation.BlockElements import DocumentationBlock
+from ....MSR.Documentation.TextModel.BlockElements import DocumentationBlock
 from .....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
 from .....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import RefType
 from .....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARPositiveInteger

armodel/models/M2/AUTOSARTemplates/SystemTemplate/Fibex/FibexCore/CoreCommunication.py

@@ -1,9 +1,11 @@
 from abc import ABCMeta
 from typing import List
 
-from ....GenericStructure.GeneralTemplateClasses.Identifiable import ARElement, Identifiable, Describable
-from ....GenericStructure.GeneralTemplateClasses.ArObject import ARObject
-from ....GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARLiteral, ARNumerical, ARPositiveInteger, RefType, ARBoolean
+from armodel.models.M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.Timing import TransmissionModeDeclaration
+
+from ......M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import ARElement, Identifiable, Describable
+from ......M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
+from ......M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARLiteral, ARNumerical, ARPositiveInteger, RefType, ARBoolean, TimeValue
 
 class FibexElement(Identifiable, metaclass = ABCMeta):
     def __init__(self, parent: ARObject, short_name: str):
@@ -279,14 +281,12 @@ class DcmIPdu(IPdu):
         self.diagPduType = value
         return self
 
-
 class IPduTiming(Describable):
     def __init__(self):
         super().__init__()
 
         self.minimumDelay = None                                # type: TimeValue
-        # type: TransmissionModeDeclaration
-        self.transmissionModeDeclaration = None
+        self.transmissionModeDeclaration = None                 # type: TransmissionModeDeclaration
 
     def getMinimumDelay(self):
         return self.minimumDelay

armodel/models/M2/AUTOSARTemplates/SystemTemplate/Fibex/FibexCore/CoreTopology.py

@@ -1,10 +1,13 @@
 from abc import ABCMeta
+from enum import Enum
 from typing import List
+
+from ......M2.AUTOSARTemplates.SWComponentTemplate.Communication import HandleInvalidEnum
 from ......M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Can.CanCommunication import CanFrameTriggering
 from ......M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Lin.LinCommunication import LinFrameTriggering
 from ......M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.CoreCommunication import FibexElement, FrameTriggering, ISignalTriggering, PduTriggering
 from ......M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
-from ......M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARFloat, RefType, ARLiteral
+from ......M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARFloat, Boolean, PositiveInteger, RefType, ARLiteral, TimeValue
 from ......M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import Identifiable
 
 class PhysicalChannel (Identifiable, metaclass = ABCMeta):
@@ -25,29 +28,28 @@ class PhysicalChannel (Identifiable, metaclass = ABCMeta):
         return self
 
     def getFrameTriggerings(self) -> List[FrameTriggering]:
-        return list(sorted(filter(lambda a: isinstance(a, FrameTriggering), self.elements.values()), key= lambda o:o.short_name))
+        return list(sorted(filter(lambda a: isinstance(a, FrameTriggering), self.elements.values()), key= lambda o:o.getShortName()))
 
     def createCanFrameTriggering(self, short_name: str):
         if (short_name not in self.elements):
-            channel = CanFrameTriggering(self, short_name)
-            self.elements[short_name] = channel
-        return self.elements[short_name]
+            triggering = CanFrameTriggering(self, short_name)
+            self.addElement(triggering)
+        return self.getElement(short_name)
     
     def createLinFrameTriggering(self, short_name: str):
         if (short_name not in self.elements):
-            channel = LinFrameTriggering(self, short_name)
-            self.elements[short_name] = channel
-        return self.elements[short_name]
+            triggering = LinFrameTriggering(self, short_name)
+            self.addElement(triggering)
+        return self.getElement(short_name)
 
     def getISignalTriggerings(self) -> List[ISignalTriggering]:
-        return list(sorted(filter(lambda a: isinstance(a, ISignalTriggering), self.elements.values()), key= lambda o:o.short_name))
+        return list(sorted(filter(lambda a: isinstance(a, ISignalTriggering), self.elements.values()), key= lambda o:o.getShortName()))
 
     def createISignalTriggering(self, short_name: str):
         if (short_name not in self.elements):
-            channel = ISignalTriggering(self, short_name)
-            self.elements[short_name] = channel
-        return self.elements[short_name]
-    
+            triggering = ISignalTriggering(self, short_name)
+            self.addElement(triggering)
+        return self.getElement(short_name)
 
     def getManagedPhysicalChannelRefs(self):
         return self.managedPhysicalChannelRefs
@@ -57,13 +59,13 @@ class PhysicalChannel (Identifiable, metaclass = ABCMeta):
         return self
     
     def getPduTriggerings(self) -> List[PduTriggering]:
-        return list(sorted(filter(lambda a: isinstance(a, PduTriggering), self.elements.values()), key= lambda o:o.short_name))
+        return list(sorted(filter(lambda a: isinstance(a, PduTriggering), self.elements.values()), key= lambda o:o.getShortName()))
 
     def createPduTriggering(self, short_name: str):
         if (short_name not in self.elements):
-            channel = PduTriggering(self, short_name)
-            self.elements[short_name] = channel
-        return self.elements[short_name]
+            triggering = PduTriggering(self, short_name)
+            self.addElement(triggering)
+        return self.getElement(short_name)
 
 class AbstractCanPhysicalChannel(PhysicalChannel, metaclass = ABCMeta):
     def __init__(self, parent, short_name):
@@ -99,25 +101,25 @@ class CommunicationCluster(FibexElement, metaclass = ABCMeta):
         return self
 
     def getPhysicalChannels(self) -> List[PhysicalChannel]:
-        return list(sorted(filter(lambda a: isinstance(a, PhysicalChannel), self.elements.values()), key= lambda o:o.short_name))
+        return list(sorted(filter(lambda a: isinstance(a, PhysicalChannel), self.elements.values()), key= lambda o:o.getShortName()))
     
     def getCanPhysicalChannels(self) -> List[CanPhysicalChannel]:
-        return list(sorted(filter(lambda a: isinstance(a, CanPhysicalChannel), self.elements.values()), key= lambda o:o.short_name))
+        return list(sorted(filter(lambda a: isinstance(a, CanPhysicalChannel), self.elements.values()), key= lambda o:o.getShortName()))
     
     def getLinPhysicalChannels(self) -> List[LinPhysicalChannel]:
-        return list(sorted(filter(lambda a: isinstance(a, LinPhysicalChannel), self.elements.values()), key= lambda o:o.short_name))
+        return list(sorted(filter(lambda a: isinstance(a, LinPhysicalChannel), self.elements.values()), key= lambda o:o.getShortName()))
     
     def createCanPhysicalChannel(self, short_name: str):
         if (short_name not in self.elements):
             channel = CanPhysicalChannel(self, short_name)
-            self.elements[short_name] = channel
-        return self.elements[short_name]
+            self.addElement(channel)
+        return self.getElement(short_name)
     
     def createLinPhysicalChannel(self, short_name: str):
         if (short_name not in self.elements):
             channel = LinPhysicalChannel(self, short_name)
-            self.elements[short_name] = channel
-        return self.elements[short_name]
+            self.addElement(channel)
+        return self.getElement(short_name)
 
     def getProtocolName(self):
         return self.protocolName
@@ -143,6 +145,7 @@ class AbstractCanCluster(CommunicationCluster, metaclass = ABCMeta):
         self.busOffRecovery = None
         self.canFdBaudrate = None
         self.canXlBaudrate = None
+        self.speed = None
 
     def getBusOffRecovery(self):
         return self.busOffRecovery
@@ -165,6 +168,12 @@ class AbstractCanCluster(CommunicationCluster, metaclass = ABCMeta):
         self.canXlBaudrate = value
         return self
 
+    def getSpeed(self):
+        return self.speed
+
+    def setSpeed(self, value):
+        self.speed = value
+        return self
 
 class CanCluster(AbstractCanCluster):
     def __init__(self, parent: ARObject, short_name: str):
@@ -172,8 +181,208 @@ class CanCluster(AbstractCanCluster):
 
 class LinCluster(CommunicationCluster):
     def __init__(self, parent: ARObject, short_name: str):
-        super().__init__(parent, short_name)                 
+        super().__init__(parent, short_name)
+
+class CommunicationController(Identifiable, metaclass = ABCMeta):
+    def __init__(self, parent: ARObject, short_name: str):
+        if type(self) == CommunicationController:
+            raise NotImplementedError("CommunicationController is an abstract class.")
+        
+        super().__init__(parent, short_name)
 
-class EcuInstance(FibexElement):
-    def __init__(self, parent, short_name):
-        super().__init__(parent, short_name)    
+        self.wakeUpByControllerSupported = None                         # type: Boolean
+
+    def getWakeUpByControllerSupported(self):
+        return self.wakeUpByControllerSupported
+
+    def setWakeUpByControllerSupported(self, value):
+        self.wakeUpByControllerSupported = value
+        return self
+    
+class PncGatewayTypeEnum(Enum):
+    ENUM_ACTIVE = "active"
+    ENUM_NONE = "none"
+    ENUM_PASSIVE = "passive"
+
+class CommunicationDirectionType(Enum):
+    ENUM_IN = "in"
+    ENUM_OUT = "out"
+
+class CommConnectorPort(Identifiable, metaclass = ABCMeta):
+    def __init__(self, parent: ARObject, short_name: str):
+        if type(self) == CommConnectorPort:
+            raise NotImplementedError("CommConnectorPort is an abstract class.")
+        
+        super().__init__(parent, short_name)
+
+        # type: CommunicationDirectionType
+        self.communicationDirection = None
+
+    def getCommunicationDirection(self) -> CommunicationDirectionType:
+        return self.communicationDirection
+
+    def setCommunicationDirection(self, value: CommunicationDirectionType):
+        self.communicationDirection = value
+        return self
+
+
+class FramePort(CommConnectorPort):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+class IPduSignalProcessingEnum(Enum):
+    ENUM_DEFERRED = "deferred"
+    ENUM_IMMEDIATE = "immediate"        
+
+class IPduPort(CommConnectorPort):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+
+        # type: IPduSignalProcessingEnum
+        self.iPduSignalProcessing = None
+        self.rxSecurityVerification = None                              # type: Boolean
+        self.timestampRxAcceptanceWindow = None                         # type: TimeValue
+        self.useAuthDataFreshness = None                                # type: Boolean
+
+    def getIPduSignalProcessing(self):
+        return self.iPduSignalProcessing
+
+    def setIPduSignalProcessing(self, value):
+        self.iPduSignalProcessing = value
+        return self
+
+    def getRxSecurityVerification(self):
+        return self.rxSecurityVerification
+
+    def setRxSecurityVerification(self, value):
+        self.rxSecurityVerification = value
+        return self
+
+    def getTimestampRxAcceptanceWindow(self):
+        return self.timestampRxAcceptanceWindow
+
+    def setTimestampRxAcceptanceWindow(self, value):
+        self.timestampRxAcceptanceWindow = value
+        return self
+
+    def getUseAuthDataFreshness(self):
+        return self.useAuthDataFreshness
+
+    def setUseAuthDataFreshness(self, value):
+        self.useAuthDataFreshness = value
+        return self
+
+class ISignalPort(CommConnectorPort):
+    def __init__(self, parent: ARObject, short_name: str):
+        super().__init__(parent, short_name)
+        
+        # type: DataFilter
+        self.dataFilter = None
+        self.ddsQosProfileRef = None                                    # type: RefType
+        # type: TimeValue
+        self.firstTimeout = None
+        # type: HandleInvalidEnum
+        self.handleInvalid = None
+
+    def getDataFilter(self):
+        return self.dataFilter
+
+    def setDataFilter(self, value):
+        self.dataFilter = value
+        return self
+
+    def getDdsQosProfileRef(self):
+        return self.ddsQosProfileRef
+
+    def setDdsQosProfileRef(self, value):
+        self.ddsQosProfileRef = value
+        return self
+
+    def getFirstTimeout(self):
+        return self.firstTimeout
+
+    def setFirstTimeout(self, value):
+        self.firstTimeout = value
+        return self
+
+    def getHandleInvalid(self):
+        return self.handleInvalid
+
+    def setHandleInvalid(self, value):
+        self.handleInvalid = value
+        return self
+
+class CommunicationConnector(Identifiable, metaclass = ABCMeta):
+    def __init__(self, parent: ARObject, short_name: str):
+        if type(self) == CommunicationConnector:
+            raise NotImplementedError("CommunicationConnector is an abstract class.")
+        
+        super().__init__(parent, short_name)
+
+        self.commControllerRef = None                                   # type: RefType
+        self.createEcuWakeupSource = None                               # type: Boolean
+        self.dynamicPncToChannelMappingEnabled = None                   # type: Boolean
+        self.ecuCommPortInstances = []                                  # type: List[CommConnectorPort]
+        self.pncFilterArrayMasks = []                                   # type: List[PositiveInteger]
+        self.pncGatewayType = None                                      # type: PncGatewayTypeEnum
+
+    def getCommControllerRef(self):
+        return self.commControllerRef
+
+    def setCommControllerRef(self, value):
+        self.commControllerRef = value
+        return self
+
+    def getCreateEcuWakeupSource(self):
+        return self.createEcuWakeupSource
+
+    def setCreateEcuWakeupSource(self, value):
+        self.createEcuWakeupSource = value
+        return self
+
+    def getDynamicPncToChannelMappingEnabled(self):
+        return self.dynamicPncToChannelMappingEnabled
+
+    def setDynamicPncToChannelMappingEnabled(self, value):
+        self.dynamicPncToChannelMappingEnabled = value
+        return self
+
+    def getEcuCommPortInstances(self):
+        return list(sorted(filter(lambda a: isinstance(a, CommConnectorPort), self.elements.values()), key= lambda o:o.getShortName()))
+
+    def createFramePort(self, short_name) -> FramePort:
+        if short_name not in self.elements:
+            port = FramePort(self, short_name)
+            self.addElement(port)
+            self.ecuCommPortInstances.append(port)
+        return self.getElement(short_name)
+
+    def createIPduPort(self, short_name) -> IPduPort:
+        if short_name not in self.elements:
+            port = IPduPort(self, short_name)
+            self.addElement(port)
+            self.ecuCommPortInstances.append(port)
+        return self.getElement(short_name)
+    
+    def createISignalPort(self, short_name) -> ISignalPort:
+        if short_name not in self.elements:
+            port = ISignalPort(self, short_name)
+            self.addElement(port)
+            self.ecuCommPortInstances.append(port)
+        return self.getElement(short_name)
+
+    def getPncFilterArrayMasks(self):
+        return self.pncFilterArrayMasks
+
+    def addPncFilterArrayMask(self, value):
+        self.pncFilterArrayMasks.append(value)
+        return self
+
+    def getPncGatewayType(self):
+        return self.pncGatewayType
+
+    def setPncGatewayType(self, value):
+        self.pncGatewayType = value
+        return self
+
+