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

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
+
+        

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

@@ -0,0 +1,223 @@
+from ......M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import Boolean, RefType, TimeValue
+from ......M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Can.CanCommunication import CanFrameTriggering
+from ......M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Can.CanTopology import CanCommunicationConnector, CanCommunicationController
+from ......M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.CoreCommunication import FibexElement
+from ......M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.CoreTopology import CommunicationConnector, CommunicationController
+from typing import List
+
+class EcuInstance(FibexElement):
+    def __init__(self, parent, short_name):
+        super().__init__(parent, short_name)
+
+        self.associatedComIPduGroupRefs = []                                # type: List[RefType]
+        self.associatedConsumedProvidedServiceInstanceGroupRefs = []        # type: List[RefType]
+        self.associatedPdurIPduGroupRefs = []                               # type: List[RefType]
+        self.channelSynchronousWakeup = None                                # type: Boolean
+        self.clientIdRange = None                                           # type: ClientIdRange
+        self.comConfigurationGwTimeBase = None                              # type: TimeValue
+        self.comConfigurationRxTimeBase = None                              # type: TimeValue
+        self.comConfigurationTxTimeBase = None                              # type: TimeValue
+        self.comEnableMDTForCyclicTransmission = None                       # type: Boolean
+        self.commControllers = []                                           # type: List[CommunicationController]
+        self.connectors = []                                                # type: List[CommunicationConnector]
+        self.dltConfig = None                                               # type: DltConfig
+        self.doIpConfig = None                                              # type: DoIpConfig
+        self.ecuTaskProxyRefs = []                                          # type: List[RefType]
+        self.ethSwitchPortGroupDerivation = None                            # type: Boolean
+        self.firewallRuleRef = None                                         # type: RefType
+        self.partitions = []                                                # type: List[EcuPartition]
+        self.pncNmRequest = None                                            # type: Boolean
+        self.pncPrepareSleepTimer = None                                    # type: TimeValue
+        self.pncSynchronousWakeup = None                                    # type: Boolean
+        self.pnResetTime = None                                             # type: TimeValue
+        self.sleepModeSupported = None                                      # type: Boolean
+        self.tcpIpIcmpPropsRef = None                                       # type: RefType
+        self.tcpIpPropsRef = None                                           # type: RefType
+        self.v2xSupported = None                                            # type: V2xSupportEnum
+        self.wakeUpOverBusSupported = None                                  # type: Boolean
+
+    def getAssociatedComIPduGroupRefs(self):
+        return self.associatedComIPduGroupRefs
+
+    def addAssociatedComIPduGroupRef(self, value):
+        self.associatedComIPduGroupRefs.append(value)
+        return self
+
+    def getAssociatedConsumedProvidedServiceInstanceGroupRefs(self):
+        return self.associatedConsumedProvidedServiceInstanceGroupRefs
+
+    def addAssociatedConsumedProvidedServiceInstanceGroupRef(self, value):
+        self.associatedConsumedProvidedServiceInstanceGroupRefs.append(value)
+        return self
+
+    def getAssociatedPdurIPduGroupRefs(self):
+        return self.associatedPdurIPduGroupRefs
+
+    def addAssociatedPdurIPduGroupRef(self, value):
+        self.associatedPdurIPduGroupRefs.append(value)
+        return self
+
+    def getChannelSynchronousWakeup(self):
+        return self.channelSynchronousWakeup
+
+    def setChannelSynchronousWakeup(self, value):
+        self.channelSynchronousWakeup = value
+        return self
+
+    def getClientIdRange(self):
+        return self.clientIdRange
+
+    def setClientIdRange(self, value):
+        self.clientIdRange = value
+        return self
+
+    def getComConfigurationGwTimeBase(self):
+        return self.comConfigurationGwTimeBase
+
+    def setComConfigurationGwTimeBase(self, value):
+        self.comConfigurationGwTimeBase = value
+        return self
+
+    def getComConfigurationRxTimeBase(self):
+        return self.comConfigurationRxTimeBase
+
+    def setComConfigurationRxTimeBase(self, value):
+        self.comConfigurationRxTimeBase = value
+        return self
+
+    def getComConfigurationTxTimeBase(self):
+        return self.comConfigurationTxTimeBase
+
+    def setComConfigurationTxTimeBase(self, value):
+        self.comConfigurationTxTimeBase = value
+        return self
+
+    def getComEnableMDTForCyclicTransmission(self):
+        return self.comEnableMDTForCyclicTransmission
+
+    def setComEnableMDTForCyclicTransmission(self, value):
+        self.comEnableMDTForCyclicTransmission = value
+        return self
+
+    def getCommControllers(self):
+        return list(sorted(filter(lambda a: isinstance(a, CommunicationController), self.elements.values()), key= lambda o:o.short_name))
+
+    def createCanCommunicationController(self, short_name: str) -> CanCommunicationController:
+        if (short_name not in self.elements):
+            controller = CanCommunicationController(self, short_name)
+            self.elements[short_name] = controller
+        return self.elements[short_name]
+
+    def getConnectors(self):
+        return list(sorted(filter(lambda a: isinstance(a, CommunicationConnector), self.elements.values()), key= lambda o:o.short_name))
+
+    def createCanCommunicationConnector(self, short_name: str) -> CanCommunicationConnector:
+        if (short_name not in self.elements):
+            controller = CanCommunicationConnector(self, short_name)
+            self.elements[short_name] = controller
+        return self.elements[short_name]
+
+    def getDltConfig(self):
+        return self.dltConfig
+
+    def setDltConfig(self, value):
+        self.dltConfig = value
+        return self
+
+    def getDoIpConfig(self):
+        return self.doIpConfig
+
+    def setDoIpConfig(self, value):
+        self.doIpConfig = value
+        return self
+
+    def getEcuTaskProxyRefs(self):
+        return self.ecuTaskProxyRefs
+
+    def setEcuTaskProxyRefs(self, value):
+        self.ecuTaskProxyRefs = value
+        return self
+
+    def getEthSwitchPortGroupDerivation(self):
+        return self.ethSwitchPortGroupDerivation
+
+    def setEthSwitchPortGroupDerivation(self, value):
+        self.ethSwitchPortGroupDerivation = value
+        return self
+
+    def getFirewallRuleRef(self):
+        return self.firewallRuleRef
+
+    def setFirewallRuleRef(self, value):
+        self.firewallRuleRef = value
+        return self
+
+    def getPartitions(self):
+        return self.partitions
+
+    def addPartition(self, value):
+        self.partitions.append(value)
+        return self
+
+    def getPncNmRequest(self):
+        return self.pncNmRequest
+
+    def setPncNmRequest(self, value):
+        self.pncNmRequest = value
+        return self
+
+    def getPncPrepareSleepTimer(self):
+        return self.pncPrepareSleepTimer
+
+    def setPncPrepareSleepTimer(self, value):
+        self.pncPrepareSleepTimer = value
+        return self
+
+    def getPncSynchronousWakeup(self):
+        return self.pncSynchronousWakeup
+
+    def setPncSynchronousWakeup(self, value):
+        self.pncSynchronousWakeup = value
+        return self
+
+    def getPnResetTime(self):
+        return self.pnResetTime
+
+    def setPnResetTime(self, value):
+        self.pnResetTime = value
+        return self
+
+    def getSleepModeSupported(self):
+        return self.sleepModeSupported
+
+    def setSleepModeSupported(self, value):
+        self.sleepModeSupported = value
+        return self
+
+    def getTcpIpIcmpPropsRef(self):
+        return self.tcpIpIcmpPropsRef
+
+    def setTcpIpIcmpPropsRef(self, value):
+        self.tcpIpIcmpPropsRef = value
+        return self
+
+    def getTcpIpPropsRef(self):
+        return self.tcpIpPropsRef
+
+    def setTcpIpPropsRef(self, value):
+        self.tcpIpPropsRef = value
+        return self
+
+    def getV2xSupported(self):
+        return self.v2xSupported
+
+    def setV2xSupported(self, value):
+        self.v2xSupported = value
+        return self
+
+    def getWakeUpOverBusSupported(self):
+        return self.wakeUpOverBusSupported
+
+    def setWakeUpOverBusSupported(self, value):
+        self.wakeUpOverBusSupported = value
+        return self