Squashed commit of the following:

commit 47828b9
Author: juergen <[email protected]>
Date:   Thu May 19 07:59:02 2022 +0200

    some prints removed

commit 494dbc0
Author: juergen <[email protected]>
Date:   Tue May 3 07:37:56 2022 +0200

    preparation to send j1939-22 PGs with Frame-Format FBFF (standard identifiers)

Author: ffcps-juergen-heilgemeir

examples/j1939_22_multi_pg.py

@@ -1,6 +1,7 @@
 import logging
 import time
 import j1939
+from j1939.message_id import FrameFormat
 
 
 logging.getLogger('j1939').setLevel(logging.DEBUG)
@@ -24,7 +25,7 @@ def on_message(priority, pgn, sa, timestamp, data):
     print("PGN {} length {}".format(pgn, len(data)), timestamp)
 
 
-def ca_timer_callback1(ca):
+def ca_timer_callback1(ca : j1939.ControllerApplication):
     """Callback for sending messages
 
     This callback is registered at the ECU timer event mechanism to be
@@ -43,10 +44,13 @@ def ca_timer_callback1(ca):
 
     # sending broadcast message
     # the following two PGNs are packed into one multi-pg, due to time-limit of 10ms and same destination address (global)
-    ca.send_pgn(0, 0xFD, 0xED, 6, data, time_limit=0.01)
-    ca.send_pgn(0, 0xFE, 0x32, 6, data, time_limit=0.01)
+    ca.send_pgn(0, 0xFD, 0xED, 6, data, time_limit=0.01, frame_format=FrameFormat.FBFF)    # Frame-Format FBFF
+    ca.send_pgn(0, 0xFE, 0x32, 6, data, time_limit=0.01, frame_format=FrameFormat.FBFF)    # Frame-Format FBFF
 
-    # sending normal peer-to-peer message, destintion address is 0x04
+    ca.send_pgn(0, 0xFA, 0xED, 6, data, time_limit=0.01)    # Frame-Format FEFF
+    ca.send_pgn(0, 0xFB, 0x32, 6, data, time_limit=0.01)    # Frame-Format FEFF
+
+    # sending peer-to-peer message, destintion address is 0x04
     # the following PGNs are transferred separately, because time limit == 0
     ca.send_pgn(0, 0xE0, 0x04, 6, data)
     ca.send_pgn(0, 0xD0, 0x04, 6, data)
@@ -62,7 +66,7 @@ def main():
     ecu = j1939.ElectronicControlUnit(data_link_layer='j1939-22', max_cmdt_packets=200)
 
     # can fd Baud: 500k/2M
-    ecu.connect(bustype='pcan', channel='PCAN_USBBUS1', fd=True,
+    ecu.connect(bustype='pcan', channel='PCAN_USBBUS3', fd=True,
                         f_clock_mhz=80, nom_brp=10, nom_tseg1=12, nom_tseg2=3, nom_sjw=1, data_brp=4, data_tseg1=7, data_tseg2=2, data_sjw=1)
 
     # subscribe to all (global) messages on the bus

j1939/controller_application.py

@@ -1,5 +1,6 @@
 import logging
 import j1939
+from .message_id import FrameFormat
 
 logger = logging.getLogger(__name__)
 
@@ -246,9 +247,9 @@ def send_message(self, priority, parameter_group_number, data):
             raise RuntimeError("Could not send message unless address claiming has finished")
 
         mid = j1939.MessageId(priority=priority, parameter_group_number=parameter_group_number, source_address=self._device_address)
-        self._ecu.send_message(mid.can_id, data)
+        self._ecu.send_message(mid.can_id, True, data)
 
-    def send_pgn(self, data_page, pdu_format, pdu_specific, priority, data, time_limit=0):
+    def send_pgn(self, data_page, pdu_format, pdu_specific, priority, data, time_limit=0, frame_format=FrameFormat.FEFF):
         """send a pgn
         :param int data_page: data page
         :param int pdu_format: pdu format
