python-can-j1939 0.1.0__py3-none-any.whl

j1939/name.py

@@ -0,0 +1,268 @@
+
+class Name:
+    """The Name of one Controller Application.
+
+    The Name consists of 64 bit:
+
+        1-bit Arbitrary Address Capable
+        Indicate the capability to solve address conflicts.
+        Set to 1 if the device is Arbitrary Address Capable, set to 0 if
+        it's Single Address Capable.
+
+        3-bit Industry Group
+        One of the predefined J1939 industry groups.
+
+        4-bit Vehicle System Instance
+        Instance number of a vehicle system to distinguish two or more
+        device with the same Vehicle System number in the same J1939
+        network.
+        The first instance is assigned to the instance number 0.
+
+        7-bit Vehicle System
+        A subcomponent of a vehicle, that includes one or more J1939
+        segments and may be connected or disconnected from the vehicle.
+        A Vehicle System may be made of one or more functions. The Vehicle
+        System depends on the Industry Group definition.
+
+        1-bit Reserved
+        This field is reserved for future use by SAE.
+
+        8-bit Function
+        One of the predefined J1939 functions. The same function value
+        (upper 128 only) may mean different things for different Industry
+        Groups or Vehicle Systems.
+
+        5-bit Function Instance
+        Instance number of a function to distinguish two or more devices
+        with the same function number in the same J1939 network.
+        The first instance is assigned to the instance number 0.
+
+        3-bit ECU Instance
+        Identify the ECU instance if multiple ECUs are involved in
+        performing a single function. Normally set to 0.
+
+        11-bit Manufacturer Code
+        One of the predefined J1939 manufacturer codes.
+
+        21-bit Identity Number
+        A unique number which identifies the particular device in a
+        manufacturer specific way.
+    """
+
+    class IndustryGroup:
+        Global = 0
+        OnHighway = 1
+        AgriculturalAndForestry = 2
+        Construction = 3
+        Marine = 4
+        Industrial = 5
+
+    def __init__(self, **kwargs):
+        """
+        :param value:
+            64-bit value the address should be extracted from
+
+        :param bytes:
+            Array of 8 bytes containing the name object as binary representation.
+
+        :param arbitrary_address_capable:
+            1-bit Arbitrary Address Capable
+            Indicate the capability to solve address conflicts.
+            Set to 1 if the device is Arbitrary Address Capable, set to 0 if
+            it's Single Address Capable.
+        :param industry_group:
+            3-bit Industry Group
+            One of the predefined J1939 industry groups.
+        :param vehicle_system_instance:
+            4-bit Vehicle System Instance
+            Instance number of a vehicle system to distinguish two or more
+            device with the same Vehicle System number in the same J1939
+            network.
+            The first instance is assigned to the instance number 0.
+        :param vehicle_system:
+            7-bit Vehicle System
+            A subcomponent of a vehicle, that includes one or more J1939
+            segments and may be connected or disconnected from the vehicle.
+            A Vehicle System may be made of one or more functions. The Vehicle
+            System depends on the Industry Group definition.
+        :param function:
+            8-bit Function
+            One of the predefined J1939 functions. The same function value
+            (upper 128 only) may mean different things for different Industry
+            Groups or Vehicle Systems.
+        :param function_instance:
+            5-bit Function Instance
+            Instance number of a function to distinguish two or more devices
+            with the same function number in the same J1939 network.
+            The first instance is assigned to the instance number 0.
+        :param ecu_instance:
+            3-bit ECU Instance
+            Identify the ECU instance if multiple ECUs are involved in
+            performing a single function. Normally set to 0.
+        :param manufacturer_code:
+            11-bit Manufacturer Code
+            One of the predefined J1939 manufacturer codes.
+        :param identity_number:
+            21-bit Identity Number
+            A unique number which identifies the particular device in a
+            manufacturer specific way.
+        """
+        if 'value' in kwargs:
+            self.value = kwargs['value']
+        elif 'bytes' in kwargs:
+            self.bytes = kwargs['bytes']
+        else:
+            self.arbitrary_address_capable = kwargs.get('arbitrary_address_capable', False)
+            if (self.arbitrary_address_capable < 0) or (self.arbitrary_address_capable > 1):
+                raise ValueError("Length of arbitrary address capable incorrect")
+            self.industry_group = kwargs.get('industry_group', Name.IndustryGroup.Global)
+            if (self.industry_group < 0) or (self.industry_group > ((2 ** 3) - 1)):
+                raise ValueError("Length of industry group incorrect")
+            self.vehicle_system_instance = kwargs.get('vehicle_system_instance', 0)
+            if (self.vehicle_system_instance < 0) or (self.vehicle_system_instance > ((2 ** 4) - 1)):
+                raise ValueError("Length of vehicle system instance incorrect")
+            self.vehicle_system = kwargs.get('vehicle_system', 0)
+            if (self.vehicle_system < 0) or (self.vehicle_system > ((2 ** 7) - 1)):
+                raise ValueError("Length of vehicle system incorrect")
+            self.function = kwargs.get('function', 0)
+            if (self.function < 0) or (self.function > ((2 ** 8) - 1)):
+                raise ValueError("Length of function incorrect")
+            self.function_instance = kwargs.get('function_instance', 0)
+            if (self.function_instance < 0) or (self.function_instance > ((2 ** 5) - 1)):
+                raise ValueError("Length of function instance incorrect")
+            self.ecu_instance = kwargs.get('ecu_instance', 0)
+            if (self.ecu_instance < 0) or (self.ecu_instance > ((2 ** 3) - 1)):
+                raise ValueError("Length of ecu instance incorrect")
+            self.manufacturer_code = kwargs.get('manufacturer_code', 0)
+            if (self.manufacturer_code < 0) or (self.manufacturer_code > ((2 ** 11) - 1)):
+                raise ValueError("Length of manufacturer code incorrect")
+            self.identity_number = kwargs.get('identity_number', 0)
+            if (self.identity_number < 0) or (self.identity_number > ((2 ** 21) - 1)):
+                raise ValueError("Length of identity number incorrect")
+
+        self.reserved_bit = 0
+
+    @property
+    def arbitrary_address_capable(self):
+        return self.__arbitrary_address_capable
+
+    @arbitrary_address_capable.setter
+    def arbitrary_address_capable(self, value):
+        self.__arbitrary_address_capable = value
+
+    @property
+    def industry_group(self):
+        return self.__industry_group
+
+    @industry_group.setter
+    def industry_group(self, value):
+        self.__industry_group = value
+
+    @property
+    def vehicle_system_instance(self):
+        return self.__vehicle_system_instance
+
+    @vehicle_system_instance.setter
+    def vehicle_system_instance(self, value):
+        self.__vehicle_system_instance = value
+
+    @property
+    def vehicle_system(self):
+        return self.__vehicle_system
+
+    @vehicle_system.setter
+    def vehicle_system(self, value):
+        self.__vehicle_system = value
+
+    @property
+    def reserved_bit(self):
+        return self.__reserved_bit
+
+    @reserved_bit.setter
+    def reserved_bit(self, value):
+        self.__reserved_bit = value
+
+    @property
+    def function(self):
+        return self.__function
+
+    @function.setter
+    def function(self, value):
+        self.__function = value
+
+    @property
+    def function_instance(self):
+        return self.__function_instance
+
+    @function_instance.setter
+    def function_instance(self, value):
+        self.__function_instance = value
+
+    @property
+    def ecu_instance(self):
+        return self.__ecu_instance
+
+    @ecu_instance.setter
+    def ecu_instance(self, value):
+        self.__ecu_instance = value
+
+    @property
+    def manufacturer_code(self):
+        return self.__manufacturer_code
+
+    @manufacturer_code.setter
+    def manufacturer_code(self, value):
+        self.__manufacturer_code = value
+
+    @property
+    def identity_number(self):
+        return self.__identity_number
+
+    @identity_number.setter
+    def identity_number(self, value):
+        self.__identity_number = value
+
+    @property
+    def value(self):
+        retval = self.identity_number
+        retval += (self.manufacturer_code << 21)
+        retval += (self.ecu_instance << 32)
+        retval += (self.function_instance << 35)
+        retval += (self.function << 40)
+        retval += (self.reserved_bit << 48)
+        retval += (self.vehicle_system << 49)
+        retval += (self.vehicle_system_instance << 56)
+        retval += (self.industry_group << 60)
+        retval += (self.arbitrary_address_capable << 63)
+        return retval
+
+    @value.setter
+    def value(self, value):
+        self.identity_number = value & ((2 ** 21) - 1)
+        self.manufacturer_code = (value >> 21) & ((2 ** 11) - 1)
+        self.ecu_instance = (value >> 32) & ((2 ** 3) - 1)
+        self.function_instance = (value >> 35) & ((2 ** 5) - 1)
+        self.function = (value >> 40) & ((2 ** 8) - 1)
+        self.reserved_bit = (value >> 48) & 1
+        self.vehicle_system = (value >> 49) & ((2 ** 7) - 1)
+        self.vehicle_system_instance = (value >> 56) & ((2 ** 4) - 1)
+        self.industry_group = (value >> 60) & ((2 ** 3) - 1)
+        self.arbitrary_address_capable = (value >> 63) & 1
+
+    @property
+    def bytes(self):
+        """Get the Name object as 8 Byte Data"""
+        return [
+            ((self.value >>  0) & 0xFF),
+            ((self.value >>  8) & 0xFF),
+            ((self.value >> 16) & 0xFF),
+            ((self.value >> 24) & 0xFF),
+            ((self.value >> 32) & 0xFF),
+            ((self.value >> 40) & 0xFF),
+            ((self.value >> 48) & 0xFF),
+            ((self.value >> 56) & 0xFF)
+        ]
+
+    @bytes.setter
+    def bytes(self, value):
+        self.value = int.from_bytes(value, byteorder='little', signed=False)

