pyccp 0.10.0__py3-none-any.whl

pyccp/__init__.py

@@ -0,0 +1,5 @@
+"""CAN Calibration Protocol tools; applications configure logging handlers."""
+
+import logging
+
+logging.getLogger(__name__).addHandler(logging.NullHandler())

pyccp/ccp.py

@@ -0,0 +1,116 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import dataclasses
+import enum
+
+MAX_CRO = 0x0008
+MAX_DTO = 0x0008
+
+CCP_VERSION = (2, 1)
+
+
+@dataclasses.dataclass(frozen=True)
+class Command:
+    """
+    Immutable command configuration.
+
+    Represents a command by its numeric code and the timeout value associated
+    with executing or handling that command. Instances are frozen by the data class
+    declaration, so the recorded values are intended to remain stable after
+    creation.
+
+    :ivar code: Numeric identifier for the command.
+    :ivar timeout: Timeout value associated with the command in milliseconds.
+    """
+
+    code: int
+    timeout: int
+
+
+# Mandatory Commands
+CONNECT = Command(0x01, 25)
+GET_CCP_VERSION = Command(0x1B, 25)
+EXCHANGE_ID = Command(0x17, 25)
+SET_MTA = Command(0x02, 25)
+DNLOAD = Command(0x03, 25)
+UPLOAD = Command(0x04, 25)
+GET_DAQ_SIZE = Command(0x14, 25)
+SET_DAQ_PTR = Command(0x15, 25)
+WRITE_DAQ = Command(0x16, 25)
+START_STOP = Command(0x06, 25)
+DISCONNECT = Command(0x07, 25)
+# Optional Commands
+GET_SEED = Command(0x12, 25)
+UNLOCK = Command(0x13, 25)
+DNLOAD_6 = Command(0x23, 25)
+SHORT_UP = Command(0x0F, 25)
+SELECT_CAL_PAGE = Command(0x11, 25)
+SET_S_STATUS = Command(0x0C, 25)
+GET_S_STATUS = Command(0x0D, 25)
+BUILD_CHKSUM = Command(0x0E, 30000)
+CLEAR_MEMORY = Command(0x10, 30000)
+PROGRAM = Command(0x18, 100)
+PROGRAM_6 = Command(0x22, 100)
+MOVE = Command(0x19, 30000)
+TEST = Command(0x05, 25)
+GET_ACTIVE_CAL_PAGE = Command(0x09, 25)
+START_STOP_ALL = Command(0x08, 25)
+DIAG_SERVICE = Command(0x20, 500)
+ACTION_SERVICE = Command(0x21, 5000)
+
+
+class ReturnCodes(enum.IntEnum):
+    ACKNOWLEDGE = 0x00
+    DAQ_PROCESSOR_OVERLOAD = 0x01  # C0
+    COMMAND_PROCESSOR_BUSY = 0x10  # C1 NONE (wait until ACK or timeout)
+    DAQ_PROCESSOR_BUSY = 0x11  # C1 NONE (wait until ACK or timeout)
+    INTERNAL_TIMEOUT = 0x12  # C1 NONE (wait until ACK or timeout)
+    KEY_REQUEST = 0x18  # C1 NONE (embedded seed&key)
+    SESSION_STATUS_REQUEST = 0x19  # C1 NONE (embedded SET_S_STATUS)
+    COLD_START_REQUEST = 0x20  # C2 COLD START
+    CAL_DATA_INIT_REQUEST = 0x21  # C2 cal. data initialization
+    DAQ_LIST_INIT_REQUEST = 0x22  # C2 DAQ list initialization
+    CODE_UPDATE_REQUEST = 0x23  # C2 (COLD START)
+    UNKNOWN_COMMAND = 0x30  # C3 (FAULT)
+    COMMAND_SYNTAX = 0x31  # C3 FAULT
+    PARAMETER_OUT_OF_RANGE = 0x32  # C3 FAULT
+    ACCESS_DENIED = 0x33  # C3 FAULT
+    OVERLOAD = 0x34  # C3 FAULT
+    ACCESS_LOCKED = 0x35  # C3 FAULT
+    RESOURCE_FUNCTION_NOT_AVAILABLE = 0x36  # C3 FAULT
+
+
+class DisconnectType(enum.IntEnum):
+    TEMPORARY = 0x00
+    PERMANENT = 0x01
+
+
+class SecondaryResource(enum.IntEnum):
+    """
+    Enumeration for secondary resource types.
+
+    This enumeration defines constants representing different types of secondary
+    resources that can be used or required in various systems or operations.
+
+    :cvar CAL: Represents the calibration resource.
+    :cvar DAQ: Represents the data acquisition resource.
+    :cvar PGM: Represents the programming resource.
+    """
+
+    CAL = 1 << 0
+    DAQ = 1 << 1
+    PGM = 1 << 6
+
+
+class DTO:
+    class Type(enum.IntEnum):
+        COMMAND_RETURN_MESSAGE = 255
+        EVENT_MESSAGE = 254
+
+
+def verify_ctr(ctr: int, response: bytes) -> bool:
+    if len(response) < 3:
+        return False
+
+    return ctr == response[2]

