python-can-cansub 2026.5.22__py3-none-any.whl

python_can_cansub/cansub_protocol.py

@@ -0,0 +1,346 @@
+import binascii
+import can
+from enum import IntEnum
+from typing import Callable
+from can.util import len2dlc, dlc2len
+
+HDLC_BOUNDARY_BYTE = 0x7E
+HDLC_ESCAPE_BYTE = 0x7D
+
+MSG_ENCODE_ERR_HEADER_SIZE = 7
+MSG_ENCODE_STD_HEADER_SIZE = 9   # 7 + 2
+MSG_ENCODE_EXT_HEADER_SIZE = 11  # 7 + 4
+MSG_ENCODE_HEADER_MIN_SIZE = MSG_ENCODE_ERR_HEADER_SIZE
+MSG_ENCODE_HEADER_MAX_SIZE = MSG_ENCODE_EXT_HEADER_SIZE
+
+# The encoded timestamp is offset by date 2025/01/01 00:00:00 UTC.
+MSG_ENCODE_TIME_MIN = 1735689600
+MSG_ENCODE_TIME_MAX = MSG_ENCODE_TIME_MIN + (0xFF_FF_FF_FF_FF_FF / 1_000_000)
+
+class CanSubErrorFrameType(IntEnum):
+    BIT = 0
+    ACK = 1
+    FORM = 2
+    STUFF = 3
+    CRC = 4
+    OTHER = 0xFF
+
+def cansub_protocol_encode(msg: can.Message, data: bytearray) -> bytes:
+    """
+    Encodes msg into data. Can be called multiple times to encode multiple messages in the same data buffer. The
+    boundary bytes (start/stop), byte stuffing and, CRC32 will be updated to ensure that the frame in the data buffer
+    is always valid.
+    """
+
+    # Encode the new message into message buffer
+    msg_buf = message_encode(msg)
+
+    # Default crc32 value
+    crc32 = 0
+
+    # Check if output buffer already contains a start boundary flag */
+    if len(data) == 0:
+        # No, add flag
+        data.append(HDLC_BOUNDARY_BYTE)
+    else:
+        # Remove the current end boundary flag (such that more data can be added)
+        boundary_flag_end = data.pop()
+        if boundary_flag_end != HDLC_BOUNDARY_BYTE:
+            raise ValueError("Unexpected boundary end flag")
+
+        # Get current CRC (and remove from the end of buffer)
+        # WARNING: The CRC bytes can be byte-stuffed and take up more than 4 bytes!
+        for i in range(0, 4):
+
+            if len(data) < 1:
+                raise ValueError("Missing CRC32 bytes")
+
+            # Get byte and check if byte before is escape byte
+            byte = data.pop()
+            if len(data) > 0 and (data[-1] == HDLC_ESCAPE_BYTE):
+                # Yes, byte before is escape byte, de-stuff crc byte and remove escape byte
+                byte ^= 0x20
+                data.pop()
+
+            # NOTE: Be aware that the CRC32 bytes are read from the end of the buffer!
+            crc32 |= byte << (i * 8)
+
+    # Update crc32 with new data
+    crc32 = binascii.crc32(msg_buf, crc32)
+
+    # Append CRC32 bytes to message buffer
+    msg_buf.extend(crc32.to_bytes(4, "big"))
+
+    # Add the new message to the persistent buffer while applying HDLC byte stuffing */
+    for byte in msg_buf:
+
+        # Check if bytestuffing in required
+        if byte == HDLC_BOUNDARY_BYTE or byte == HDLC_ESCAPE_BYTE:
+            # Insert escape byte
+            data.append(HDLC_ESCAPE_BYTE)
+
+            # Modify data byte with XOR 0x20
+            byte ^= 0x20
+
+        # Insert data byte
+        data.append(byte)
+
+    # Insert the boundary end flag
+    data.append(HDLC_BOUNDARY_BYTE)
+
+    return data
+
+def cansub_protocol_decode(data: bytearray, msg_cb: Callable[[can.Message], None]) -> None:
+    frames_decode(data, msg_cb)
+
+def frames_decode(data: bytearray, msg_cb: Callable[[can.Message], None]) -> None:
+
+    # Decode all frames in buffer
+    while len(data) > 0:
+
+        # Pre-decode length of buffer
+        data_len_pre = len(data)
+
+        # Decode single frame
+        try:
+            frame_decode(data, msg_cb)
+
+            # Check if bytes consumed
+            if len(data) == data_len_pre:
+                # No, this is not an error. Just that we need more bytes to parse frame.
+                break
+        except Exception as e:
+            # Some error. Bytes consumed?
+            print(f"Error decoding frame {e}")
+            if data_len_pre == len(data):
+                # No, likely deadlock, reset buffer
+                data = bytearray()
+                break
+
+def frame_decode(data: bytearray, msg_cb: Callable[[can.Message], None]) -> None:
+
+    # Find boundary start
+    frame_start = data.find(HDLC_BOUNDARY_BYTE)
+    if frame_start < 0:
+        # Boundary start byte should during normal operation always be present. However, this is not a hard fault.
+        return
+
+    # Find boundary end (starting from boundary_start + 1)
+    frame_end = data.find(HDLC_BOUNDARY_BYTE, frame_start + 1)
+    if frame_end < 0:
+        # No boundary end, wait for more data. Zero bytes consumed
+        return
+
+    # Create frame containing byte-stuffed bytes without boundary flags
+    frame = data[frame_start + 1:frame_end]
+
+    # Consume frame bytes (including boundary flags)
+    del data[:frame_end + 1]
+
+    # Perform byte de-stuffing
+    i_in = 0
+    i_out = 0
+    while i_in < len(frame):
+
+        # Read one byte
+        byte = frame[i_in]
+        i_in += 1
+
+        # Check if de-stuffing is required
+        if byte == HDLC_ESCAPE_BYTE:
+            # Yes, check that we have one more byte
+            if i_in < len(frame):
+                # Yes, de-stuff next byte
+                byte = frame[i_in] ^ 0x20
+                i_in += 1
+            else:
+                # No, this is an error
+                raise ValueError("Frame stuffed byte missing")
+
+        # Add de-stuffed byte to the output
+        frame[i_out] = byte
+        i_out += 1
+
+    del frame[i_out:]
+
+    # Check frame crc32
+    if len(frame) < 4:
+        raise ValueError("Frame CRC32 missing")
+
+    crc32_expected = int.from_bytes(frame[-4:], "big")
+    del frame[-4:]
+    crc32_actual = binascii.crc32(frame)
+
+    if crc32_expected != crc32_actual:
+        raise ValueError("Frame CRC32 mismatch")
+
+    # Decode message(s) in frame
+    messages_decode(frame, msg_cb)
+
+def messages_decode(data: bytearray, msg_cb: Callable[[can.Message], None]) -> None:
+
+    # Decode all messages in buffer
+    while len(data) > 0:
+        # Pre-decode length of buffer
+        data_len_pre = len(data)
+
+        # Decode a single message
+        try:
+            message_decode(data, msg_cb)
+            result = True
+        except Exception as e:
+            print(f"Error decoding message {e}")
+            result = False
+            break
+
+        # If decode error or if zero bytes consumed, break
+        if not result or data_len_pre == len(data):
+            raise ValueError("Message decode error")
+
+def message_decode(data: bytearray, msg_cb: Callable[[can.Message], None]) -> None:
+
+    # Backup of len before bytes are removed
+    data_len_orig = len(data)
+
+    # Check minimum header
+    if data_len_orig < MSG_ENCODE_HEADER_MIN_SIZE:
+        raise ValueError("Not enough data to parse header")
+
+    # Microseconds (48 bit)
+    timestamp_us = int.from_bytes(data[:6], byteorder='big')
+    timestamp = float(timestamp_us) / 1_000_000.0 + MSG_ENCODE_TIME_MIN
+    del data[:6]
+
+    # Flags
+    flags = data[0]
+    del data[0]
+
+    # Error frame ?
+    if (flags & 0xE0) != 0x20:
+
+        # No, is data frame
+        if data_len_orig < MSG_ENCODE_STD_HEADER_SIZE:
+            raise ValueError("Not enough data to parse header")
+
+        # Frame format
+        is_fdf = bool(flags & 0x80)
+
+        if not is_fdf:
+            is_rtr = bool(flags & 0x40)
+            is_brs = False
+            is_esi = False
+        else:
+            is_rtr = False
+            is_brs = bool(flags & 0x40)
+            is_esi = bool(flags & 0x20)
+
+        # Get TX (note, logic reversed)
+        is_rx = not bool(flags & 0x10)
+
+        # DLC
+        dlc = flags & 0x0F
+
+        # Is extended ID?
+        is_extended_id = bool(data[0] & 0x80)
+
+        # Arbitration ID
+        if not is_extended_id:
+            # Regular ID
+            if len(data) < 2:
+                raise ValueError("Not enough data to parse STD ID")
+            arbitration_id = int.from_bytes(bytes(data[:2]), byteorder='big') & 0x7FF
+            del data[:2]
+        else:
+            # Extended ID
+            if len(data) < 4:
+                raise ValueError("Not enough data to parse EXT ID")
+            arbitration_id = int.from_bytes(bytes(data[:4]), byteorder='big') & 0x1FFFFFFF
+            del data[:4]
+
+        # Payload
+        payload = b""
+        if not is_rtr:
+            payload_len = dlc2len(dlc)
+            if len(data) >= payload_len:
+                payload = data[:payload_len]
+                del data[:payload_len]
+            else:
+                raise ValueError("Not enough data bytes for payload")
+
+        msg = can.Message(timestamp=timestamp,
+                          channel=None,
+                          is_rx=is_rx,
+                          arbitration_id=arbitration_id,
+                          is_extended_id=is_extended_id,
+                          is_remote_frame=is_rtr,
+                          is_fd=is_fdf,
+                          bitrate_switch=is_brs,
+                          error_state_indicator=is_esi,
+                          # Note: python-can stores actual byte length in Message.dlc
+                          dlc=dlc2len(dlc) if is_rtr else len(payload),
+                          data=payload,
+                          check=True,
+        )
+        # Invoke callback
+        msg_cb(msg)
+
+    else:
+        # Yes, is error frame. Store the error code in the arbitration ID (like the python-can socketcan implementation)
+        error_type_val = flags & 0x1F
+
+        # Map error type to enum value, default to OTHER if unknown
+        try:
+            error_type = CanSubErrorFrameType(error_type_val)
+        except ValueError:
+            error_type = CanSubErrorFrameType.OTHER
+
+        msg = can.Message(timestamp=timestamp,
+                          channel=None,
+                          arbitration_id=int(error_type),
+                          is_error_frame=True,
+                          check=True,
+        )
+        # Invoke callback
+        msg_cb(msg)
+
+
+def message_encode(message: can.Message) -> bytearray:
+
+    if message.is_error_frame:
+        raise ValueError("Encoding of error frames not supported")
+
+    buffer = bytearray()
+
+    # Microseconds since 00:00:00 01/01/2025 UTC (48 bit)
+    timestamp_us = 0
+    if (message.timestamp is not None ) and (MSG_ENCODE_TIME_MAX >= message.timestamp >= MSG_ENCODE_TIME_MIN):
+        timestamp_us = int((message.timestamp - MSG_ENCODE_TIME_MIN) * 1_000_000)
+    buffer.extend(timestamp_us.to_bytes(6, byteorder='big'))
+
+    # Note: python-can stores actual byte length in Message.dlc
+    dlc = len2dlc(len(message.data)) if not message.is_remote_frame else len2dlc(message.dlc)
+
+    # fd (1 bit), rtr/brs (1 bit), 0/esi (1 bit), tx (1 bit), dlc (4 bit)
+    flags = 0
+    flags |= 0x80 if message.is_fd else 0x00
+    if not message.is_fd:
+        flags |= 0x40 if message.is_remote_frame else 0x00
+    else:
+        flags |= 0x40 if message.bitrate_switch else 0x00
+        flags |= 0x20 if message.error_state_indicator else 0x00
+    flags |= 0x10 if not message.is_rx else 0x00
+    flags |= dlc & 0x0F
+    buffer.append(flags)
+
+    # ID (11 or 29 bit). Note: MSb set if extended ID.
+    if not message.is_extended_id:
+        arbitration_id = bytearray((message.arbitration_id & 0x7FF).to_bytes(2, byteorder='big'))
+    else:
+        arbitration_id = bytearray(((message.arbitration_id & 0x1FFFFFFF) | 0x80000000).to_bytes(4, byteorder='big'))
+    buffer.extend(arbitration_id)
+
+    # Payload (omit for RTR)
+    if not message.is_remote_frame:
+        buffer.extend(message.data)
+
+    return buffer

