armodel 1.7.6__py3-none-any.whl → 1.7.8__py3-none-any.whl

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

@@ -1,22 +1,77 @@
 from abc import ABCMeta
 from enum import Enum
 from typing import List
+
+from ......M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Flexray.FlexrayCommunication import FlexrayFrameTriggering
+from ......M2.AUTOSARTemplates.CommonStructure.Filter import DataFilter
 from ......M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.ArObject import ARObject
-from ......M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import ARFloat, Boolean, PositiveInteger, PositiveUnlimitedInteger, RefType, ARLiteral, TimeValue
 from ......M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.Identifiable import Identifiable
+from ......M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import AREnum, ARFloat, Boolean, Integer, PositiveInteger
+from ......M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import PositiveUnlimitedInteger, RefType, ARLiteral, TimeValue
 from ......M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Can.CanCommunication import CanFrameTriggering
 from ......M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Lin.LinCommunication import LinFrameTriggering, LinScheduleTable
-from ......M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.CoreCommunication import FibexElement, FrameTriggering, ISignalTriggering, PduTriggering
 from ......M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Ethernet.NetworkEndpoint import NetworkEndpoint
+from ......M2.AUTOSARTemplates.SystemTemplate.Fibex.FibexCore.CoreCommunication import FibexElement, FrameTriggering, ISignalTriggering, PduTriggering
+
+
+class CommunicationCycle(ARObject):
+    def __init__(self):
+        super().__init__()
+
+
+class CycleCounter(CommunicationCycle):
+    def __init__(self):
+        super().__init__()
+
+        self.CycleCounter = None                            # type: Integer
+
+    def getCycleCounter(self):
+        return self.CycleCounter
+
+    def setCycleCounter(self, value):
+        if value is not None:
+            self.CycleCounter = value
+        return self
+
+
+class CycleRepetitionType(AREnum):
+    def __init__(self):
+        super().__init__([])
+
+
+class CycleRepetition(CommunicationCycle):
+    def __init__(self):
+        super().__init__()
+
+        self.BaseCycle = None                               # type: Integer
+        self.CycleRepetition = None                         # type: CycleRepetitionType
+
+    def getBaseCycle(self):
+        return self.BaseCycle
+
+    def setBaseCycle(self, value):
+        if value is not None:
+            self.BaseCycle = value
+        return self
+
+    def getCycleRepetition(self):
+        return self.CycleRepetition
+
+    def setCycleRepetition(self, value):
+        if value is not None:
+            self.CycleRepetition = value
+        return self
 
-class PhysicalChannel (Identifiable, metaclass = ABCMeta):
+
+class PhysicalChannel (Identifiable, metaclass=ABCMeta):
     def __init__(self, parent: ARObject, short_name: str):
-        if type(self) == PhysicalChannel:
+        if type(self) is PhysicalChannel:
             raise NotImplementedError("PhysicalChannel is an abstract class.")
         
         super().__init__(parent, short_name)
 
         self.commConnectorRefs = []                     # type: List[RefType]
+        self.frameTriggerings = []                      # type: List[FrameTriggering]
         self.managedPhysicalChannelRefs = []            # type: List[RefType]
 
     def getCommConnectorRefs(self):
@@ -27,22 +82,31 @@ 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.getShortName()))
+        return list(sorted(filter(lambda a: isinstance(a, FrameTriggering), self.elements.values()), key=lambda o: o.getShortName()))
 
-    def createCanFrameTriggering(self, short_name: str):
+    def createCanFrameTriggering(self, short_name: str) -> CanFrameTriggering:
         if (short_name not in self.elements):
             triggering = CanFrameTriggering(self, short_name)
             self.addElement(triggering)
+            self.frameTriggerings.append(triggering)
         return self.getElement(short_name)
     
-    def createLinFrameTriggering(self, short_name: str):
+    def createLinFrameTriggering(self, short_name: str) -> LinFrameTriggering:
         if (short_name not in self.elements):
             triggering = LinFrameTriggering(self, short_name)
             self.addElement(triggering)
+            self.frameTriggerings.append(triggering)
+        return self.getElement(short_name)
+    
+    def createFlexrayFrameTriggering(self, short_name: str) -> FlexrayFrameTriggering:
+        if (short_name not in self.elements):
+            triggering = FlexrayFrameTriggering(self, short_name)
+            self.addElement(triggering)
+            self.frameTriggerings.append(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.getShortName()))
+        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):
@@ -58,7 +122,7 @@ 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.getShortName()))
+        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):
@@ -66,16 +130,19 @@ class PhysicalChannel (Identifiable, metaclass = ABCMeta):
             self.addElement(triggering)
         return self.getElement(short_name)
 
