Index: leahi_dialin/protocols/CAN.py =================================================================== diff -u -r6d104d3185ac3ed7c18c97ecdc13fd59bf53a8d1 -r1f2bf6d939eb4033dbedb7d7005494cc12fccbc6 --- leahi_dialin/protocols/CAN.py (.../CAN.py) (revision 6d104d3185ac3ed7c18c97ecdc13fd59bf53a8d1) +++ leahi_dialin/protocols/CAN.py (.../CAN.py) (revision 1f2bf6d939eb4033dbedb7d7005494cc12fccbc6) @@ -32,7 +32,7 @@ from concurrent.futures import ThreadPoolExecutor -class DenaliMessage: +class CanMessage: BYTE_ORDER = 'little' START_BYTE = 0xA5 START_INDEX = 0 @@ -83,7 +83,7 @@ @classmethod def build_message(cls, channel_id=0, message_id=0, payload=None, seq=None): """ - Builds a Denali message + Builds a CAN message @param channel_id: (int) indicates the channel @param message_id: (int) indicating the request type @@ -94,9 +94,9 @@ if payload is None: payload = [] - message_list = [DenaliCanMessenger.START_BYTE] + message_list = [CanMessenger.START_BYTE] - if 0 <= message_id <= DenaliMessage.MAX_MSG_ID_NUMBER: + if 0 <= message_id <= CanMessage.MAX_MSG_ID_NUMBER: if seq is None: # Wrap sequence number if it hits a max int16 if cls._seq_num >= 32767: @@ -107,13 +107,13 @@ if message_id not in ACK_NOT_REQUIRED: seq *= -1 - message_seq_in_bytes = seq.to_bytes(2, byteorder=DenaliMessage.BYTE_ORDER, signed=True) + message_seq_in_bytes = seq.to_bytes(2, byteorder=CanMessage.BYTE_ORDER, signed=True) message_list += [message_seq_in_bytes[0]] message_list += [message_seq_in_bytes[1]] # Add message ID as unsigned 16-bit # - message_id_in_bytes = message_id.to_bytes(2, byteorder=DenaliMessage.BYTE_ORDER) + message_id_in_bytes = message_id.to_bytes(2, byteorder=CanMessage.BYTE_ORDER) message_list += [message_id_in_bytes[0]] message_list += [message_id_in_bytes[1]] @@ -128,7 +128,7 @@ payload_length = len(payload) # if payload is larger than 255 return nothing - if payload_length <= DenaliMessage.MAX_NUMBER_OF_PAYLOAD_BYTES: + if payload_length <= CanMessage.MAX_NUMBER_OF_PAYLOAD_BYTES: # payload has to be a list message_list += [payload_length] else: @@ -137,11 +137,11 @@ message_list += payload # Because CRC does not include first byte, then we pass a list with out it - message_list += [DenaliMessage.crc8(message_list[1:])] + message_list += [CanMessage.crc8(message_list[1:])] - message_list = DenaliMessage.pad_message_with_zeros(message_list) + message_list = CanMessage.pad_message_with_zeros(message_list) - return DenaliMessage.build_basic_message(channel_id=channel_id, message=message_list) + return CanMessage.build_basic_message(channel_id=channel_id, message=message_list) @staticmethod def crc8(message_list): @@ -154,7 +154,7 @@ crc = 0 for byte in message_list: unsigned_byte = byte ^ crc - crc = DenaliMessage.CRC_LIST[unsigned_byte] + crc = CanMessage.CRC_LIST[unsigned_byte] return crc @@ -169,10 +169,10 @@ message_length = len(message) # message must be multiple of 8 - if message_length % DenaliMessage.PACKET_LENGTH != 0: + if message_length % CanMessage.PACKET_LENGTH != 0: # We need to pad the message with trailing zeros - add_these_many_zeros = math.ceil(message_length / DenaliMessage.PACKET_LENGTH) * \ - DenaliMessage.PACKET_LENGTH - message_length + add_these_many_zeros = math.ceil(message_length / CanMessage.PACKET_LENGTH) * \ + CanMessage.PACKET_LENGTH - message_length message += [0] * add_these_many_zeros @@ -187,7 +187,7 @@ @return:: CRC in message """ - crc_index = DenaliMessage.PAYLOAD_START_INDEX + DenaliMessage.get_payload_length(message) + crc_index = CanMessage.PAYLOAD_START_INDEX + CanMessage.get_payload_length(message) return message['message'][crc_index] @@ -203,9 +203,9 @@ else: message_list = message['message'] - message_length = DenaliMessage.PAYLOAD_START_INDEX + DenaliMessage.get_payload_length(message) - calculated_crc = DenaliMessage.crc8(message_list[1:message_length]) - actual_crc = DenaliMessage.get_crc(message) + message_length = CanMessage.PAYLOAD_START_INDEX + CanMessage.get_payload_length(message) + calculated_crc = CanMessage.crc8(message_list[1:message_length]) + actual_crc = CanMessage.get_crc(message) return calculated_crc == actual_crc @@ -227,8 +227,8 @@ @param message: dictionary containing the message @return:: (int) the sequence number """ - seq = message['message'][DenaliMessage.MSG_SEQ_INDEX:DenaliMessage.MSG_ID_INDEX] - return int.from_bytes(seq, byteorder=DenaliMessage.BYTE_ORDER, signed=True) + seq = message['message'][CanMessage.MSG_SEQ_INDEX:CanMessage.MSG_ID_INDEX] + return int.from_bytes(seq, byteorder=CanMessage.BYTE_ORDER, signed=True) @staticmethod def create_ack_message(message: dict, passive_mode: bool = True): @@ -242,57 +242,57 @@ message = message.copy() seq = struct.unpack('h', bytearray( - message['message'][DenaliMessage.MSG_SEQ_INDEX:DenaliMessage.MSG_ID_INDEX]))[0] + message['message'][CanMessage.MSG_SEQ_INDEX:CanMessage.MSG_ID_INDEX]))[0] # send back empty payload since this is an ACK payload = bytearray() - channel_id_rx = DenaliMessage.get_channel_id(message) + channel_id_rx = CanMessage.get_channel_id(message) if passive_mode: channel_rx_tx_pairs = { - DenaliChannels.td_alarm_broadcast_ch_id: None, - DenaliChannels.dd_alarm_broadcast_ch_id: None, - DenaliChannels.fp_alarm_broadcast_ch_id: None, - DenaliChannels.ui_alarm_broadcast_ch_id: None, - DenaliChannels.td_to_dd_ch_id: None, - DenaliChannels.dd_to_td_ch_id: None, - DenaliChannels.td_to_ui_ch_id: None, - DenaliChannels.td_sync_broadcast_ch_id: None, - DenaliChannels.dd_sync_broadcast_ch_id: None, - DenaliChannels.fp_sync_broadcast_ch_id: None, - DenaliChannels.ui_to_td_ch_id: None, - DenaliChannels.ui_sync_broadcast_ch_id: None, - DenaliChannels.td_to_dialin_ch_id: DenaliChannels.dialin_to_td_ch_id, - DenaliChannels.dd_to_dialin_ch_id: DenaliChannels.dialin_to_dd_ch_id, - DenaliChannels.fp_to_dialin_ch_id: DenaliChannels.dialin_to_fp_ch_id, - DenaliChannels.ui_to_dialin_ch_id: DenaliChannels.dialin_to_ui_ch_id + CanChannels.td_alarm_broadcast_ch_id: None, + CanChannels.dd_alarm_broadcast_ch_id: None, + CanChannels.fp_alarm_broadcast_ch_id: None, + CanChannels.ui_alarm_broadcast_ch_id: None, + CanChannels.td_to_dd_ch_id: None, + CanChannels.dd_to_td_ch_id: None, + CanChannels.td_to_ui_ch_id: None, + CanChannels.td_sync_broadcast_ch_id: None, + CanChannels.dd_sync_broadcast_ch_id: None, + CanChannels.fp_sync_broadcast_ch_id: None, + CanChannels.ui_to_td_ch_id: None, + CanChannels.ui_sync_broadcast_ch_id: None, + CanChannels.td_to_dialin_ch_id: CanChannels.dialin_to_td_ch_id, + CanChannels.dd_to_dialin_ch_id: CanChannels.dialin_to_dd_ch_id, + CanChannels.fp_to_dialin_ch_id: CanChannels.dialin_to_fp_ch_id, + CanChannels.ui_to_dialin_ch_id: CanChannels.dialin_to_ui_ch_id } else: channel_rx_tx_pairs = { - DenaliChannels.td_alarm_broadcast_ch_id: None, - DenaliChannels.dd_alarm_broadcast_ch_id: None, - DenaliChannels.fp_alarm_broadcast_ch_id: None, - DenaliChannels.ui_alarm_broadcast_ch_id: None, - DenaliChannels.td_to_dd_ch_id: DenaliChannels.dialin_to_td_ch_id, - DenaliChannels.dd_to_td_ch_id: DenaliChannels.dialin_to_dd_ch_id, - DenaliChannels.td_to_ui_ch_id: DenaliChannels.dialin_to_td_ch_id, - DenaliChannels.td_sync_broadcast_ch_id: DenaliChannels.dialin_to_td_ch_id, - DenaliChannels.dd_sync_broadcast_ch_id: DenaliChannels.dialin_to_dd_ch_id, - DenaliChannels.fp_sync_broadcast_ch_id: DenaliChannels.dialin_to_fp_ch_id, - DenaliChannels.ui_to_td_ch_id: DenaliChannels.td_to_ui_ch_id, - DenaliChannels.ui_sync_broadcast_ch_id: DenaliChannels.dialin_to_ui_ch_id, - DenaliChannels.td_to_dialin_ch_id: DenaliChannels.dialin_to_td_ch_id, - DenaliChannels.dd_to_dialin_ch_id: DenaliChannels.dialin_to_dd_ch_id, - DenaliChannels.ui_to_dialin_ch_id: DenaliChannels.dialin_to_ui_ch_id + CanChannels.td_alarm_broadcast_ch_id: None, + CanChannels.dd_alarm_broadcast_ch_id: None, + CanChannels.fp_alarm_broadcast_ch_id: None, + CanChannels.ui_alarm_broadcast_ch_id: None, + CanChannels.td_to_dd_ch_id: CanChannels.dialin_to_td_ch_id, + CanChannels.dd_to_td_ch_id: CanChannels.dialin_to_dd_ch_id, + CanChannels.td_to_ui_ch_id: CanChannels.dialin_to_td_ch_id, + CanChannels.td_sync_broadcast_ch_id: CanChannels.dialin_to_td_ch_id, + CanChannels.dd_sync_broadcast_ch_id: CanChannels.dialin_to_dd_ch_id, + CanChannels.fp_sync_broadcast_ch_id: CanChannels.dialin_to_fp_ch_id, + CanChannels.ui_to_td_ch_id: CanChannels.td_to_ui_ch_id, + CanChannels.ui_sync_broadcast_ch_id: CanChannels.dialin_to_ui_ch_id, + CanChannels.td_to_dialin_ch_id: CanChannels.dialin_to_td_ch_id, + CanChannels.dd_to_dialin_ch_id: CanChannels.dialin_to_dd_ch_id, + CanChannels.ui_to_dialin_ch_id: CanChannels.dialin_to_ui_ch_id } channel_id_tx = channel_rx_tx_pairs.get(channel_id_rx, None) if channel_id_tx is None: return None - message = DenaliMessage.build_message( + message = CanMessage.build_message( channel_id=channel_id_tx, message_id=MsgIds.MSG_ID_ACK_MESSAGE_THAT_REQUIRES_ACK.value, payload=payload, @@ -307,9 +307,9 @@ @param message: complete Diality Packet @return:: integer with request ID """ - msg_id_array = message['message'][DenaliMessage.MSG_ID_INDEX: - DenaliMessage.PAYLOAD_LENGTH_INDEX] - return int.from_bytes(msg_id_array, DenaliMessage.BYTE_ORDER) + msg_id_array = message['message'][CanMessage.MSG_ID_INDEX: + CanMessage.PAYLOAD_LENGTH_INDEX] + return int.from_bytes(msg_id_array, CanMessage.BYTE_ORDER) @staticmethod def get_message_id_xstr(message): @@ -319,7 +319,7 @@ @return:: integer with request ID """ msg_id = "" - for index in range(DenaliMessage.MSG_ID_INDEX, DenaliMessage.PAYLOAD_LENGTH_INDEX): + for index in range(CanMessage.MSG_ID_INDEX, CanMessage.PAYLOAD_LENGTH_INDEX): msg_id += "{0:02X}" .format(message['message'][index]) return msg_id @@ -331,7 +331,7 @@ @param message: dictionary with channel_id and message keys @return:: a unsigned payload length """ - return message['message'][DenaliMessage.PAYLOAD_LENGTH_INDEX] + return message['message'][CanMessage.PAYLOAD_LENGTH_INDEX] @staticmethod def get_payload(message): @@ -341,32 +341,32 @@ @param message: dictionary with channel_id and message keys @return:: a payload array if exist """ - payload_length = DenaliMessage.get_payload_length(message) + payload_length = CanMessage.get_payload_length(message) if payload_length == 0: return None else: - return message['message'][DenaliMessage.PAYLOAD_START_INDEX:] + return message['message'][CanMessage.PAYLOAD_START_INDEX:] @staticmethod def get_total_packets(message, is_array=True): """ - Returns the number of packets needed to transmit Denali Message + Returns the number of packets needed to transmit CAN Message @param message: dictionary with channel_id and message keys or raw message @param is_array: True if message is an array and not a dictionary @return:: number of packets """ the_message = message if is_array else message['message'] - return math.ceil((the_message[DenaliMessage.PAYLOAD_LENGTH_INDEX] + - DenaliMessage.HEADER_LENGTH + DenaliMessage.CRC_LENGTH) / - DenaliMessage.PACKET_LENGTH) + return math.ceil((the_message[CanMessage.PAYLOAD_LENGTH_INDEX] + + CanMessage.HEADER_LENGTH + CanMessage.CRC_LENGTH) / + CanMessage.PACKET_LENGTH) -class DenaliChannels: +class CanChannels: """ - Convenience class listing all the possible CAN channels used in the Denali system. + Convenience class listing all the possible CAN channels used in the Diality systems. Updates made to the "Message List.xlsx" document found in the Diality Software Team SharePoint, specifically in the CAN Channels sheet, should also be applied here. """ @@ -394,17 +394,17 @@ ui_to_dialin_ch_id = 0x407 -class LongDenaliMessageBuilder: +class LongMessageBuilder: def __init__(self, message: can.Message): """ - LongDialityMessageBuilder is a utility object that helps construct a Denali message + LongMessageBuilder is a utility object that helps construct a message that is longer than 8 bytes. It is only called when we don't yet have a long message builder for the current channel. Basic principle is to construct an object with the first 8 byte message which contains the length of the message, and the later push the remaining messages. e.g., let's imagine a 3 message packet. - obj = LongDialityMessageBuilder(msg1) + obj = LongMessageBuilder(msg1) message = obj.push(msg2), returns None, message is not complete @@ -413,7 +413,7 @@ @param message: a CAN message """ self.message_data = [b for b in message.data] - self.number_of_can_packets_needed = DenaliMessage.get_total_packets(self.message_data) + self.number_of_can_packets_needed = CanMessage.get_total_packets(self.message_data) self.number_of_can_packets_up_to_now = 1 def push(self, message: can.Message, first_packet=False): @@ -429,7 +429,7 @@ message_data = [b for b in message.data] if first_packet: self.message_data = message_data - self.number_of_can_packets_needed = DenaliMessage.get_total_packets(message_data) + self.number_of_can_packets_needed = CanMessage.get_total_packets(message_data) self.number_of_can_packets_up_to_now = 1 else: @@ -445,16 +445,16 @@ return None -class DenaliCanMessenger(metaclass=SingletonMeta): - START_BYTE = DenaliMessage.START_BYTE +class CanMessenger(metaclass=SingletonMeta): + START_BYTE = CanMessage.START_BYTE DIALIN_MSG_RESP_TO = 0.5 # number of seconds to wait for a response to a send command def __init__(self, can_interface: str, logger: Logger, passive_mode=True, console_out=False): """ - DenaliCanMessenger constructor + CanMessenger constructor @param can_interface - string containing the can interface, e.g., 'can0" @return: DialityCanMessenger object @@ -572,72 +572,72 @@ self.message_queue_mutex.acquire() message: can.Message = self.message_queue.popleft() - if message.dlc == DenaliMessage.PACKET_LENGTH: + if message.dlc == CanMessage.PACKET_LENGTH: # We have received a legit CAN message of 8 bytes can_data = [b for b in message.data] channel_id = message.arbitration_id - if not DenaliMessage.PAYLOAD_LENGTH_INDEX < len(can_data): - self.logger.error("Invalid Denali message received: {0}".format(message)) + if not CanMessage.PAYLOAD_LENGTH_INDEX < len(can_data): + self.logger.error("Invalid CAN message received: {0}".format(message)) self.messages = None # Can't process this message, get the next one self.message_queue_mutex.release() continue else: - message_length = can_data[DenaliMessage.PAYLOAD_LENGTH_INDEX] + message_length = can_data[CanMessage.PAYLOAD_LENGTH_INDEX] # if we are building a long message, then proceed to push it to the channel dictionary if channel_id in self.long_msg_channel_id_set: self.messages = self.long_message_builders[channel_id].push(message) - elif can_data[0] == DenaliMessage.START_BYTE and \ - message_length <= DenaliMessage.PAYLOAD_LENGTH_FIRST_PACKET: # This is a short packet + elif can_data[0] == CanMessage.START_BYTE and \ + message_length <= CanMessage.PAYLOAD_LENGTH_FIRST_PACKET: # This is a short packet # This is the first time that we are building a message self.messages = can_data # deliver the packet elif can_data[0] == self.START_BYTE and \ - message_length > DenaliMessage.PAYLOAD_LENGTH_FIRST_PACKET: # Long packet start + message_length > CanMessage.PAYLOAD_LENGTH_FIRST_PACKET: # Long packet start # We are starting to build a long message, include it in the lonMsgChannelIDSet self.long_msg_channel_id_set.add(channel_id) - # if we don't have a long Denali message builder yet, create it + # if we don't have a long CAN message builder yet, create it if channel_id not in self.long_message_builders.keys(): - self.long_message_builders[channel_id] = LongDenaliMessageBuilder(message) + self.long_message_builders[channel_id] = LongMessageBuilder(message) self.messages = None else: # if we do have a builder. This is the first time self.long_message_builders[channel_id].push(message, first_packet=True) self.messages = None - # Do we have a complete (long or short) Denali Message? + # Do we have a complete (long or short) CAN Message? if self.messages is not None: message_valid = True # assume true for now, set to false if CRC check fails below - complete_dialin_message = DenaliMessage.build_basic_message(channel_id=channel_id, + complete_dialin_message = CanMessage.build_basic_message(channel_id=channel_id, message=self.messages) - dialin_msg_id = DenaliMessage.get_message_id(complete_dialin_message) - dialin_ch_id = DenaliMessage.get_channel_id(complete_dialin_message) + dialin_msg_id = CanMessage.get_message_id(complete_dialin_message) + dialin_ch_id = CanMessage.get_channel_id(complete_dialin_message) # TODO for debugging purposes. Change to configurable setting. #self.temp_dialin_processed_logger.write(str(complete_dialin_message)) if dialin_ch_id in self.long_msg_channel_id_set: # We need to remove channel ID from the long message set self.long_msg_channel_id_set.remove(dialin_ch_id) # Need to verify CRC at this point - if not DenaliMessage.verify_crc(complete_dialin_message): + if not CanMessage.verify_crc(complete_dialin_message): # if verify is False, let's drop (ignore) this message message_valid = False dialin_ch_id = None dialin_msg_id = None self.logger.critical( "Incorrect CRC, received message: {}, crc: {}, calculated crc: {}\n".format( - self.messages, DenaliMessage.get_crc(complete_dialin_message), - DenaliMessage.crc8(self.messages))) + self.messages, CanMessage.get_crc(complete_dialin_message), + CanMessage.crc8(self.messages))) if message_valid: if self.console_out: self.do_console_out(complete_dialin_message) # Send an ack if required - if DenaliMessage.get_sequence_number(complete_dialin_message) < 0: + if CanMessage.get_sequence_number(complete_dialin_message) < 0: # ACK required. Send back the received message with the sequence sign bit flipped - msg = DenaliMessage.create_ack_message(message=complete_dialin_message, + msg = CanMessage.create_ack_message(message=complete_dialin_message, passive_mode=False) if msg is not None: self.send(msg, 0, is_ack=True) @@ -652,7 +652,7 @@ else: self.response_dictionary_mutex.acquire() - if DenaliCanMessenger.is_ui_received_channel(dialin_ch_id): # check if the channel is in ui channels + if CanMessenger.is_ui_received_channel(dialin_ch_id): # check if the channel is in ui channels if self.ui_received_function_ptr is not None: self.thread_pool_executor.submit( self.ui_received_function_ptr, @@ -682,11 +682,11 @@ @return: true, if the channel is the ui channel. """ if channel_id in { - DenaliChannels.ui_to_td_ch_id, - # DenaliChannels.ui_to_dd_ch_id, - DenaliChannels.ui_to_dialin_ch_id, - DenaliChannels.ui_sync_broadcast_ch_id, - DenaliChannels.ui_alarm_broadcast_ch_id + CanChannels.ui_to_td_ch_id, + # Channels.ui_to_dd_ch_id, + CanChannels.ui_to_dialin_ch_id, + CanChannels.ui_sync_broadcast_ch_id, + CanChannels.ui_alarm_broadcast_ch_id }: # check if the channel is in ui channels return True else: @@ -731,13 +731,13 @@ resend: bool = False, is_ack: bool = False): """ - Sends a Denali message + Sends a CAN message @param built_message: (dict) message built using DialinMessage class @param time_out: (float) time it will wait for a response in seconds @param resend: (bool) Allow resending the message when no response is received. Disabled by default @param is_ack: (bool) If we're sending an ACK, False by default - @return: (dict) The Denali packet. If a timeout occurs returns None + @return: (dict) The CAN packet. If a timeout occurs returns None """ data = str(time.time()) + ',' + str(built_message) + '\r' # TODO for debugging purposes. Change to configurable setting. @@ -748,25 +748,25 @@ # keep trying to send message until we get a response while not msg_sent: - channel_id = DenaliMessage.get_channel_id(built_message) + channel_id = CanMessage.get_channel_id(built_message) padded_can_message_array = built_message['message'] - msg_id = DenaliMessage.get_message_id(built_message) + msg_id = CanMessage.get_message_id(built_message) if not is_ack and msg_id not in self.pending_requests: self.pending_requests[msg_id] = None # A message can be longer than 8 bytes, so we need to split it # into 8 bytes packets. - number_of_packets = DenaliMessage.get_total_packets(padded_can_message_array) + number_of_packets = CanMessage.get_total_packets(padded_can_message_array) # We are sending one message at a time on CAN self.transmitting_mutex.acquire() for n in range(number_of_packets): - packet = padded_can_message_array[n * DenaliMessage.PACKET_LENGTH: - (n + 1) * DenaliMessage.PACKET_LENGTH] + packet = padded_can_message_array[n * CanMessage.PACKET_LENGTH: + (n + 1) * CanMessage.PACKET_LENGTH] # Sending one packet at a time packet = can.Message(arbitration_id=channel_id, @@ -841,23 +841,23 @@ @staticmethod def convert_message_to_string(complete_dialin_message: dict) -> str: """ - Converts the DenaliMessage to hex string (data len is not hex) + Converts the CanMessage to hex string (data len is not hex) @param complete_dialin_message: the complete can message in dictionary @return: """ - channel = "{0:03X}" .format(DenaliMessage.get_channel_id(complete_dialin_message)) - msg_id = DenaliMessage.get_message_id_xstr(complete_dialin_message) - data_len = DenaliMessage.get_payload_length(complete_dialin_message) + channel = "{0:03X}" .format(CanMessage.get_channel_id(complete_dialin_message)) + msg_id = CanMessage.get_message_id_xstr(complete_dialin_message) + data_len = CanMessage.get_payload_length(complete_dialin_message) length = "{0:02X}" .format(data_len) data = "" pram_len = 0 if data_len != 0: pram_len = int(data_len / 4) for i in range(pram_len): - data += "{0:02X}".format(complete_dialin_message['message'][DenaliMessage.PAYLOAD_START_INDEX + i ]) - data += "{0:02X}".format(complete_dialin_message['message'][DenaliMessage.PAYLOAD_START_INDEX + i + 1]) - data += "{0:02X}".format(complete_dialin_message['message'][DenaliMessage.PAYLOAD_START_INDEX + i + 2]) - data += "{0:02X}".format(complete_dialin_message['message'][DenaliMessage.PAYLOAD_START_INDEX + i + 3]) + data += "{0:02X}".format(complete_dialin_message['message'][CanMessage.PAYLOAD_START_INDEX + i ]) + data += "{0:02X}".format(complete_dialin_message['message'][CanMessage.PAYLOAD_START_INDEX + i + 1]) + data += "{0:02X}".format(complete_dialin_message['message'][CanMessage.PAYLOAD_START_INDEX + i + 2]) + data += "{0:02X}".format(complete_dialin_message['message'][CanMessage.PAYLOAD_START_INDEX + i + 3]) data += " " message = "{} {} {} {}".format(channel, msg_id, data_len, data) return message @@ -872,11 +872,11 @@ MsgIds.MSG_ID_UI_CHECK_IN.value, MsgIds.MSG_ID_ACK_MESSAGE_THAT_REQUIRES_ACK } - msg_id = DenaliMessage.get_message_id(complete_dialin_message) + msg_id = CanMessage.get_message_id(complete_dialin_message) if msg_id in exception_msg_id: return - message = "# " + DenaliCanMessenger.convert_message_to_string(complete_dialin_message) + message = "# " + CanMessenger.convert_message_to_string(complete_dialin_message) print(message) def register_transmitting_interval_message(self, interval: float, function) ->None: