From 694f5a364aca44c36e1d52be85cb3ea47ad8930a Mon Sep 17 00:00:00 2001 From: TIM ANDERSON Date: Wed, 18 Nov 2026 20:37:14 +1000 Subject: [PATCH] Read classic and FD frame flags from CANFD ASC records --- can/io/asc.py | 42 +++++++++++++++++++++++++---------------- test/logformats_test.py | 33 ++++++++++++++++++++++++++++---- 2 files changed, 55 insertions(+), 20 deletions(-) diff --git a/can/io/asc.py b/can/io/asc.py index be1e05b05..0a7dc46a8 100644 --- a/can/io/asc.py +++ b/can/io/asc.py @@ -21,6 +21,8 @@ CAN_MSG_EXT = 0x80000000 CAN_ID_MASK = 0x1FFFFFFF +ASC_FLAG_REMOTE_FRAME = 0x10 +ASC_FLAG_FD_FRAME = 0x1000 BASE_HEX = 16 BASE_DEC = 10 ASC_TRIGGER_REGEX: Final = re.compile( @@ -189,14 +191,10 @@ def _check_base(base: str) -> int: raise ValueError('base should be either "hex" or "dec"') return BASE_DEC if base == "dec" else BASE_HEX - def _process_data_string( - self, data_str: str, data_length: int, msg_kwargs: dict[str, Any] - ) -> None: - frame = bytearray() - data = data_str.split() - for byte in data[:data_length]: - frame.append(int(byte, self._converted_base)) - msg_kwargs["data"] = frame + def _parse_data(self, fields: list[str], data_length: int) -> bytearray: + return bytearray( + int(byte, self._converted_base) for byte in fields[:data_length] + ) def _process_classic_can_frame( self, line: str, msg_kwargs: dict[str, Any] @@ -230,7 +228,7 @@ def _process_classic_can_frame( dlc = dlc2len(int(dlc_str, self._converted_base)) msg_kwargs["dlc"] = dlc - self._process_data_string(data, min(8, dlc), msg_kwargs) + msg_kwargs["data"] = self._parse_data(data.split(), min(8, dlc)) return Message(**msg_kwargs) @@ -259,12 +257,25 @@ def _process_fd_can_frame(self, line: str, msg_kwargs: dict[str, Any]) -> Messag ) self._extract_can_id(can_id_str, msg_kwargs) - msg_kwargs["bitrate_switch"] = brs == "1" - msg_kwargs["error_state_indicator"] = esi == "1" dlc = int(dlc_str, self._converted_base) data_length = int(data_length_str) - if data_length == 0: - # CAN remote Frame + fields = data.split() + # The CANFD record layout also carries classic CAN data and remote frames. + # The flags follow the payload, message duration and message length. + try: + flags = int(fields[data_length + 2], BASE_HEX) + except (IndexError, ValueError): + # Preserve the existing interpretation of records without a flags field. + is_fd = True + is_remote = data_length == 0 + else: + # Some older logs omit the FD bit even for payloads over eight bytes. + is_fd = bool(flags & ASC_FLAG_FD_FRAME) or data_length > 8 + is_remote = not is_fd and bool(flags & ASC_FLAG_REMOTE_FRAME) + msg_kwargs["is_fd"] = is_fd + msg_kwargs["bitrate_switch"] = is_fd and brs == "1" + msg_kwargs["error_state_indicator"] = is_fd and esi == "1" + if is_remote: msg_kwargs["is_remote_frame"] = True msg_kwargs["dlc"] = dlc else: @@ -277,7 +288,7 @@ def _process_fd_can_frame(self, line: str, msg_kwargs: dict[str, Any]) -> Messag ) msg_kwargs["dlc"] = data_length - self._process_data_string(data, data_length, msg_kwargs) + msg_kwargs["data"] = self._parse_data(fields, data_length) return Message(**msg_kwargs) @@ -500,8 +511,7 @@ def on_message_received(self, msg: Message) -> None: if msg.is_extended_id: arb_id += "x" if msg.is_fd: - flags = 0 - flags |= 1 << 12 + flags = ASC_FLAG_FD_FRAME if msg.bitrate_switch: flags |= 1 << 13 if msg.error_state_indicator: diff --git a/test/logformats_test.py b/test/logformats_test.py index beb5b7b9f..2ca86890e 100644 --- a/test/logformats_test.py +++ b/test/logformats_test.py @@ -20,7 +20,7 @@ from abc import ABCMeta, abstractmethod from contextlib import contextmanager from datetime import datetime, timedelta, timezone -from io import BytesIO +from io import BytesIO, StringIO from itertools import zip_longest from pathlib import Path from unittest.mock import patch @@ -510,7 +510,7 @@ def test_read_can_remote_message(self): actual = self._read_log_file("test_CanRemoteMessage.asc") self.assertMessagesEqual(actual, expected_messages) - def test_read_can_fd_remote_message(self): + def test_read_classic_remote_message_in_canfd_record(self): expected_messages = [ can.Message( timestamp=30.300981, @@ -518,14 +518,39 @@ def test_read_can_fd_remote_message(self): channel=2, dlc=5, is_rx=False, - is_fd=True, is_remote_frame=True, - error_state_indicator=True, ) ] actual = self._read_log_file("test_CanFdRemoteMessage.asc") self.assertMessagesEqual(actual, expected_messages) + def test_roundtrip_empty_can_fd_data(self): + msg = can.Message(is_fd=True, bitrate_switch=True, channel=0, check=True) + with can.ASCWriter(self.test_file_name) as writer: + writer.on_message_received(msg) + with can.ASCReader(self.test_file_name) as reader: + (actual,) = reader + self.assertTrue(msg.equals(actual, timestamp_delta=None)) + + @parameterized.expand( + [ + ("empty_data", "0 0 0 0 0", False, 0, b""), + ("empty_remote", "0 0 0 0 10", True, 0, b""), + ("data", "1 1 AB 0 0 0", False, 1, b"\xab"), + ] + ) + def test_classic_frame_in_canfd_record(self, _, fields, remote, dlc, data): + stream = StringIO( + "base hex timestamps absolute\ninternal events logged\n" + f"0.100000 CANFD 1 Rx 123 0 0 {fields}\n" + ) + with can.ASCReader(stream) as reader: + (actual,) = reader + self.assertFalse(actual.is_fd) + self.assertEqual(actual.is_remote_frame, remote) + self.assertEqual(actual.dlc, dlc) + self.assertEqual(actual.data, data) + def test_read_can_fd_message(self): expected_messages = [ can.Message(