pyccp/master.py

@@ -0,0 +1,556 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import ctypes
+import logging
+import struct
+import threading
+import time
+from collections.abc import Callable
+from concurrent.futures import Future
+from threading import Event, Thread
+from types import TracebackType
+from typing import Optional
+
+import can
+from can import Message
+
+from . import ccp
+from .ccp import ReturnCodes, SecondaryResource
+
+MTA0 = 0
+MTA1 = 1
+
+
+def _unsigned(name: str, value: int, bits: int) -> int:
+    if not isinstance(value, int) or not 0 <= value < (1 << bits):
+        raise ValueError(
+            f"{name} must be an unsigned {bits}-bit integer, got {value!r}"
+        )
+
+    return value
+
+
+def _payload(data: bytes, minimum: int, maximum: int):
+    """Normalize byte sequences without interpreting integers as zero-filled data."""
+    if isinstance(data, (int, str)):
+        raise TypeError("Data must be a bytes-like object or byte sequence")
+
+    payload = bytes(data)
+
+    if not minimum <= len(payload) <= maximum:
+        raise ValueError(
+            f"Data length must be between {minimum} and {maximum}, got {len(payload)}"
+        )
+
+    return payload
+
+
+def _transfer_size(size: int):
+    if not isinstance(size, int) or not 1 <= size <= 5:
+        raise ValueError(f"Size must be between 1 and 5, got {size!r}")
+
+    return size
+
+
+def _pack_address(address: int):
+    return struct.pack("<L", _unsigned("Address", address, 32))
+
+
+class CommandResponse:
+    __slots__ = ("code", "data")
+
+    def __init__(self, raw_data: bytes):
+        if len(raw_data) < 3:
+            raise ValueError("Raw data must be at least 3 bytes long")
+
+        self.code = ReturnCodes(raw_data[1])
+        self.data = raw_data[3:]
+
+
+class DAQMessage:
+    __slots__ = ("daq_id", "pid", "data")
+
+    def __init__(self, message: Message):
+        self.daq_id = message.arbitration_id
+        self.pid = message.data[0]
+        self.data = message.data[1:]
+
+
+DAQCallback = Callable[[DAQMessage], None]
+EventCallback = Callable[[CommandResponse], None]
+
+
+class Master:
+    class _Receiver(Thread):
+        def __init__(self, master: "Master"):
+            super().__init__(daemon=True)
+            self._master = master
+            self._stop_event = Event()
+
+        def run(self):
+            while True:
+                message = self._master.get_raw_data(timeout=0.1)
+
+                if message is not None:
+                    self._master._on_message(message)
+
+                if self._stop_event.is_set():
+                    break
+
+        def stop(self) -> None:
+            self._stop_event.set()
+            self.join()
+
+    def __init__(self, bus: can.BusABC, cro: int, dto: int):
+        """CCP Master implementation for sending and receiving messages over
+        a CAN Calibration Protocol.
+
+        :param bus: CAN Bus object for sending and receiving messages.
+        :type bus: `can.BusABC`
+        :param cro: The 11-bit or 29-bit identifier for outgoing CAN message from
+        the host.
+        :type cro: int
+        :param dto: The 11-bit or 29-bit identifier for incoming CAN message from
+        a slave.
+        :type dto: int
+        """
+        self.transport = bus
+        self.ctr = ctypes.c_uint8(0)
+        self.logger = logging.getLogger(__name__)
+        self._cro = cro
+        self._dto = dto
+        self._lock = threading.Lock()
+        self._receiver: Optional[Master._Receiver] = None
+        self._on_event: Optional[EventCallback] = None
+        self._on_daq: dict[int, DAQCallback] = {}
+        self._pending_requests: dict[int, Future] = {}
+
+    def __enter__(self) -> "Master":
+        if self._receiver is None:
+            self._receiver = Master._Receiver(self)
+
+        self._receiver.start()
+
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> None:
+        self._shutdown()
+
+    def _shutdown(self) -> None:
+        if self._receiver is not None:
+            self._receiver.stop()
+            self._receiver = None
+
+        self.transport.shutdown()
+
+    def on_event(self, callback: EventCallback) -> None:
+        with self._lock:
+            self._on_event = callback
+
+    def on_daq(self, daq_id: int, callback: DAQCallback) -> None:
+        with self._lock:
+            self._on_daq[daq_id] = callback
+
+    def send_cro(self, cmd: ccp.Command, ctr, *data: int) -> int:
+        """
+        Send a Command Receive Object (CRO) message via the transport layer.
+
+        This method constructs the CRO data frame using the provided
+        Command Specifier (cmd), counter value (ctr), and additional data bytes.
+        The data frame is then sent using the transport layer. It also ensures
+        that the control byte value increments properly after each successful
+        transmission.
+
+        :param cmd: Command Specifier byte used in the CCP protocol.
+        :type cmd: int
+        :param ctr: Control byte used for controlling the flow of messages.
+        :type ctr: int
+        :param data: Up to six additional data bytes for the message payload.
+        :return: The transmitted counter (the internal counter advances after sending).
+        :rtype: int
+        :raises ValueError: If more than six data bytes are provided.
+        """
+        if len(data) > 6:
+            raise ValueError(f"Maximum 6 data bytes allowed, got {len(data)}")
+
+        data = bytearray((cmd.code, ctr, *data))
+
+        if len(data) < ccp.MAX_CRO:
+            data.extend(bytearray(ccp.MAX_CRO - len(data)))
+
+        msg = Message(arbitration_id=self._cro, data=data, is_rx=False)
+        self.logger.debug(f"Command: [{cmd}]")
+        self.logger.debug(f"Sending message: {msg}")
+        self.transport.send(msg)
+        self.ctr = ctypes.c_uint8(self.ctr.value + 1)
+
+        return ctr
+
+    def _on_message(self, message: Message) -> None:
+        resource_id = message.data[0]
+
+        if resource_id == ccp.DTO.Type.COMMAND_RETURN_MESSAGE:
+            self._handle_response(message)
+        elif resource_id == ccp.DTO.Type.EVENT_MESSAGE:
+            self._handle_event(message)
+        elif resource_id in self._on_daq:
+            self._handle_daq(message)
+
+    def _handle_response(self, message: Message) -> None:
+        """Handle a response message by verifying the control byte and
+        processing the response.
+        """
+        ctr = message.data[2]
+
+        with self._lock:
+            future = self._pending_requests.pop(ctr, None)
+
+            if future is not None:
+                future.set_result(CommandResponse(message.data))
+            else:
+                self.logger.warning(f"Unexpected response received: {message}")
+
+    def _handle_daq(self, message: Message) -> None:
+        """Handle a DAQ message by invoking the registered callback for the DAQ ID."""
+        daq_id = message.arbitration_id
+
+        with self._lock:
+            callback = self._on_daq.get(daq_id)
+
+            if callback is not None:
+                self.logger.debug(f"Handling DAQ message with ID: {daq_id}")
+                callback(DAQMessage(message))
+
+    def _handle_event(self, message: Message) -> None:
+        """Handle an event message by invoking the registered event callback."""
+        with self._lock:
+            if self._on_event is not None:
+                self.logger.debug(f"Handling event message: {message}")
+                self._on_event(CommandResponse(message.data))
+
+    def _get_data(self, timeout: Optional[float] = None) -> Optional[Message]:
+        """Receive the first available message within `timeout` seconds."""
+        if timeout is None:
+            return self.transport.recv(timeout=None)
+
+        deadline = time.monotonic() + timeout
+
+        while True:
+            residual = deadline - time.monotonic()
+
+            if residual <= 0:
+                return None
+
+            message = self.transport.recv(timeout=residual)
+
+            if message is not None:
+                return message
+
+    def get_data(self, timeout: Optional[float] = None) -> Optional[Message]:
+        """Return the first message addressed to the DTO id within `timeout` seconds."""
+        if timeout is None:
+            deadline = None
+        else:
+            deadline = time.monotonic() + timeout
+
+        while True:
+            if deadline is None:
+                residual = None
+            else:
+                residual = deadline - time.monotonic()
+
+                if residual <= 0:
+                    break
+
+            message = self._get_data(residual)
+
+            if message is None:
+                break
+
+            if message.arbitration_id == self._dto:
+                self.logger.debug(f"Received message: {message}")
+                return message
+
+        self.logger.warning(f"Nothing received after: {timeout} seconds")
+
+        return None
+
+    def get_raw_data(self, timeout: Optional[float] = None) -> Optional[Message]:
+        return self._get_data(timeout)
+
+    def _transaction(
+        self,
+        timeout: int,
+        command: ccp.Command,
+        ctr: int,
+        *data: int,
+    ) -> Optional[CommandResponse]:
+        future = Future()
+
+        with self._lock:
+            ctr = self.send_cro(command, ctr, *data)
+            self._pending_requests[ctr] = future
+
+        try:
+            return future.result(timeout=timeout / 1000.0)
+        except TimeoutError:
+            self.logger.warning(f"Transaction timed out after {timeout} ms")
+
+            with self._lock:
+                self._pending_requests.pop(ctr, None)
+
+            return None
+
+    def _execute(
+        self, command: ccp.Command, *payload: int
+    ) -> Optional[CommandResponse]:
+        """Resolve transaction metadata once; public commands only encode payloads."""
+        return self._transaction(command.timeout, command, self.ctr.value, *payload)
+
+    # Mandatory Commands.
+    def connect(self, address: int) -> Optional[CommandResponse]:
+        address = struct.pack("<H", _unsigned("Station address", address, 16))
+        return self._execute(ccp.CONNECT, *address)
+
+    def get_ccp_version(
+        self, major: int = ccp.CCP_VERSION[0], minor: int = ccp.CCP_VERSION[1]
+    ) -> Optional[CommandResponse]:
+        return self._execute(
+            ccp.GET_CCP_VERSION,
+            major,
+            minor,
+        )
+
+    def exchange_id(self, info: bytes) -> Optional[CommandResponse]:
+        if len(info) > 6:
+            raise ValueError(f"Maximum 6 bytes allowed, got {len(info)}")
+
+        return self._execute(ccp.EXCHANGE_ID, *info)
+
+    def set_mta(
+        self, address: int, address_extension: int = 0x00, mta: int = MTA0
+    ) -> Optional[CommandResponse]:
+        address = _pack_address(address)
+        _unsigned("Address extension", address_extension, 8)
+
+        if mta not in (MTA0, MTA1):
+            raise ValueError(f"MTA must be 0 or 1, got {mta!r}")
+
+        return self._execute(
+            ccp.SET_MTA,
+            mta,
+            address_extension,
+            *address,
+        )
+
+    def dnload(self, size: int, data: bytes) -> Optional[CommandResponse]:
+        _transfer_size(size)
+        data = _payload(data, size, size)
+
+        return self._execute(
+            ccp.DNLOAD,
+            size,
+            *data,
+        )
+
+    def upload(self, size: int) -> Optional[CommandResponse]:
+        _transfer_size(size)
+
+        return self._execute(
+            ccp.UPLOAD,
+            size,
+        )
+
+    def get_daq_size(
+        self, daq_list_number: int, address: int
+    ) -> Optional[CommandResponse]:
+        address = _pack_address(address)
+
+        return self._execute(
+            ccp.GET_DAQ_SIZE,
+            daq_list_number,
+            0x00,
+            *address,
+        )
+
+    def set_daq_ptr(
+        self, daq_list_number: int, odt_number: int, element_number: int
+    ) -> Optional[CommandResponse]:
+        return self._execute(
+            ccp.SET_DAQ_PTR,
+            daq_list_number,
+            odt_number,
+            element_number,
+        )
+
+    def write_daq(
+        self, element_size: int, address_extension: int, address: int
+    ) -> Optional[CommandResponse]:
+        address = _pack_address(address)
+        _unsigned("Address extension", address_extension, 8)
+        return self._execute(
+            ccp.WRITE_DAQ,
+            element_size,
+            address_extension,
+            *address,
+        )
+
+    def start_stop(
+        self,
+        mode: int,
+        daq_list_number: int,
+        last_odt_number: int,
+        event_channel: int,
+        rate_prescaler: int,
+    ) -> Optional[CommandResponse]:
+        rate_prescaler = struct.pack(
+            "<H", _unsigned("Rate prescaler", rate_prescaler, 16)
+        )
+
+        return self._execute(
+            ccp.START_STOP,
+            mode,
+            daq_list_number,
+            last_odt_number,
+            event_channel,
+            *rate_prescaler,
+        )
+
+    def disconnect(
+        self, disconnect_type: ccp.DisconnectType, address: int
+    ) -> Optional[CommandResponse]:
+        address = struct.pack("<H", _unsigned("Station address", address, 16))
+
+        return self._execute(
+            ccp.DISCONNECT,
+            disconnect_type,
+            0x00,
+            *address,
+        )
+
+    # Optional Commands.
+    def test(self, station_id: int) -> Optional[CommandResponse]:
+        to_send = struct.pack("<H", _unsigned("Station address", station_id, 16))
+
+        return self._execute(ccp.TEST, *to_send)
+
+    def dnload6(self, data: bytes) -> Optional[CommandResponse]:
+        data = _payload(data, 6, 6)
+        return self._execute(
+            ccp.DNLOAD_6,
+            *data,
+        )
+
+    def short_up(
+        self, size: int, address: int, address_extension: int = 0
+    ) -> Optional[CommandResponse]:
+        _transfer_size(size)
+        address = _pack_address(address)
+        _unsigned("Address extension", address_extension, 8)
+        return self._execute(
+            ccp.SHORT_UP,
+            size,
+            address_extension,
+            *address,
+        )
+
+    def start_stop_all(self, mode: int) -> Optional[CommandResponse]:
+        return self._execute(
+            ccp.START_STOP_ALL,
+            mode,
+        )
+
+    def set_s_status(self, status: int) -> Optional[CommandResponse]:
+        status = struct.pack("<B", _unsigned("Status", status, 8))
+
+        return self._execute(
+            ccp.SET_S_STATUS,
+            *status,
+        )
+
+    def get_s_status(self) -> Optional[CommandResponse]:
+        return self._execute(ccp.GET_S_STATUS)
+
+    def build_chksum(self, block_size: int) -> Optional[CommandResponse]:
+        block_size = struct.pack("<L", _unsigned("Block size", block_size, 32))
+
+        return self._execute(
+            ccp.BUILD_CHKSUM,
+            *block_size,
+        )
+
+    def clear_memory(self, block_size: int) -> Optional[CommandResponse]:
+        block_size = struct.pack("<L", _unsigned("Block size", block_size, 32))
+
+        return self._execute(
+            ccp.CLEAR_MEMORY,
+            *block_size,
+        )
+
+    def program(self, data: bytes) -> Optional[CommandResponse]:
+        """Program 1–5 bytes at MTA0; empty data ends the programming sequence."""
+        data = _payload(data, 0, 5)
+
+        return self._execute(
+            ccp.PROGRAM,
+            len(data),
+            *data,
+        )
+
+    def program6(self, data: bytes) -> Optional[CommandResponse]:
+        """Program exactly six bytes at MTA0, with no size byte or implicit retries."""
+        data = _payload(data, 6, 6)
+
+        return self._execute(
+            ccp.PROGRAM_6,
+            *data,
+        )
+
+    def diag_service(
+        self, service_number: int, parameters: bytes = b""
+    ) -> Optional[CommandResponse]:
+        """Run a diagnostic service with up to four-parameter bytes.
+
+        Return the raw CRM (or None on timeout). The slave sets MTA0 to the
+        return information; use upload() separately to read that information.
+        """
+        service_number = struct.pack(
+            "<H", _unsigned("Diagnostic service number", service_number, 16)
+        )
+        parameters = _payload(parameters, 0, 4)
+
+        return self._execute(
+            ccp.DIAG_SERVICE,
+            *service_number,
+            *parameters,
+        )
+
+    def move(self, size: int) -> Optional[CommandResponse]:
+        size = struct.pack("<L", _unsigned("Size", size, 32))
+
+        return self._execute(ccp.MOVE, *size)
+
+    def get_active_cal_page(self) -> Optional[CommandResponse]:
+        return self._execute(ccp.GET_ACTIVE_CAL_PAGE)
+
+    def select_cal_page(self) -> Optional[CommandResponse]:
+        return self._execute(ccp.SELECT_CAL_PAGE)
+
+    def unlock(self, key: bytes) -> Optional[CommandResponse]:
+        key = _payload(key, 0, 6)
+        return self._execute(
+            ccp.UNLOCK,
+            *key,
+        )
+
+    def get_seed(self, resource: SecondaryResource) -> Optional[CommandResponse]:
+        return self._execute(
+            ccp.GET_SEED,
+            resource,
+        )