-class AbstractCanPhysicalChannel(PhysicalChannel, metaclass = ABCMeta):
+
+class AbstractCanPhysicalChannel(PhysicalChannel, metaclass=ABCMeta):
     def __init__(self, parent, short_name):
-        if type(self) == ARObject:
+        if type(self) is AbstractCanPhysicalChannel:
             raise NotImplementedError("AbstractCanPhysicalChannel is an abstract class.")
          
         super().__init__(parent, short_name)
 
+
 class CanPhysicalChannel(AbstractCanPhysicalChannel):
     def __init__(self, parent, short_name):
-        super().__init__(parent, short_name) 
+        super().__init__(parent, short_name)
+
 
 class LinPhysicalChannel(PhysicalChannel):
     def __init__(self, parent: ARObject, short_name: str):
@@ -96,13 +163,14 @@ class LinPhysicalChannel(PhysicalChannel):
     def getScheduleTables(self):
         return self.scheduleTables
 
-    def createLinScheduleTable(self, short_name:str) -> LinScheduleTable:
+    def createLinScheduleTable(self, short_name: str) -> LinScheduleTable:
         if (short_name not in self.elements):
             end_point = LinScheduleTable(self, short_name)
             self.addElement(end_point)
             self.scheduleTables.append(end_point)
         return self.getElement(short_name)
-    
+
+
 class VlanConfig(Identifiable):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
@@ -116,6 +184,8 @@ class VlanConfig(Identifiable):
         if value is not None:
             self.vlanIdentifier = value
         return self
+
+
 class EthernetPhysicalChannel(PhysicalChannel):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
@@ -127,7 +197,7 @@ class EthernetPhysicalChannel(PhysicalChannel):
     def getNetworkEndpoints(self):
         return self.networkEndpoints
 
-    def createNetworkEndPoint(self, short_name:str) -> NetworkEndpoint:
+    def createNetworkEndPoint(self, short_name: str) -> NetworkEndpoint:
         if (short_name not in self.elements):
             end_point = NetworkEndpoint(self, short_name)
             self.addElement(end_point)
@@ -149,18 +219,46 @@ class EthernetPhysicalChannel(PhysicalChannel):
             config = VlanConfig(self, short_name)
             self.vlan = config
             self.addElement(config)
-        return self.getElement(short_name)  
+        return self.getElement(short_name)
+
 
-class CommunicationCluster(FibexElement, metaclass = ABCMeta):
+class FlexrayChannelName(AREnum):
+    CHANNEL_A = "channelA"
+    channel_B = "channelB"
+
+    def __init__(self):
+        super().__init__([
+            FlexrayChannelName.CHANNEL_A,
+            FlexrayChannelName.channel_B
+        ])
+
+
+class FlexrayPhysicalChannel(PhysicalChannel):
     def __init__(self, parent: ARObject, short_name: str):
-        if type(self) == CommunicationCluster:
+        super().__init__(parent, short_name)
+
+        self.channelName = None                                     # type: FlexrayChannelName
+
+    def getChannelName(self):
+        return self.channelName
+
+    def setChannelName(self, value):
+        if value is not None:
+            self.channelName = value
+        return self
+
+
+class CommunicationCluster(FibexElement, metaclass=ABCMeta):
+    def __init__(self, parent: ARObject, short_name: str):
+        if type(self) is CommunicationCluster:
             raise NotImplementedError("CommunicationCluster is an abstract class.")
         
         super().__init__(parent, short_name)
 
-        self.baudrate = None                # type: ARFloat
-        self.protocolName = None            # type: ARLiteral
-        self.protocolVersion = None         # type: ARLiteral
+        self.baudrate = None                    # type: ARFloat
+        self.physicalChannel = []               # type: List[PhysicalChannel]
+        self.protocolName = None                # type: ARLiteral
+        self.protocolVersion = None             # type: ARLiteral
 
     def getBaudrate(self):
         return self.baudrate
@@ -170,33 +268,43 @@ 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.getShortName()))
+        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.getShortName()))
+        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.getShortName()))
+        return list(sorted(filter(lambda a: isinstance(a, LinPhysicalChannel), self.elements.values()), key=lambda o: o.getShortName()))
     
     def getEthernetPhysicalChannels(self) -> List[EthernetPhysicalChannel]:
