fix(asc): apply timestamps_format to actual written timestamps, not just header

Previously, log_event() always subtracted self.started from every timestamp
regardless of timestamps_format, meaning "relative" mode only changed the
header line while writing identical data to "absolute" mode.

Per the ASC format specification:
- "absolute": each timestamp is an offset from the start of measurement
- "relative": each timestamp is a delta from the preceding event

Fix log_event() to compute per-event deltas when timestamps_format="relative",
and update self.last_timestamp after each event so the next delta is correct.

Also add two tests that verify the actual values written to the file differ
between the two modes (3-message uneven spacing exposes the distinction at msg3:
absolute writes 1.0, relative writes 0.7).

Update changelog fragment to describe the semantic difference accurately.

Author: Ju-Daeng-E

can/io/asc.py

@@ -462,10 +462,22 @@ def log_event(self, message: str, timestamp: float | None = None) -> None:
         # Use last known timestamp if unknown
         if timestamp is None:
             timestamp = self.last_timestamp
-        # turn into relative timestamps if necessary
-        if timestamp >= self.started:
-            timestamp -= self.started
-        line = self.FORMAT_EVENT.format(timestamp=timestamp, message=message)
+        # Compute written timestamp based on configured format
+        if self.timestamps_format == "absolute":
+            # offsets from the start of measurement
+            written_timestamp = (
+                timestamp - self.started if timestamp >= self.started else timestamp
+            )
+        else:
+            # deltas from the preceding event
+            written_timestamp = (
+                timestamp - self.last_timestamp
+                if timestamp >= self.last_timestamp
+                else 0.0
+            )
+        # Track last timestamp so the next event can compute its delta
+        self.last_timestamp = timestamp
+        line = self.FORMAT_EVENT.format(timestamp=written_timestamp, message=message)
         self.file.write(line)
 
     def on_message_received(self, msg: Message) -> None:

doc/changelog.d/2022.added.md

@@ -1 +1,4 @@
-Added `timestamps_format` parameter to `ASCWriter` to allow writing `relative` or `absolute` timestamps in the ASC file header.
+Added `timestamps_format` parameter to `ASCWriter` to support configurable timestamp
+format: `"absolute"` (default, timestamps are offsets from the start of measurement)
+or `"relative"` (each timestamp is the delta from the preceding event), matching the
+semantics described in the ASC format specification.

test/logformats_test.py

@@ -725,10 +725,56 @@ def test_write_relative_timestamp_roundtrip(self):
             result = list(reader)
 
         self.assertEqual(len(result), len(msgs))
-        # With relative_timestamp=True timestamps are offsets from the first message
+        # Timestamps in file are per-event deltas; reader reads them as-is
         self.assertAlmostEqual(result[0].timestamp, 0.0, places=5)
         self.assertAlmostEqual(result[1].timestamp, 0.5, places=5)
 
+    def test_write_relative_timestamps_are_per_event_deltas(self):
+        """With timestamps_format='relative', each written timestamp is a delta from the
+        preceding event (not an offset from measurement start)."""
+        msgs = [
+            can.Message(timestamp=100.0, arbitration_id=0x1, data=b"\x01"),
+            can.Message(timestamp=100.3, arbitration_id=0x2, data=b"\x02"),
+            can.Message(timestamp=101.0, arbitration_id=0x3, data=b"\x03"),
+        ]
+
+        with can.ASCWriter(self.test_file_name, timestamps_format="relative") as writer:
+            for m in msgs:
+                writer.on_message_received(m)
+
+        with can.ASCReader(self.test_file_name, relative_timestamp=True) as reader:
+            result = list(reader)
+
+        self.assertEqual(len(result), len(msgs))
+        # msg1: 0.0  (delta from "Start of measurement" at same time)
+        # msg2: 0.3  (delta from msg1)
+        # msg3: 0.7  (delta from msg2 — NOT 1.0, which would be absolute offset)
+        self.assertAlmostEqual(result[0].timestamp, 0.0, places=5)
+        self.assertAlmostEqual(result[1].timestamp, 0.3, places=5)
+        self.assertAlmostEqual(result[2].timestamp, 0.7, places=5)
+
+    def test_write_absolute_timestamps_are_offsets_from_start(self):
+        """With timestamps_format='absolute' (default), each written timestamp is an
+        offset from the measurement start, not a per-event delta."""
+        msgs = [
+            can.Message(timestamp=100.0, arbitration_id=0x1, data=b"\x01"),
+            can.Message(timestamp=100.3, arbitration_id=0x2, data=b"\x02"),
+            can.Message(timestamp=101.0, arbitration_id=0x3, data=b"\x03"),
+        ]
+
+        with can.ASCWriter(self.test_file_name, timestamps_format="absolute") as writer:
+            for m in msgs:
+                writer.on_message_received(m)
+
+        with can.ASCReader(self.test_file_name, relative_timestamp=True) as reader:
+            result = list(reader)
+
+        self.assertEqual(len(result), len(msgs))
+        # All timestamps are offsets from the measurement start (100.0):
+        self.assertAlmostEqual(result[0].timestamp, 0.0, places=5)
+        self.assertAlmostEqual(result[1].timestamp, 0.3, places=5)
+        self.assertAlmostEqual(result[2].timestamp, 1.0, places=5)
+
     @parameterized.expand(
         [
             (