@@ -262,7 +263,7 @@ def send_pgn(self, data_page, pdu_format, pdu_specific, priority, data, time_lim
         if self.state != ControllerApplication.State.NORMAL:
             raise RuntimeError("Could not send message unless address claiming has finished")
 
-        return self._ecu.send_pgn(data_page, pdu_format, pdu_specific, priority, self._device_address, data, time_limit)
+        return self._ecu.send_pgn(data_page, pdu_format, pdu_specific, priority, self._device_address, data, time_limit, frame_format)
 
     def send_request(self, data_page, pgn, destination):
         """send a request message
@@ -287,7 +288,7 @@ def _send_address_claimed(self, address):
         pgn = j1939.ParameterGroupNumber(0, 238, j1939.ParameterGroupNumber.Address.GLOBAL)
         mid = j1939.MessageId(priority=6, parameter_group_number=pgn.value, source_address=address)
         data = self._name.bytes
-        self._ecu.send_message(mid.can_id, data)
+        self._ecu.send_message(mid.can_id, True, data)
 
     def on_request(self, src_address, dest_address, pgn):
         """Callback for PGN requests

j1939/electronic_control_unit.py

@@ -8,7 +8,7 @@
 from .parameter_group_number import ParameterGroupNumber
 from .j1939_21 import J1939_21
 from .j1939_22 import J1939_22
-
+from .message_id import FrameFormat
 
 logger = logging.getLogger(__name__)
 
@@ -195,7 +195,7 @@ def remove_ca(self, device_address):
         """
         return self.j1939_dll.remove_ca(device_address)
 
-    def send_pgn(self, data_page, pdu_format, pdu_specific, priority, src_address, data, time_limit=0):
+    def send_pgn(self, data_page, pdu_format, pdu_specific, priority, src_address, data, time_limit=0, frame_format=FrameFormat.FEFF):
         """send a pgn
         :param int data_page: data page
         :param int pdu_format: pdu format
@@ -207,9 +207,9 @@ def send_pgn(self, data_page, pdu_format, pdu_specific, priority, src_address, d
         after this time, the multi-pg will be sent. several pgs can thus be combined in one multi-pg.
         0 or no time-limit means immediate sending.
         """
-        return self.j1939_dll.send_pgn(data_page, pdu_format, pdu_specific, priority, src_address, data, time_limit)
+        return self.j1939_dll.send_pgn(data_page, pdu_format, pdu_specific, priority, src_address, data, time_limit, frame_format)
 
-    def send_message(self, can_id, data, fd_format=False):
+    def send_message(self, can_id, extended_id, data, fd_format=False):
         """Send a raw CAN message to the bus.
 
         This method may be overridden in a subclass if you need to integrate
@@ -229,7 +229,7 @@ def send_message(self, can_id, data, fd_format=False):
 
         if not self._bus:
             raise RuntimeError("Not connected to CAN bus")
-        msg = can.Message(is_extended_id=True,
+        msg = can.Message(is_extended_id=extended_id,
                           arbitration_id=can_id,
                           data=data,
                           is_fd=fd_format,

j1939/j1939_21.py

@@ -92,7 +92,7 @@ def send_pgn(self, data_page, pdu_format, pdu_specific, priority, src_address, d
         if len(data) <= 8:
             # send normal message
             mid = MessageId(priority=priority, parameter_group_number=pgn.value, source_address=src_address)
-            self.__send_message(mid.can_id, data)
+            self.__send_message(mid.can_id, True, data)
         else:
             # if the PF is between 0 and 239, the message is destination dependent when pdu_specific != 255
             # if the PF is between 240 and 255, the message can only be broadcast
@@ -413,42 +413,42 @@ def _process_tp_dt(self, mid, dest_address, data, timestamp):
     def __send_tp_dt(self, src_address, dest_address, data):
         pgn = ParameterGroupNumber(0, 235, dest_address)
         mid = MessageId(priority=7, parameter_group_number=pgn.value, source_address=src_address)
-        self.__send_message(mid.can_id, data)
+        self.__send_message(mid.can_id, True, data)
 
     def __send_tp_abort(self, src_address, dest_address, reason, pgn_value):
         pgn = ParameterGroupNumber(0, 236, dest_address)
         mid = MessageId(priority=7, parameter_group_number=pgn.value, source_address=src_address)
         data = [self.ConnectionMode.ABORT, reason, 0xFF, 0xFF, 0xFF, pgn_value & 0xFF, (pgn_value >> 8) & 0xFF, (pgn_value >> 16) & 0xFF]
-        self.__send_message(mid.can_id, data)
+        self.__send_message(mid.can_id, True, data)
 
     def __send_tp_cts(self, src_address, dest_address, num_packets, next_packet, pgn_value):
         pgn = ParameterGroupNumber(0, 236, dest_address)
         mid = MessageId(priority=7, parameter_group_number=pgn.value, source_address=src_address)
         data = [self.ConnectionMode.CTS, num_packets, next_packet, 0xFF, 0xFF, pgn_value & 0xFF, (pgn_value >> 8) & 0xFF, (pgn_value >> 16) & 0xFF]
-        self.__send_message(mid.can_id, data)
+        self.__send_message(mid.can_id, True, data)
 
     def __send_tp_eom_ack(self, src_address, dest_address, message_size, num_packets, pgn_value):
         pgn = ParameterGroupNumber(0, 236, dest_address)
         mid = MessageId(priority=7, parameter_group_number=pgn.value, source_address=src_address)
         data = [self.ConnectionMode.EOM_ACK, message_size & 0xFF, (message_size >> 8) & 0xFF, num_packets, 0xFF, pgn_value & 0xFF, (pgn_value >> 8) & 0xFF, (pgn_value >> 16) & 0xFF]
-        self.__send_message(mid.can_id, data)
+        self.__send_message(mid.can_id, True, data)
 
     def __send_tp_rts(self, src_address, dest_address, priority, pgn_value, message_size, num_packets, max_cmdt_packets):
         pgn = ParameterGroupNumber(0, 236, dest_address)
         mid = MessageId(priority=priority, parameter_group_number=pgn.value, source_address=src_address)
         data = [self.ConnectionMode.RTS, message_size & 0xFF, (message_size >> 8) & 0xFF, num_packets, max_cmdt_packets, pgn_value & 0xFF, (pgn_value >> 8) & 0xFF, (pgn_value >> 16) & 0xFF]
-        self.__send_message(mid.can_id, data)
+        self.__send_message(mid.can_id, True, data)
 
     def __send_acknowledgement(self, control_byte, group_function_value, address_acknowledged, pgn):
         data = [control_byte, group_function_value, 0xFF, 0xFF, address_acknowledged, (pgn & 0xFF), ((pgn >> 8) & 0xFF), ((pgn >> 16) & 0xFF)]
         mid = MessageId(priority=6, parameter_group_number=0x00E800, source_address=255)
-        self.__send_message(mid.can_id, data)
+        self.__send_message(mid.can_id, True, data)
 
     def __send_tp_bam(self, src_address, priority, pgn_value, message_size, num_packets):
         pgn = ParameterGroupNumber(0, 236, ParameterGroupNumber.Address.GLOBAL)
         mid = MessageId(priority=priority, parameter_group_number=pgn.value, source_address=src_address)
         data = [self.ConnectionMode.BAM, message_size & 0xFF, (message_size >> 8) & 0xFF, num_packets, 0xFF, pgn_value & 0xFF, (pgn_value >> 8) & 0xFF, (pgn_value >> 16) & 0xFF]
-        self.__send_message(mid.can_id, data)
+        self.__send_message(mid.can_id, True, data)
 
     def notify(self, can_id, data, timestamp):
         """Feed incoming CAN message into this ecu.

j1939/j1939_22.py

@@ -1,5 +1,6 @@
+from tkinter import E
 from .parameter_group_number import ParameterGroupNumber
-from .message_id import MessageId
+from .message_id import MessageId, FrameFormat
 import logging
 import time
 import numpy as np
@@ -87,6 +88,8 @@ def __init__(self, send_message, job_thread_wakeup, notify_subscribers, max_cmdt
         # specified time range in j1939-22: 10-200ms
         if minimum_tp_bam_dt_interval == None:
             self._minimum_tp_bam_dt_interval = 0.010
+        else:
+            self._minimum_tp_bam_dt_interval = minimum_tp_bam_dt_interval
 
         # Up to 4 concurrent BAM sessions per originator address are allowed
         self.__bam_session_list = [True] * 4
@@ -113,8 +116,27 @@ def remove_ca(self, device_address):
         return False
 
     def _buffer_hash(self, session_num, src_address, dest_address):
-        """Calcluates a hash value for the given address pair
+        """Calculates a hash value for the given address pair
+
+        :param src_address:
+            The Source-Address the connection should bound to.
+        :param dest_address:
+            The Destination-Address the connection should bound to.
+
+        :return:
+            The calculated hash value.
+
+        :rtype: int
+        """
+        return ((session_num & 0xF) << 16) | ((src_address & 0xFF) << 8) | (dest_address & 0xFF)
 
+    def _buffer_hash_mpg(self, frame_format, msg_counter, src_address, dest_address):
+        """Calculates a hash value for the given multi-pg arguments
+
+        :param frame_format:
+            The frame-format (FBFF, FEFF) the connection should bound to.
+        :param msg_counter:
+            The message counter the connection should bound to.
         :param src_address:
             The Source-Address the connection should bound to.
         :param dest_address:
@@ -125,10 +147,10 @@ def _buffer_hash(self, session_num, src_address, dest_address):
 
         :rtype: int
         """
-        return (((session_num & 0xF) << 16) | (src_address & 0xFF) << 8) | (dest_address & 0xFF)
+        return ((frame_format & 0xFF) << 24) | ((msg_counter & 0xFF) << 16) | ((src_address & 0xFF) << 8) | (dest_address & 0xFF)
 
     def _buffer_unhash(self, hash):
-        """Calcluates session-number, source-address and destination-address for the given hash value
+        """Calculates session-number, source-address and destination-address for the given hash value
 
         :param hash:
             The hash to be unhased
@@ -138,6 +160,17 @@ def _buffer_unhash(self, hash):
         """
         return ((hash >> 16) & 0xFF), ((hash >> 8) & 0xFF), (hash & 0xFF)
 
+    def _buffer_unhash_mpg(self, hash):
+        """Calculates frame_format, msg_counter, source-address and destination-address for the given hash value
+
+        :param hash:
+            The hash to be unhased
+
+        :return:
+            The session-number, source-address and destination-address
+        """
+        return ((hash >> 24) & 0xFF), ((hash >> 16) & 0xFF), ((hash >> 8) & 0xFF), (hash & 0xFF)
+
     def __get_bam_session(self):
         for idx, i in enumerate(self.__bam_session_list):
             if i == True:
@@ -158,7 +191,7 @@ def __get_rts_cts_session(self):
     def __put_rts_cts_session(self, session):
         self.__rts_cts_session_list[session] = True
 
-    def send_pgn(self, data_page, pdu_format, pdu_specific, priority, src_address, data, time_limit=0, tos = 2, trailer_format = 0):
+    def send_pgn(self, data_page, pdu_format, pdu_specific, priority, src_address, data, time_limit, frame_format, tos=2, trailer_format=0):
         pgn = ParameterGroupNumber(data_page, pdu_format, pdu_specific)
         data_length = len(data)
 
@@ -173,17 +206,24 @@ def send_pgn(self, data_page, pdu_format, pdu_specific, priority, src_address, d
                 cpgn = pgn.value
                 dst_address = ParameterGroupNumber.Address.GLOBAL
 
+            if (frame_format==FrameFormat.FBFF):
+                priority = 0
+                if (dst_address!=ParameterGroupNumber.Address.GLOBAL):
+                    logger.info('FBFF message must be a broadcast type')
+                    return False
+
             # create header dict
             cpg = {'priority': (priority & 0x7), 'tos': (tos & 0x7), 'tf': (trailer_format & 0x7), 'cpgn': (cpgn & 0x3FFFF), 'data_length': data_length, 'data': data.copy()}
 
             # send immediately
             if time_limit == 0:
-                self.__send_multi_pg([cpg], src_address, dst_address)
+                self.__send_multi_pg(frame_format, [cpg], src_address, dst_address)
             else:
                 session = 0
                 deadline = time.time() + time_limit
                 while True:
-                    hash = self._buffer_hash(session, src_address, dst_address)
+                    hash = self._buffer_hash_mpg(frame_format, session, src_address, dst_address)
+                    #hash = self._buffer_hash(session, src_address, dst_address)
                     if hash not in self._multi_pg_snd_buffer:
                         self._multi_pg_snd_buffer[hash] = {'deadline': deadline, 'cpg': [cpg], 'fill_level': 4 + data_length}
                         break
@@ -209,13 +249,13 @@ def send_pgn(self, data_page, pdu_format, pdu_specific, priority, src_address, d
                 dest_address = ParameterGroupNumber.Address.GLOBAL
                 session_num = self.__get_bam_session()
                 if session_num == None:
-                    print('bam session not available')
+                    #print('bam session not available')
                     return False
             else:
                 dest_address = pdu_specific
                 session_num = self.__get_rts_cts_session()
                 if session_num == None:
-                    print('rts/cts session not available')
+                    #print('rts/cts session not available')
                     return False
 
             # init sequence
@@ -280,7 +320,7 @@ def send_pgn(self, data_page, pdu_format, pdu_specific, priority, src_address, d
 
         return True
 
-    def __send_multi_pg(self, cpg_list, src_address, dst_address):
+    def __send_multi_pg(self, frame_format, cpg_list, src_address, dst_address):
         # deadline reached
         priority = 7
         data = []
@@ -306,10 +346,13 @@ def __send_multi_pg(self, cpg_list, src_address, dst_address):
             else:
                 data.append(0xAA)
 
-        mid = MessageId(priority=priority,
-                        parameter_group_number=ParameterGroupNumber.PGN.FEFF_MULTI_PG | (dst_address & 0xFF),
-                        source_address=src_address)
-        self.__send_message(mid.can_id, data, fd_format=True)
+        if frame_format == FrameFormat.FBFF:
+            self.__send_message(src_address, False, data, fd_format=True)
+        else:
+            mid = MessageId(priority=priority,
+                            parameter_group_number=ParameterGroupNumber.PGN.FEFF_MULTI_PG | (dst_address & 0xFF),
+                            source_address=src_address)
+            self.__send_message(mid.can_id, True, data, fd_format=True)
 
 
     def async_job_thread(self, now):
@@ -345,9 +388,9 @@ def async_job_thread(self, now):
                     next_wakeup = buf['deadline']
             else:
                 # deadline reached
-                session_num, src_address, dst_address = self._buffer_unhash(bufid)
+                frame_format, session_num, src_address, dst_address = self._buffer_unhash_mpg(bufid)
 
-                self.__send_multi_pg(buf['cpg'], src_address, dst_address)
+                self.__send_multi_pg(frame_format, buf['cpg'], src_address, dst_address)
 
                 del self._multi_pg_snd_buffer[bufid]
 
@@ -717,7 +760,7 @@ def __send_tp_cm(self,  src_address, dest_address,
         data[10] = ( (pgn >> 8) & 0xFF )
         data[11] = ( (pgn >> 16) & 0xFF )
         # 13 up to 64 Assurance Data of full message calculated using AD Type. Total length = Size in byte 8.
-        self.__send_message(mid.can_id, data, fd_format=True)
+        self.__send_message(mid.can_id, True, data, fd_format=True)
 
     def __send_tp_dt(self, src_address, dest_address, session_num, segment_num, data, Dtfi=0):
         pgn = ParameterGroupNumber(0, (ParameterGroupNumber.PGN.FD_TP_DT>>8) & 0xFF, dest_address)
@@ -739,7 +782,7 @@ def __send_tp_dt(self, src_address, dest_address, session_num, segment_num, data
             while len(data)<next_valid_fd_length:
                 data.append(255)
 
-        self.__send_message(mid.can_id, data, fd_format=True)
+        self.__send_message(mid.can_id, True, data, fd_format=True)
 
 
     def notify(self, can_id, data, timestamp):

j1939/version.py

@@ -1 +1 @@
-__version__ = "2.0.8"
+__version__ = "2.0.9"