-        return list(sorted(filter(lambda a: isinstance(a, EthernetPhysicalChannel), self.elements.values()), key= lambda o:o.getShortName()))
+        return list(sorted(filter(lambda a: isinstance(a, EthernetPhysicalChannel), 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.addElement(channel)
+            self.physicalChannel.append(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.addElement(channel)
+            self.physicalChannel.append(channel)
         return self.getElement(short_name)
     
     def createEthernetPhysicalChannel(self, short_name: str):
         if (short_name not in self.elements):
             channel = EthernetPhysicalChannel(self, short_name)
             self.addElement(channel)
+            self.physicalChannel.append(channel)
+        return self.getElement(short_name)
+    
+    def createFlexrayPhysicalChannel(self, short_name: str):
+        if (short_name not in self.elements):
+            channel = FlexrayPhysicalChannel(self, short_name)
+            self.addElement(channel)
+            self.physicalChannel.append(channel)
         return self.getElement(short_name)
 
     def getProtocolName(self):
@@ -212,7 +320,8 @@ class CommunicationCluster(FibexElement, metaclass = ABCMeta):
     def setProtocolVersion(self, value):
         self.protocolVersion = value
         return self
-    
+
+
 class CanClusterBusOffRecovery(ARObject):
     def __init__(self):
         super().__init__()
@@ -263,9 +372,10 @@ class CanClusterBusOffRecovery(ARObject):
             self.mainFunctionPeriod = value
         return self
 
-class AbstractCanCluster(CommunicationCluster, metaclass = ABCMeta):
+
+class AbstractCanCluster(CommunicationCluster, metaclass=ABCMeta):
     def __init__(self, parent: ARObject, short_name: str):
-        if type(self) == AbstractCanCluster:
+        if type(self) is AbstractCanCluster:
             raise NotImplementedError("AbstractCanCluster is an abstract class.")
         
         super().__init__(parent, short_name)
@@ -303,17 +413,20 @@ class AbstractCanCluster(CommunicationCluster, metaclass = ABCMeta):
         self.speed = value
         return self
 
+
 class CanCluster(AbstractCanCluster):
     def __init__(self, parent: ARObject, short_name: str):
-        super().__init__(parent, short_name)         
+        super().__init__(parent, short_name)
+
 
 class LinCluster(CommunicationCluster):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
 
-class CommunicationController(Identifiable, metaclass = ABCMeta):
+
+class CommunicationController(Identifiable, metaclass=ABCMeta):
     def __init__(self, parent: ARObject, short_name: str):
-        if type(self) == CommunicationController:
+        if type(self) is CommunicationController:
             raise NotImplementedError("CommunicationController is an abstract class.")
         
         super().__init__(parent, short_name)
@@ -326,19 +439,22 @@ class CommunicationController(Identifiable, metaclass = ABCMeta):
     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):
+
+class CommConnectorPort(Identifiable, metaclass=ABCMeta):
     def __init__(self, parent: ARObject, short_name: str):
-        if type(self) == CommConnectorPort:
+        if type(self) is CommConnectorPort:
             raise NotImplementedError("CommConnectorPort is an abstract class.")
         
         super().__init__(parent, short_name)
@@ -358,9 +474,11 @@ 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"        
+    ENUM_IMMEDIATE = "immediate"
+
 
 class IPduPort(CommConnectorPort):
     def __init__(self, parent: ARObject, short_name: str):
@@ -412,6 +530,7 @@ class IPduPort(CommConnectorPort):
             self.useAuthDataFreshness = value
         return self
 
+
 class ISignalPort(CommConnectorPort):
     def __init__(self, parent: ARObject, short_name: str):
         super().__init__(parent, short_name)
@@ -462,9 +581,10 @@ class ISignalPort(CommConnectorPort):
             self.timeout = value
         return self
 
-class CommunicationConnector(Identifiable, metaclass = ABCMeta):
+
+class CommunicationConnector(Identifiable, metaclass=ABCMeta):
     def __init__(self, parent: ARObject, short_name: str):
-        if type(self) == CommunicationConnector:
+        if type(self) is CommunicationConnector:
             raise NotImplementedError("CommunicationConnector is an abstract class.")
         
         super().__init__(parent, short_name)
@@ -498,7 +618,7 @@ class CommunicationConnector(Identifiable, metaclass = ABCMeta):
         return self
 
     def getEcuCommPortInstances(self):
-        return list(sorted(filter(lambda a: isinstance(a, CommConnectorPort), self.elements.values()), key= lambda o:o.getShortName()))
+        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:
@@ -534,5 +654,3 @@ class CommunicationConnector(Identifiable, metaclass = ABCMeta):
     def setPncGatewayType(self, value):
         self.pncGatewayType = value
         return self
-
-        

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

@@ -4,6 +4,7 @@ from ......M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Can.CanCommunication i
 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 ......M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Flexray.FlexrayTopology import FlexrayCommunicationConnector, FlexrayCommunicationController
 from ......M2.AUTOSARTemplates.SystemTemplate.Fibex.Fibex4Lin.LinTopology import LinCommunicationConnector, LinMaster
 from typing import List
 
@@ -22,6 +23,7 @@ class EcuInstance(FibexElement):
         self.comEnableMDTForCyclicTransmission = None                       # type: Boolean
         self.commControllers = []                                           # type: List[CommunicationController]
         self.connectors = []                                                # type: List[CommunicationConnector]
+        self.diagnosticAddress = None                                       # type: Integer             ## Only AR 4.3.1
         self.dltConfig = None                                               # type: DltConfig
         self.doIpConfig = None                                              # type: DoIpConfig
         self.ecuTaskProxyRefs = []                                          # type: List[RefType]
@@ -105,43 +107,63 @@ class EcuInstance(FibexElement):
         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):
+        if (not self.IsElementExists(short_name)):
             controller = CanCommunicationController(self, short_name)
             self.addElement(controller)
         return self.getElement(short_name)
     
     def createEthernetCommunicationController(self, short_name: str) -> EthernetCommunicationController:
-        if (short_name not in self.elements):
+        if (not self.IsElementExists(short_name)):
             controller = EthernetCommunicationController(self, short_name)
             self.addElement(controller)
         return self.getElement(short_name)
     
     def createLinMaster(self, short_name: str) -> LinMaster:
-        if (short_name not in self.elements):
+        if (not self.IsElementExists(short_name)):
             controller = LinMaster(self, short_name)
             self.addElement(controller)
         return self.getElement(short_name)
+    
+    def createFlexrayCommunicationController(self, short_name: str) -> FlexrayCommunicationController:
+        if (not self.IsElementExists(short_name)):
+            controller = FlexrayCommunicationController(self, short_name)
+            self.addElement(controller)
+        return self.getElement(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):
+        if (not self.IsElementExists(short_name)):
             connector = CanCommunicationConnector(self, short_name)
             self.addElement(connector)
         return self.getElement(short_name)
     
     def createEthernetCommunicationConnector(self, short_name: str) -> EthernetCommunicationConnector:
-        if (short_name not in self.elements):
+        if (not self.IsElementExists(short_name)):
             connector = EthernetCommunicationConnector(self, short_name)
             self.addElement(connector)
         return self.getElement(short_name)
     
     def createLinCommunicationConnector(self, short_name: str) -> LinCommunicationConnector:
-        if (short_name not in self.elements):
+        if (not self.IsElementExists(short_name)):
             connector = LinCommunicationConnector(self, short_name)
             self.addElement(connector)
         return self.getElement(short_name)
+    
+    def createFlexrayCommunicationConnector(self, short_name: str) -> FlexrayCommunicationConnector:
+        if (not self.IsElementExists(short_name)):
+            connector = FlexrayCommunicationConnector(self, short_name)
+            self.addElement(connector)
+        return self.getElement(short_name)
+    
+    def getDiagnosticAddress(self):
+        return self.diagnosticAddress
+
+    def setDiagnosticAddress(self, value):
+        if value is not None:
+            self.diagnosticAddress = value
+        return self
 
     def getDltConfig(self):
         return self.dltConfig

armodel/models/M2/AUTOSARTemplates/SystemTemplate/InstanceRefs.py

@@ -2,6 +2,7 @@ from typing import List
 from ....M2.AUTOSARTemplates.GenericStructure.GeneralTemplateClasses.PrimitiveTypes import RefType
 from ....M2.AUTOSARTemplates.GenericStructure.AbstractStructure import AtpInstanceRef
 
+
 class VariableDataPrototypeInSystemInstanceRef(AtpInstanceRef):
     def __init__(self):
         super().__init__()
@@ -47,6 +48,7 @@ class VariableDataPrototypeInSystemInstanceRef(AtpInstanceRef):
         self.targetDataPrototypeRef = value
         return self
 
+
 class ComponentInSystemInstanceRef(AtpInstanceRef):
     def __init__(self):
         super().__init__()