python_can_cansub/cansub_root_cert.crt

@@ -0,0 +1,11 @@
+-----BEGIN CERTIFICATE-----
+MIIBkDCCATegAwIBAgIUXNdJNtJWKeOF1jo//9d5b4ogt8MwCgYIKoZIzj0EAwIw
+FjEUMBIGA1UEAwwLQ0FOc3ViIHJvb3QwHhcNMjYwNDIxMDQ1NDQwWhcNNDYwNDE2
+MDQ1NDQwWjAWMRQwEgYDVQQDDAtDQU5zdWIgcm9vdDBZMBMGByqGSM49AgEGCCqG
+SM49AwEHA0IABE/d9+b3ev4iv6R2K75IE+V+6Tiy7F0FZCOfh/XgcUDrHjGRFdG1
+HM7g77ca+yBXebiZOLAhSaDgVghdF4nCLy6jYzBhMB0GA1UdDgQWBBQLrD8RSEnY
+1TuXPi9/acQRBcMD9zAfBgNVHSMEGDAWgBQLrD8RSEnY1TuXPi9/acQRBcMD9zAP
+BgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwICBDAKBggqhkjOPQQDAgNHADBE
+AiAknEW1MJy1PUO5I8T94ruNSqoFJ0aqrBXM8qBSEmWYhQIgc1wRS3jTucldvwKZ
+yXf3o3Cmm+ebthFrKw7Bk5LtbkY=
+-----END CERTIFICATE-----