pyccp-0.10.0.dist-info/METADATA

@@ -0,0 +1,87 @@
+Metadata-Version: 2.5
+Name: pyccp
+Version: 0.10.0
+Summary: CAN Calibration Protocol for Python
+Author-email: Vladimir Petrigo <vladimir.petrigo@gmail.com>
+License-File: LICENSE.md
+Keywords: asam,automotive,ccp,ecu
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Software Development
+Requires-Python: >=3.11
+Requires-Dist: python-can<5,>=4
+Description-Content-Type: text/markdown
+
+[![CI](https://github.com/vpetrigo/pyccp/actions/workflows/ci.yml/badge.svg)](https://github.com/vpetrigo/pyccp/actions/workflows/ci.yml)
+[![PyPI - Version](https://img.shields.io/pypi/v/pyccp)](https://pypi.org/project/pyccp)
+![PyPI - Python Version](https://img.shields.io/pypi/pyversions/pyccp)
+[![PyPI Downloads](https://static.pepy.tech/personalized-badge/pyccp?period=monthly&units=INTERNATIONAL_SYSTEM&left_color=GREY&right_color=GREEN&left_text=downloads%2Fmonth)](https://pepy.tech/projects/pyccp)
+
+# CAN Calibration Protocol for Python
+
+Python implementation of the CAN Calibration Protocol (CCP) v2.1 Master, built
+on [python-can](https://python-can.readthedocs.io/). Inspired by [pySART/pyccp](https://github.com/pySART/pyccp).
+
+## Install
+
+```toml
+dependencies = [
+    "pyccp==0.10.0"
+]
+```
+
+## Quick Start
+
+```python
+import can
+from pyccp import Master
+from pyccp.ccp import ReturnCodes
+
+bus = can.Bus(interface="socketcan", channel="can0")
+
+with Master(bus, cro=0x7E1, dto=0x815) as master:
+    resp = master.connect(address=0x39)
+    assert resp is not None and resp.code == ReturnCodes.ACKNOWLEDGE
+
+    resp = master.set_mta(address=0x1000)
+    assert resp is not None and resp.code == ReturnCodes.ACKNOWLEDGE
+
+    resp = master.clear_memory(block_size=0x200)
+    chunks = [b"abcdef", b"ghi", b""]
+
+    for chunk in chunks:
+        resp = master.program6(chunk)
+        assert resp is not None and resp.code == ReturnCodes.ACKNOWLEDGE
+```
+
+## DAQ & Events
+
+```python
+from pyccp import Master, DAQMessage, CommandResponse
+
+with Master(bus, cro=0x7E1, dto=0x815) as master:
+    # Register a callback for DAQ messages
+    master.on_daq(0x816, lambda msg: print(f"DAQ: {msg.daq_id:#04X}, ODT: {msg.pid}, data: {msg.data.hex()}"))
+    # Connect and configure DAQ list
+```
+
+## Logging
+
+```python
+import logging
+
+logging.getLogger("pyccp").setLevel(logging.DEBUG)
+```
+
+## Tests
+
+```sh
+hatch test -py 3.15
+```

pyccp-0.10.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+pyccp/__init__.py,sha256=Ys1PlqDDrAVc3Gnhj3hFWd85AEqIyrvFPCDQkoI5ET4,158
+pyccp/ccp.py,sha256=7qJUz9WwvZeJ6PE8a7AOtRCNghOjyCjlhJazrYvSxyY,3317
+pyccp/master.py,sha256=tTfkXdI12WJF44e2nq8n55gElP-QloicylO_ehkp0Ts,17031
+pyccp-0.10.0.dist-info/METADATA,sha256=S8gblKY9AfL3A7zyUEM16O9yY6hcJ8H1AIujHnS7YI8,2709
+pyccp-0.10.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+pyccp-0.10.0.dist-info/licenses/LICENSE.md,sha256=I5-2rJHdNVVOaXNl4aYS3C1CPfA9hDnkyNQkB8ZWlUY,1073
+pyccp-0.10.0.dist-info/RECORD,,

pyccp-0.10.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.33.0
+Root-Is-Purelib: true
+Tag: py3-none-any

pyccp-0.10.0.dist-info/licenses/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Vladimir Petrigo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.