j1939/parameter_group_number.py

@@ -0,0 +1,136 @@
+import j1939
+
+class ParameterGroupNumber:
+    """Parameter Group Number (PGN).
+
+    The PGN are described in SAE J1939/21 and consists of four parts:
+      * 1-bit Reserved (sometimes referred to as Extended Data Page)
+      * 1-bit Data Page (DP)
+      * 8-bit PDU Format (PF)
+      * 8-bit PDU Specific (PS)
+
+    Predefined PGNs are listed in SAE J1939 and SAE J1939/71
+
+    A PF value from 0 to 239 (PDU1) indicates a destination address (DA) in PS
+    (peer-to-peer communication). A PF value from 240 to 255 (PDU2) indicates
+    a Group Extension (GE) inside the PS (broadcast message).
+    The DA 255 is called the Global Destination Address. It requires all nodes
+    to listen to and to respond, if required.
+
+    TODO: naming/wording: according the standard, a PGN in PDU1 format always
+          sets the 8 Bit PS to 0.
+          Do we have to separate this object to reflect this rule. And if we
+          have to, how to name the other PGN object?
+    """
+
+    class PGN:
+        FEFF_MULTI_PG       =  9472  # 2500
+        FD_TP_CM            = 19712  # 4D00
+        FD_TP_DT            = 19968  # 4E00
+
+        REQUEST             = 59904  # EA00
+        #ACKNOWLEDGEMENT    = 59392
+        ADDRESSCLAIM        = 60928  # EE00
+        DATATRANSFER        = 60160  # EB00
+        TP_CM               = 60416  # EC00
+        #COMMANDED_ADDRESS  = 65240
+        #PROPRIETARY_A      = 61184
+        #SOFTWARE_IDENT     = 65242
+        # Diagnostic messages
+        DM01	            = 65226  # FECA
+        DM02	            = 65227  # FECB
+        DM03	            = 65228  # FECC
+        DM04	            = 65229  # FECD
+        DM05	            = 65230  # FECE
+        DM06	            = 65231  # FECF
+        DM07	            = 58112  # E300
+        DM08	            = 65232  # FED0
+        DM10                = 65234  # FED2
+        DM11                = 65235  # FED3
+        DM12                = 65236  # FED4
+        DM13                = 57088  # DF00
+        DM14                = 55552  # D900
+        DM15                = 55296  # D800
+        DM16                = 55040  # D700
+        DM17                = 54784  # D600
+        DM18                = 54272  # D400
+        DM19                = 54016  # D300
+        DM20                = 49664  # C200
+        DM21                = 49408  # C100
+        DM22                = 49920  # C300
+        DM23                = 64949  # FDB5
+        DM24                = 64950  # FDB6
+        DM25                = 64951  # FDB7
+        DM26                = 64952  # FDB8
+        DM27                = 64898  # FD82
+        DM28                = 64896  # FD80
+        DM29                = 40448  # 9E00
+        DM30                = 41984  # A400
+        DM31                = 41728  # A300
+        DM32                = 41472  # A200
+        DM33                = 41216  # A100
+        DM34                = 40960  # A000
+        DM35                = 40704  # 9F00
+        DM36                = 64868  # FD64
+        DM37                = 64867  # FD63
+        DM38                = 64866  # FD62
+        DM39                = 64865  # FD61
+        DM40                = 64864  # FD60
+        DM41                = 64863  # FD5F
+        DM42                = 64862  # FD5E
+        DM43                = 64861  # FD5D
+        DM44                = 64860  # FD5C
+        DM45                = 64859  # FD5B
+        DM46                = 64858  # FD5A
+        DM47                = 64857  # FD59
+        DM48                = 64856  # FD58
+        DM49                = 64855  # FD57
+        DM50                = 64854  # FD56
+        DM51                = 64853  # FD55
+        DM52                = 64852  # FD54
+        DM53                = 64721  # FCD1
+        DM54                = 64722  # FCD2
+        DM55                = 64723  # FCD3
+        DM56                = 64711  # FCC7
+        DM57                = 64710  # FCC6
+
+    class Address:
+        NULL                = 254
+        GLOBAL              = 255
+
+    def __init__(self, data_page=0, pdu_format=0, pdu_specific=0):
+        """
+        :param data_page:
+            1-bit Data Page
+        :param pdu_format:
+            8-bit PDU Format
+        :param pdu_specific:
+            8-bit PDU Specific
+        """
+        self.data_page = data_page & 0x01
+        self.pdu_format = pdu_format & 0xFF
+        self.pdu_specific = pdu_specific & 0xFF
+
+    @property
+    def is_pdu1_format(self):
+        """Indicates Peer-to-Peer communication"""
+        return True if self.pdu_format>=0 and self.pdu_format<=239 else False
+
+    @property
+    def is_pdu2_format(self):
+        """Indicates broadcast communication"""
+        return True if self.pdu_format>=240 and self.pdu_format<=255 else False
+
+    def from_message_id(self, mid):
+        """Fills in the object from a MessageId given"""
+        if not isinstance(mid, j1939.MessageId):
+            raise ValueError("the parameter mid must be an instance of MessageId")
+
+        self.data_page = (mid.parameter_group_number >> 16) & 0x01
+        self.pdu_format = (mid.parameter_group_number >> 8) & 0xFF
+        self.pdu_specific = mid.parameter_group_number & 0xFF
+
+    @property
+    def value(self):
+        """Returns the value of the PGN"""
+        return (self.data_page << 16) | (self.pdu_format << 8) | self.pdu_specific

j1939/version.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"