python_can_cansub-2026.5.22.dist-info/METADATA

@@ -0,0 +1,339 @@
+Metadata-Version: 2.4
+Name: python-can-cansub
+Version: 2026.5.22
+Summary: CANsub python-can interface
+Project-URL: Homepage, https://csselectronics.com/
+Project-URL: Source, https://github.com/CSS-Electronics/python-can-cansub
+Author: CSS Electronics
+Author-email: contact@csselectronics.com
+License: MIT
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.12
+Requires-Dist: python-can>=4.6.0
+Requires-Dist: requests>=2.32.5
+Requires-Dist: wsproto>=1.3.2
+Requires-Dist: zeroconf>=0.131.0
+Description-Content-Type: text/markdown
+
+# python-can-cansub
+
+A [python-can](https://python-can.readthedocs.io/) integration for the [CANsub](https://csselectronics.com/) CAN bus interface family by CSS Electronics. Source on [GitHub](https://github.com/CSS-Electronics/python-can-cansub).
+
+This package registers the CANsub as a standard python-can interface, making it compatible with all python-can tools and workflows. It also adds a CSV logger compatible with the *webCAN* browser tool provided with the device.
+
+> **Tip:** This README is optimized for LLMs. When using an AI coding assistant with this package, provide this file as context for accurate results.
+
+## python-can API
+
+### Installation
+
+```bash
+pip install python-can-cansub
+```
+
+### Import
+
+When `python-can-cansub` is installed, the `cansub` interface is automatically registered with python-can. Import with:
+
+```python
+import can
+```
+
+### Configuration
+
+Python-can defines a hardware *configuration* by an `interface` and a `channel` (a single interface can have multiple channels).
+
+The CANsub `interface` is fixed `"cansub"`. The `channel` is constructed from the device hostname (unique) and channel index.
+
+| Connection | Hostname                | python-can `channel` string       |
+|------------|-------------------------|-----------------------------------|
+| USB        | `[DEVICE-ID]-usb.local` | `[DEVICE-ID]-usb.local@[channel]` |
+| Ethernet   | `[DEVICE-ID]-eth.local` | `[DEVICE-ID]-eth.local@[channel]` |
+
+The device-ID is printed on the device label. Channel indexing is **1-based** - the first channel is `1`.
+
+A configuration is passed to `can.Bus` to open a bus.
+
+#### Fixed
+
+Example of a fixed configuration:
+
+```python
+configs = [{"interface": "cansub", "channel": "aabbccdd-usb.local@1"},
+           {"interface": "cansub", "channel": "aabbccdd-usb.local@2"}]
+```
+
+#### Auto-detect
+
+Example of using `detect_available_configs` to automatically discover (uses mDNS) all connected CANsub devices and channels:
+
+```python
+configs = can.detect_available_configs(interfaces=["cansub"])
+# e.g. [{"interface": "cansub", "channel": "aabbccdd-usb.local@1"},
+#       {"interface": "cansub", "channel": "aabbccdd-usb.local@2"}
+#       {"interface": "cansub", "channel": "11223344-eth.local@1"}
+#       {"interface": "cansub", "channel": "11223344-eth.local@2"}]
+```
+
+In the above example two CANsub devices are detected, each with two channels. One device is connected via USB and the other via Ethernet.
+
+### Opening a Bus
+
+#### Single bus - hardcoded
+
+```python
+with can.Bus(interface="cansub", channel="aabbccdd-usb.local@1", bitrate=250_000, data_bitrate=1_000_000) as bus:
+    pass
+```
+
+#### Single bus - from configs
+
+```python
+with can.Bus(interface=configs[0]["interface"], channel=configs[0]["channel"], bitrate=250_000, data_bitrate=1_000_000) as bus:
+    pass
+```
+
+#### Multiple buses - from configs
+
+```python
+with (can.Bus(interface=configs[0]["interface"], channel=configs[0]["channel"], bitrate=250_000, data_bitrate=1_000_000) as bus1,
+      can.Bus(interface=configs[1]["interface"], channel=configs[1]["channel"], bitrate=250_000, data_bitrate=1_000_000) as bus2):
+    pass
+```
+
+> **Tip:** `**config` unpacks a config dict directly into `can.Bus` keyword arguments:
+>
+> ```python
+> with can.Bus(**configs[0], bitrate=250_000, data_bitrate=1_000_000) as bus:
+>     pass
+> ```
+
+### Receive and Transmit
+
+```python
+with can.Bus(**configs[0], bitrate=250_000, data_bitrate=1_000_000) as bus:
+    
+    # Transmit
+    msg_tx = can.Message(is_extended_id=False, arbitration_id=0x123, data=[0x01, 0x02, 0x03, 0x04])
+    bus.send(msg_tx)
+    
+    # Receive with timeout
+    msg_rx = bus.recv(timeout=1.0)
+    print(msg_rx)
+```
+
+### Filters
+
+Apply hardware filters by passing `can_filters` to `can.Bus`. Each filter specifies a `can_id`, a `can_mask`, and whether to match standard (`extended=False`) or extended (`extended=True`) frames. A frame passes if `(frame_id & can_mask) == (can_id & can_mask)`.
+
+```python
+filters = [
+    {"can_id": 0x123, "can_mask": 0x7FF, "extended": False},  # standard frames, exact ID match
+    {"can_id": 0x000, "can_mask": 0x000, "extended": True},   # all extended frames
+]
+
+with can.Bus(**configs[0], bitrate=250_000, data_bitrate=1_000_000, can_filters=filters) as bus:
+    msg = bus.recv(timeout=1.0)
+    print(msg)
+```
+
+> **Tip:** Applying hardware filters reduces the network load between the CANsub and the connected client.
+
+### Notifier and Listeners
+
+`bus.recv()` blocks until a frame arrives. A `can.Notifier` runs a background thread that dispatches received frames to one or more *listeners*, allowing the main program to continue other work.
+
+python-can provides built-in listeners including `can.Printer` (print to stdout) and `can.Logger` (log to file). The example below logs to a CSV file while the main program continues. Custom listeners can be implemented by subclassing `can.Listener`.
+
+```python
+from time import sleep
+
+print_listener = can.Printer()
+csv_listener = can.Logger("log.csv")
+
+with can.Bus(**configs[0], bitrate=250_000, data_bitrate=1_000_000) as bus:
+    with can.Notifier([bus], listeners=[print_listener, csv_listener]):
+
+        # Perform other tasks here while frames are received in the background
+        sleep(10)
+```
+
+### Broadcast Manager
+
+Periodic transmission jobs can be started with `bus.send_periodic()`.
+
+Most periodic transmission job types can be offloaded to the CANsub hardware, providing much better transmission time accuracy (compared to a host-scheduled transmission). A host-side background task is used only as a fallback when hardware transmission is not available.
+
+```python
+from time import sleep
+
+msgs = [
+    can.Message(is_extended_id=False, arbitration_id=0x123, data=[0x01, 0x02, 0x03, 0x04]),
+    can.Message(is_extended_id=False, arbitration_id=0x124, data=[0x05, 0x06, 0x07, 0x08]),
+    can.Message(is_extended_id=False, arbitration_id=0x125, data=[0x09, 0x0A, 0x0B, 0x0C]),
+]
+
+with can.Bus(**configs[0], bitrate=250_000, data_bitrate=1_000_000) as bus:
+    # period: time between individual frames (sequence repeats every len(msgs) * period)
+    # duration: total transmission time in seconds (None = transmit indefinitely)
+    task = bus.send_periodic(msgs, period=0.1, duration=5.0)
+
+    # Perform other tasks here while frames are transmitted in the background
+    sleep(6)
+```
+
+### Replaying files
+
+`can.MessageSync` can be used to replay messages from a log file.
+
+```python
+with can.Bus(**configs[0], bitrate=250_000, data_bitrate=1_000_000) as bus:
+    with can.LogReader("log.csv") as reader:
+        for msg in can.MessageSync(messages=reader):
+            bus.send(msg)
+```
+
+## python-can tools
+
+python-can includes several command line tools. All tools accept `--interface` and `--channel` to select the bus, following the same configuration as the API.
+
+The common argument pattern for the CANsub:
+
+```
+--interface cansub --channel aabbccdd-usb.local@1 --bitrate 250000 --data-bitrate 1000000
+```
+
+### can_logger
+
+Log received frames to a file (CSV by default; format inferred from file extension):
+
+```bash
+can_logger --interface cansub --channel aabbccdd-usb.local@1 --bitrate 250000 --data-bitrate 1000000 --output-file log.csv
+```
+
+### can_player
+
+Play back a previously recorded log file:
+
+```bash
+can_player --interface cansub --channel aabbccdd-usb.local@1 --bitrate 250000 --data-bitrate 1000000 log.csv
+```
+
+### can_viewer
+
+Live terminal viewer showing received frames, updated counts, timestamps, and byte-level changes:
+
+```bash
+can_viewer --interface cansub --channel aabbccdd-usb.local@1 --bitrate 250000 --data-bitrate 1000000
+```
+
+### can_bridge
+
+Forward all frames received on one bus to another (e.g. bridge two CANsub channels):
+
+```bash
+can_bridge --interface cansub --channel aabbccdd-usb.local@1 --bitrate 250000 --data-bitrate 1000000 \
+           --interface2 cansub --channel2 aabbccdd-usb.local@2 --bitrate2 250000 --data-bitrate2 1000000
+```
+
+### can_logconvert
+
+Convert a log file between formats; the format is inferred from the file extension:
+
+```bash
+can_logconvert log.csv log.asc
+```
+
+## Related Packages
+
+The following packages complement `python-can-cansub` and are included here as inspiration for working with CAN data in Python.
+
+### cantools
+
+[cantools](https://github.com/cantools/cantools) is a Python package for encoding and decoding CAN messages. Encoding/decoding rules can be created or loaded from DBC (and other) database files. It works directly with `can.Message` objects from python-can.
+
+#### Installation
+
+```bash
+pip install cantools
+```
+
+#### Create database in code
+
+A database can be constructed directly in Python without a database file:
+
+```python
+import cantools
+
+db = cantools.database.Database()
+
+msg_def = cantools.database.can.Message(
+    frame_id=0x123,
+    name="Message1",
+    length=8,
+    signals=[
+        cantools.database.can.Signal(name="Signal1", start=0,  length=16, scale=0.1, offset=0.0, minimum=0.0, maximum=100.0),
+        cantools.database.can.Signal(name="Signal2", start=16, length=16, scale=0.1, offset=0.0, minimum=0.0, maximum=100.0),
+    ]
+)
+
+db.add_message(msg_def)
+```
+
+#### Load database from DBC file
+
+```python
+import cantools
+
+db = cantools.database.load_file("database.dbc")
+msg_def = db.get_message_by_name("Message1")
+```
+
+#### Encode
+
+Encode signal values into the byte payload of a `can.Message`:
+
+```python
+data = msg_def.encode({"Signal1": 1.0, "Signal2": 42.5})
+msg_tx = can.Message(arbitration_id=msg_def.frame_id,
+                     is_extended_id=msg_def.is_extended_frame,
+                     data=data)
+
+with can.Bus(**configs[0], bitrate=250_000, data_bitrate=1_000_000) as bus:
+    bus.send(msg_tx)
+```
+
+#### Decode
+
+Decode the byte payload of a received `can.Message` back into signal values:
+
+```python
+with can.Bus(**configs[0], bitrate=250_000, data_bitrate=1_000_000) as bus:
+    msg_rx = bus.recv(timeout=1.0)
+    if msg_rx:
+        signals = db.decode_message(msg_rx.arbitration_id, msg_rx.data)
+        print(signals)  # e.g. {'Signal1': 1.0, 'Signal2': 42.5}
+```
+
+### asammdf
+
+[asammdf](https://github.com/danielhrisca/asammdf) is a Python package for reading and writing MDF (Measurement Data Format) files.
+
+When `asammdf` is installed, python-can automatically gains support for reading MDF log files via `can.LogReader`, allowing MDF recordings to be played back directly using `can.MessageSync`:
+
+#### Installation
+
+```bash
+pip install asammdf
+```
+
+#### Playback of MDF log file
+
+```python
+with can.Bus(**configs[0], bitrate=250_000, data_bitrate=1_000_000) as bus:
+    with can.LogReader("recording.mf4") as reader:
+        for msg in can.MessageSync(messages=reader):
+            bus.send(msg)
+```

python_can_cansub-2026.5.22.dist-info/RECORD

@@ -0,0 +1,8 @@
+python_can_cansub/__init__.py,sha256=d6h_Gcl355zHd6n60XpGI9VVfMf63GMXkVmt7fOqiaU,225
+python_can_cansub/cansub.py,sha256=rUn9fFIZXgLPMwHD-kn4WiH3nrcBkwiVEtMJm77a7yE,36702
+python_can_cansub/cansub_protocol.py,sha256=tPYurcznSyR6oG6xN5sG7sgy9QHtt3WJ8UyGNP3LdT0,11315
+python_can_cansub/cansub_root_cert.crt,sha256=g4ds4CtMhoX3QWX_fGnXbaBhxLBHCNN2I4ci4gMdlGw,603
+python_can_cansub-2026.5.22.dist-info/METADATA,sha256=sb8jyA07UxsIKBPCVlcdZTND1rPIV8hDj9-WPOQ5nO8,11342
+python_can_cansub-2026.5.22.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+python_can_cansub-2026.5.22.dist-info/entry_points.txt,sha256=2NrO_BE31bhjk-Gg0oSfOA5eUSS358RcN8hdxoEsd44,201
+python_can_cansub-2026.5.22.dist-info/RECORD,,