Python-CAN

https://python-can.readthedocs.io/en/stable
Admin
A Python library providing Controller Area Network (CAN) communication support, allowing...
Tokens:217,648
Snippets:1,363
Trust Score:8.3
Update:3 months ago
Show doc for...
Tokens:
Raw
### Install socketcand

Source: https://python-can.readthedocs.io/en/stable/_sources/interfaces/socketcand.rst.txt

Install the compiled socketcand binary.

```bash
make install
```

--------------------------------

### Setup Development Environment with pip

Source: https://python-can.readthedocs.io/en/stable/_sources/development.rst.txt

Traditional workflow for creating a virtual environment and installing the package in editable mode.

```shell
# Create a new virtual environment
python -m venv .venv

# Activate the environment
.venv\Scripts\activate    # On Windows
source .venv/bin/activate  # On Unix/macOS

# Upgrade pip and install python-can in editable mode with development dependencies
python -m pip install --upgrade pip
pip install -e .[dev]

# Run your script
python snippet.py
```

--------------------------------

### Install Development Tools

Source: https://python-can.readthedocs.io/en/stable/_sources/development.rst.txt

Install tox using uv for managing project dependencies and test environments.

```shell
uv tool install tox --with tox-uv
```

--------------------------------

### Install Multicast Dependencies

Source: https://python-can.readthedocs.io/en/stable/_sources/interfaces/udp_multicast.rst.txt

Install the required msgpack library using the multicast extra.

```bash
$ pip install python-can[multicast]
```

--------------------------------

### Install CANtact backend

Source: https://python-can.readthedocs.io/en/stable/_sources/installation.rst.txt

Commands to install the CANtact driver backend for python-can.

```bash
python3 -m pip install "python-can[cantact]"
```

```bash
pip install cantact
```

--------------------------------

### Install python-can with interface extras

Source: https://python-can.readthedocs.io/en/stable/_sources/installation.rst.txt

Install the package along with specific hardware interface dependencies.

```bash
$ pip install python-can[serial]
```

--------------------------------

### Install Seeed Studio dependencies

Source: https://python-can.readthedocs.io/en/stable/_sources/interfaces/seeedstudio.rst.txt

Install the required dependencies for the Seeed Studio interface using pip.

```bash
pip install python-can[seeedstudio]
```

--------------------------------

### start()

Source: https://python-can.readthedocs.io/en/stable/_modules/can/interfaces/socketcan/socketcan.html

Restarts a periodic task by sending a TX_SETUP message to the Linux kernel after verifying the task's existence.

```APIDOC
## start()

### Description
Restarts a periodic task by sending a TX_SETUP message to the Linux kernel. It verifies the presence of the BCM task by sending a TX_READ message prior to scheduling.

### Parameters
None
```

--------------------------------

### Install python-can pre-release

Source: https://python-can.readthedocs.io/en/stable/_sources/installation.rst.txt

Install the latest available pre-release version of the package.

```bash
pip install --upgrade --pre python-can
```

--------------------------------

### Install PCAN and Viewer dependencies

Source: https://python-can.readthedocs.io/en/stable/installation.html

Install optional dependencies for PCAN support or the CAN viewer terminal application.

```bash
pip install python-can[pcan]
```

```bash
python -m pip install "python-can[viewer]"
```

--------------------------------

### Install in development mode

Source: https://python-can.readthedocs.io/en/stable/_sources/installation.rst.txt

Install the package in editable mode to allow local modifications.

```bash
# install in editable mode
cd <path-to-this-repo>
python3 -m pip install -e .
```

--------------------------------

### Load Configuration File

Source: https://python-can.readthedocs.io/en/stable/internal-api.html

Example content for a configuration file used by load_file_config.

```ini
[default]
interface = socketcan
channel = can0
```

--------------------------------

### Install python-can via pip

Source: https://python-can.readthedocs.io/en/stable/_sources/installation.rst.txt

Standard installation command for the python-can package.

```bash
$ pip install python-can
```

--------------------------------

### Build socketcand from source

Source: https://python-can.readthedocs.io/en/stable/_sources/interfaces/socketcand.rst.txt

Install dependencies and compile the socketcand daemon from the official repository.

```bash
# autoconf is needed to build socketcand
sudo apt-get install -y autoconf
# clone & build sources
git clone https://github.com/linux-can/socketcand.git
cd socketcand
./autogen.sh
./configure
make
```

--------------------------------

### Enable and start systemd-networkd

Source: https://python-can.readthedocs.io/en/stable/_sources/interfaces/socketcand.rst.txt

Enable the network service to ensure the CAN interface starts on boot.

```bash
sudo systemctl enable systemd-networkd
sudo systemctl start systemd-networkd
```

--------------------------------

### Install CanViewer dependencies

Source: https://python-can.readthedocs.io/en/stable/_sources/installation.rst.txt

Install the necessary dependencies to run the CAN viewer terminal application.

```bash
python -m pip install "python-can[viewer]"
```

--------------------------------

### Install python-can with neoVI support

Source: https://python-can.readthedocs.io/en/stable/_sources/interfaces/neovi.rst.txt

Use pip to install the python-can package along with the necessary extras for neoVI hardware.

```bash
pip install python-can[neovi]
```

--------------------------------

### Registering a Listener with a Notifier

Source: https://python-can.readthedocs.io/en/stable/_sources/notifier.rst.txt

Example demonstrating how to use a Notifier to distribute messages to a listener.

```python
import can

# Create a bus instance
bus = can.interface.Bus(bustype='virtual', channel='test')

# Create a listener that prints messages
printer = can.Printer()

# Create a notifier to distribute messages to the listener
notifier = can.Notifier(bus, [printer])

# Send a message to the bus
bus.send(can.Message(arbitration_id=0x123))

# Stop the notifier when done
notifier.stop()
```

--------------------------------

### Configure CAN bus timing

Source: https://python-can.readthedocs.io/en/stable/scripts.html

Examples for setting bit rate and timing parameters for classical CAN and CAN FD buses.

```bash
--timing f_clock=8_000_000 tseg1=5 tseg2=2 sjw=2
                        brp=2 nof_samples=1
```

```bash
--timing
                        f_clock=80_000_000 nom_tseg1=119 nom_tseg2=40
                        nom_sjw=40 nom_brp=1 data_tseg1=29 data_tseg2=10
                        data_sjw=10 data_brp=1
```

--------------------------------

### Set CAN configuration via environment variables

Source: https://python-can.readthedocs.io/en/stable/_sources/configuration.rst.txt

Example of passing configuration settings through shell environment variables.

```bash
CAN_INTERFACE=socketcan CAN_CONFIG={"receive_own_messages": true, "fd": true}
```

--------------------------------

### Configure can.ini for neoVI

Source: https://python-can.readthedocs.io/en/stable/_sources/interfaces/neovi.rst.txt

Example configuration for a Windows environment specifying the neoVI interface and channel.

```ini
[default]
interface = neovi
channel = 1
```

--------------------------------

### Configure systemd-networkd for CAN interface

Source: https://python-can.readthedocs.io/en/stable/_sources/interfaces/socketcand.rst.txt

Create a network configuration file to automatically start the can0 interface.

```bash
cat >/etc/systemd/network/80-can.network <<'EOT'
[Match]
Name=can0
[CAN]
BitRate=250K
RestartSec=100ms
EOT
```

--------------------------------

### Configure CAN 2.0 Bit Timings via Config File

Source: https://python-can.readthedocs.io/en/stable/_sources/bit_timing.rst.txt

Example of specifying CAN 2.0 bit timing parameters within a configuration file.

```none
[default]
f_clock=8000000
brp=1
tseg1=5
tseg2=2
sjw=1
nof_samples=1
```

--------------------------------

### Configure Vector interface in configuration file

Source: https://python-can.readthedocs.io/en/stable/_sources/interfaces/vector.rst.txt

Example configuration for connecting to CAN channels 0 and 1 using a specific application name.

```ini
[default]
interface = vector
channel = 0, 1
app_name = python-can
```

--------------------------------

### Socketcand verbose output

Source: https://python-can.readthedocs.io/en/stable/interfaces/socketcand.html

Example of the output displayed when socketcand starts with verbose mode enabled.

```text
Verbose output activated

Using network interface 'eth0'
Listen adress is 10.0.16.15
Broadcast adress is 10.0.255.255
creating broadcast thread...
binding socket to 10.0.16.15:29536

```

--------------------------------

### Register Interface in setup.py

Source: https://python-can.readthedocs.io/en/stable/plugin-interface.html

Configure the entry point using the setup.py format.

```python
from setuptools import setup

setup(
    # ...,
    entry_points = {
        'can.interface': [
            'interface_name = module:classname'
        ]
    }
)
```

--------------------------------

### Register Interface in setup.cfg

Source: https://python-can.readthedocs.io/en/stable/plugin-interface.html

Configure the entry point using the setup.cfg format.

```ini
[options.entry_points]
can.interface =
    interface_name = module:classname
```

--------------------------------

### Initialize BitTiming configurations

Source: https://python-can.readthedocs.io/en/stable/_modules/can/bit_timing.html

Demonstrates various methods to instantiate a BitTiming object, including direct parameter setting, bitrate-based calculation, register definition, and sample point calculation.

```python
can.BitTiming(f_clock=8_000_000, brp=1, tseg1=5, tseg2=1, sjw=1)
```

```python
can.BitTiming.from_bitrate_and_segments(
    f_clock=8_000_000, bitrate=1_000_000, tseg1=5, tseg2=1, sjw=1
)
```

```python
can.BitTiming.from_registers(f_clock=8_000_000, btr0=0x00, btr1=0x14)
```

```python
can.BitTiming.from_sample_point(f_clock=8_000_000, bitrate=1_000_000, sample_point=75.0)
```

--------------------------------

### Start CAN Controller

Source: https://python-can.readthedocs.io/en/stable/_modules/can/interfaces/ixxat/canlib_vcinpl2.html

Starts the CAN controller and initializes timing offsets for message timestamps.

```python
        # Start the CAN controller. Messages will be forwarded to the channel
        start_begin = time.time()
        _canlib.canControlStart(self._control_handle, constants.TRUE)
        start_end = time.time()

        # Calculate an offset to make them relative to epoch
        # Assume that the time offset is in the middle of the start command
        self._timeoffset = start_begin + (start_end - start_begin / 2)
        self._overrunticks = 0
        self._starttickoffset = 0
```

--------------------------------

### Initialize Seeed Studio Bus

Source: https://python-can.readthedocs.io/en/stable/_sources/interfaces/seeedstudio.rst.txt

Create a bus instance for the Seeed Studio USB-CAN Analyzer.

```python
bus = can.interface.Bus(interface='seeedstudio', channel='/dev/ttyUSB0', bitrate=500000)
```

--------------------------------

### Initialize gs_usb Bus with Specific Address

Source: https://python-can.readthedocs.io/en/stable/_sources/interfaces/gs_usb.rst.txt

Demonstrates opening a specific device by providing the bus and address parameters retrieved via pyusb.

```python
import usb
import can

dev = usb.core.find(idVendor=0x1D50, idProduct=0x606F)
bus = can.Bus(
    interface="gs_usb",
    channel=dev.product,
    bus=dev.bus,
    address=dev.address,
    bitrate=250000
)
```

--------------------------------

### IXXATBus.__init__

Source: https://python-can.readthedocs.io/en/stable/_modules/can/interfaces/ixxat/canlib_vcinpl.html

Initializes a new instance of the IXXATBus, configuring the channel, bitrate, and hardware-specific FIFO settings.

```APIDOC
## IXXATBus.__init__

### Description
Initializes the IXXAT CAN bus interface. Note that message filters must be provided during initialization as `set_filters` is not supported.

### Parameters
- **channel** (int) - Required - The Channel id to create this bus with.
- **can_filters** (list, optional) - Optional - List of filters to apply to incoming messages.
- **receive_own_messages** (bool) - Optional - Enable self-reception of sent messages (default: False).
- **unique_hardware_id** (int) - Optional - Unique hardware ID to connect to.
- **extended** (bool) - Optional - Enables the capability to use extended IDs (default: True).
- **rx_fifo_size** (int) - Optional - Receive FIFO size (default: 16).
- **tx_fifo_size** (int) - Optional - Transmit FIFO size (default: 16).
- **bitrate** (int) - Optional - Channel bitrate in bit/s (default: 500000).
```

--------------------------------

### Initialize BitTiming from bitrate and segments

Source: https://python-can.readthedocs.io/en/stable/bit_timing.html

Create a configuration by specifying the desired bitrate instead of the bit rate prescaler.

```python
can.BitTiming.from_bitrate_and_segments(
    f_clock=8_000_000, bitrate=1_000_000, tseg1=5, tseg2=1, sjw=1
)
```

--------------------------------

### Start cyclic transmission

Source: https://python-can.readthedocs.io/en/stable/_modules/can/broadcastmanager.html

Initializes and starts the background thread for cyclic message transmission.

```python
    def start(self) -> None:
        self.stopped = False
        if self.thread is None or not self.thread.is_alive():
            name = f"Cyclic send task for 0x{self.messages[0].arbitration_id:X}"
            self.thread = threading.Thread(target=self._run, name=name)
            self.thread.daemon = True

            self.end_time: Optional[float] = (
                time.perf_counter() + self.duration if self.duration else None
            )

            if self.event and PYWIN32:
                PYWIN32.set_timer(self.event, self.period_ms)

            self.thread.start()
```

--------------------------------

### Open Vector hardware configuration window

Source: https://python-can.readthedocs.io/en/stable/_modules/can/interfaces/vector/canlib.html

Opens the Vector hardware configuration GUI, optionally waiting for user input.

```python
@staticmethod
def popup_vector_hw_configuration(wait_for_finish: int = 0) -> None:
    """Open vector hardware configuration window.

    :param wait_for_finish:
        Time to wait for user input in milliseconds.
    """
    if xldriver is None:
        raise CanInterfaceNotImplementedError("The Vector API has not been loaded")

    xldriver.xlPopupHwConfig(ctypes.c_char_p(), ctypes.c_uint(wait_for_finish))
```

--------------------------------

### Using the Listener class

Source: https://python-can.readthedocs.io/en/stable/_modules/can/listener.html

Demonstrates how to instantiate a listener, receive a message from a bus, and process it using the listener instance.

```python
listener = SomeListener()
msg = my_bus.recv()

# now either call
listener(msg)
# or
listener.on_message_received(msg)

# Important to ensure all outputs are flushed
listener.stop()
```

--------------------------------

### Create BitTiming from sample point

Source: https://python-can.readthedocs.io/en/stable/_modules/can/bit_timing.html

Initializes a BitTiming instance based on clock frequency, bitrate, and a target sample point percentage.

```python
@classmethod
def from_sample_point(
    cls, f_clock: int, bitrate: int, sample_point: float = 69.0
) -> "BitTiming":
    """Create a :class:`~can.BitTiming` instance for a sample point.

    This function tries to find bit timings, which are close to the requested
    sample point. It does not take physical bus properties into account, so the
    calculated bus timings might not work properly for you.

    The :func:`oscillator_tolerance` function might be helpful to evaluate the
    bus timings.

    :param int f_clock:
        The CAN system clock frequency in Hz.
    :param int bitrate:
        Bitrate in bit/s.
    :param int sample_point:
        The sample point value in percent.
    :raises ValueError:
        if the arguments are invalid.
    """

    if sample_point < 50.0:
        raise ValueError(f"sample_point (={sample_point}) must not be below 50%.")

    possible_solutions: list[BitTiming] = list(
        cls.iterate_from_sample_point(f_clock, bitrate, sample_point)
    )

    if not possible_solutions:
        raise ValueError("No suitable bit timings found.")

    # sort solutions
    for key, reverse in (
        # prefer low prescaler
        (lambda x: x.brp, False),
        # prefer low sample point deviation from requested values
        (lambda x: abs(x.sample_point - sample_point), False),
    ):
        possible_solutions.sort(key=key, reverse=reverse)

    return possible_solutions[0]
```

--------------------------------

### Initialize gs_usb Bus

Source: https://python-can.readthedocs.io/en/stable/_sources/interfaces/gs_usb.rst.txt

Demonstrates initializing the bus using automatic device detection by index or channel.

```python
import can
import usb
dev = usb.core.find(idVendor=0x1D50, idProduct=0x606F)

bus = can.Bus(interface="gs_usb", channel=dev.product, index=0, bitrate=250000)
bus = can.Bus(interface="gs_usb", channel=0, bitrate=250000)  # same
```

--------------------------------

### VectorBus.send_periodic()

Source: https://python-can.readthedocs.io/en/stable/interfaces/vector.html

Starts sending messages at a given period on this bus.

```APIDOC
## send_periodic(msgs, period, duration=None, store_task=True, autostart=True, modifier_callback=None)

### Description
Start sending messages at a given period on this bus.

### Parameters
- **msgs** (Message | Sequence[Message]) - Required - Message(s) to transmit.
- **period** (float) - Required - Period in seconds between each message.
- **duration** (float | None) - Optional - Approximate duration in seconds to continue sending messages.
- **store_task** (bool) - Optional - If True, the task will be attached to this Bus instance.
- **autostart** (bool) - Optional - If True, the sending task will immediately start after creation.
- **modifier_callback** (Callable[[Message], None] | None) - Optional - Function which should be used to modify each message’s data before sending.
```

--------------------------------

### Read CAN messages

Source: https://python-can.readthedocs.io/en/stable/_sources/interfaces/socketcan.rst.txt

Examples for blocking and non-blocking reads from the bus.

```python
import can

bus = can.Bus(channel='vcan0', interface='socketcan')
message = bus.recv()
```

```python
message = bus.recv(1.0)  # Timeout in seconds.

if message is None:
    print('Timeout occurred, no message.')
```

--------------------------------

### Initialize PCAN hardware

Source: https://python-can.readthedocs.io/en/stable/_sources/interfaces/socketcan.rst.txt

Commands to load PCAN drivers and bring up a CAN interface.

```bash
sudo modprobe peak_usb
sudo modprobe peak_pci
sudo ip link set can0 up type can bitrate 500000
```

--------------------------------

### Initialize IXXAT VCI Device and Channel

Source: https://python-can.readthedocs.io/en/stable/_modules/can/interfaces/ixxat/canlib_vcinpl.html

Handles the enumeration of available IXXAT devices, opening the specified channel, and configuring the control parameters.

```python
# Search for supplied device
        if unique_hardware_id is None:
            log.info("Searching for first available device")
        else:
            log.info("Searching for unique HW ID %s", unique_hardware_id)
        _canlib.vciEnumDeviceOpen(ctypes.byref(self._device_handle))
        while True:
            try:
                _canlib.vciEnumDeviceNext(
                    self._device_handle, ctypes.byref(self._device_info)
                )
            except StopIteration:
                if unique_hardware_id is None:
                    raise VCIDeviceNotFoundError(
                        "No IXXAT device(s) connected or device(s) in use by other process(es)."
                    ) from None
                else:
                    raise VCIDeviceNotFoundError(
                        f"Unique HW ID {unique_hardware_id} not connected or not available."
                    ) from None
            else:
                if (unique_hardware_id is None) or (
                    self._device_info.UniqueHardwareId.AsChar
                    == bytes(unique_hardware_id, "ascii")
                ):
                    break

                log.debug(
                    "Ignoring IXXAT with hardware id '%s'.",
                    self._device_info.UniqueHardwareId.AsChar.decode("ascii"),
                )
        _canlib.vciEnumDeviceClose(self._device_handle)

        try:
            _canlib.vciDeviceOpen(
                ctypes.byref(self._device_info.VciObjectId),
                ctypes.byref(self._device_handle),
            )
        except Exception as exception:
            raise CanInitializationError(
                f"Could not open device: {exception}"
            ) from exception

        log.info("Using unique HW ID %s", self._device_info.UniqueHardwareId.AsChar)

        log.info(
            "Initializing channel %d in shared mode, %d rx buffers, %d tx buffers",
            channel,
            rx_fifo_size,
            tx_fifo_size,
        )

        try:
            _canlib.canChannelOpen(
                self._device_handle,
                channel,
                constants.FALSE,
                ctypes.byref(self._channel_handle),
            )
        except Exception as exception:
            raise CanInitializationError(
                f"Could not open and initialize channel: {exception}"
            ) from exception

        # Signal TX/RX events when at least one frame has been handled
        _canlib.canChannelInitialize(
            self._channel_handle, rx_fifo_size, 1, tx_fifo_size, 1
        )
        _canlib.canChannelActivate(self._channel_handle, constants.TRUE)

        log.info("Initializing control %d bitrate %d", channel, bitrate)
        _canlib.canControlOpen(
            self._device_handle, channel, ctypes.byref(self._control_handle)
        )

        # compute opmode before control initialize
        opmode = constants.CAN_OPMODE_STANDARD | constants.CAN_OPMODE_ERRFRAME
        if extended:
            opmode |= constants.CAN_OPMODE_EXTENDED

        # control initialize
        _canlib.canControlInitialize(
            self._control_handle,
            opmode,
            self.CHANNEL_BITRATES[0][bitrate],
            self.CHANNEL_BITRATES[1][bitrate],
        )
        _canlib.canControlGetCaps(
            self._control_handle, ctypes.byref(self._channel_capabilities)
        )

        # With receive messages, this field contains the relative reception time of
        # the message in ticks. The resolution of a tick can be calculated from the fields
        # dwClockFreq and dwTscDivisor of the structure  CANCAPABILITIES in accordance with the following formula:
        # frequency [1/s] = dwClockFreq / dwTscDivisor
        self._tick_resolution = (
            self._channel_capabilities.dwClockFreq
            / self._channel_capabilities.dwTscDivisor
        )
```

--------------------------------

### stop_all_periodic_tasks(remove_tasks=True)

Source: https://python-can.readthedocs.io/en/stable/bus.html

Stops all periodic tasks started via send_periodic.

```APIDOC
## stop_all_periodic_tasks

### Description
Stop sending any messages that were started using send_periodic.

### Parameters
- **remove_tasks** (bool) - Optional - Stop tracking the stopped tasks.
```

--------------------------------

### Run socketcand daemon

Source: https://python-can.readthedocs.io/en/stable/_sources/interfaces/socketcand.rst.txt

Start the socketcand daemon on the specified CAN interface.

```bash
./socketcand -v -i can0
```

--------------------------------

### Configure PCAN-USB interface

Source: https://python-can.readthedocs.io/en/stable/_sources/interfaces/pcan.rst.txt

Example configuration file for a PCAN-USB device.

```ini
[default]
interface = pcan
channel = PCAN_USBBUS1
state = PASSIVE
bitrate = 500000
```

--------------------------------

### Initialize BitTimingFd

Source: https://python-can.readthedocs.io/en/stable/_modules/can/bit_timing.html

Demonstrates various ways to construct a BitTimingFd instance for CAN FD, including direct parameter specification, bitrate-based calculation, and sample point-based calculation.

```python
can.BitTimingFd(
    f_clock=80_000_000,
    nom_brp=1,
    nom_tseg1=59,
    nom_tseg2=20,
    nom_sjw=10,
    data_brp=1,
    data_tseg1=6,
    data_tseg2=3,
    data_sjw=2,
)
```

```python
can.BitTimingFd.from_bitrate_and_segments(
    f_clock=80_000_000,
    nom_bitrate=1_000_000,
    nom_tseg1=59,
    nom_tseg2=20,
    nom_sjw=10,
    data_bitrate=8_000_000,
    data_tseg1=6,
    data_tseg2=3,
    data_sjw=2,
)
```

```python
can.BitTimingFd.from_sample_point(
    f_clock=80_000_000,
    nom_bitrate=1_000_000,
    nom_sample_point=75.0,
    data_bitrate=8_000_000,
    data_sample_point=70.0,
)
```

--------------------------------

### Build distribution and verify

Source: https://python-can.readthedocs.io/en/stable/_sources/development.rst.txt

Builds the source distribution and checks the package with twine.

```shell
uv build
uvx twine check --strict dist/*
```

--------------------------------

### Get Message Count

Source: https://python-can.readthedocs.io/en/stable/_modules/can/io/sqlite.html

Returns the total number of messages in the database table.

```python
def __len__(self) -> int:
    # this might not run in constant time
    result = self._cursor.execute(f"SELECT COUNT(*) FROM {self.table_name}")
    return int(result.fetchone()[0])
```

--------------------------------

### Device Number Management

Source: https://python-can.readthedocs.io/en/stable/_modules/can/interfaces/pcan/pcan.html

Methods to get and set the PCAN device number.

```python
def get_device_number(self):
    """
    Return the PCAN device number.

    :rtype: int
    :return: PCAN device number
    """
    error, value = self.m_objPCANBasic.GetValue(
        self.m_PcanHandle, PCAN_DEVICE_NUMBER
    )
    if error != PCAN_ERROR_OK:
        return None
    return value
```

```python
def set_device_number(self, device_number):
    """
    Set the PCAN device number.

    :param device_number: new PCAN device number
    :rtype: bool
    :return: True if device number set successfully
    """
    try:
        if (
            self.m_objPCANBasic.SetValue(
                self.m_PcanHandle, PCAN_DEVICE_NUMBER, int(device_number)
            )
            != PCAN_ERROR_OK
        ):
            raise ValueError()
    except ValueError:
        log.error("Invalid value '%s' for device number.", device_number)
        return False
    return True
```

--------------------------------

### Load Configuration from File

Source: https://python-can.readthedocs.io/en/stable/_modules/can/util.html

Reads configuration settings from an INI-style file. If no path is provided, it searches default platform-specific locations.

```python
def load_file_config(
    path: Optional[typechecking.StringPathLike] = None, section: str = "default"
) -> dict[str, str]:
    """
    Loads configuration from file with following content::

        [default]
        interface = socketcan
        channel = can0

    :param path:
        path to config file. If not specified, several sensible
        default locations are tried depending on platform.
    :param section:
        name of the section to read configuration from.
    """
    config = ConfigParser()

    # make sure to not transform the entries such that capitalization is preserved
    config.optionxform = lambda optionstr: optionstr  # type: ignore[method-assign]

    if path is None:
        config.read([os.path.expanduser(path) for path in CONFIG_FILES])
    else:
        config.read(path)

    _config: dict[str, str] = {}

    if config.has_section(section):
        _config.update(config.items(section))

    return _config
```

--------------------------------

### Get file descriptor

Source: https://python-can.readthedocs.io/en/stable/_modules/can/interfaces/slcan.html

Retrieves the file descriptor for the underlying serial port.

```python
    def fileno(self) -> int:
        try:
            return cast("int", self.serialPortOrig.fileno())
        except io.UnsupportedOperation:
            raise NotImplementedError(
                "fileno is not implemented using current CAN bus on this platform"
            ) from None
        except Exception as exception:
            raise CanOperationError("Cannot fetch fileno") from exception
```

--------------------------------

### Display can.logger help information

Source: https://python-can.readthedocs.io/en/stable/scripts.html

Run the help command to view all available arguments and configuration options for the logger.

```bash
$ python -m can.logger -h
usage: logger.py [-h] [-f LOG_FILE] [-a] [-s FILE_SIZE] [-v] [--active |
                 --passive] [-c CHANNEL]
                 [-i {canalystii,cantact,etas,gs_usb,iscan,ixxat,kvaser,neousys,neovi,nican,nixnet,pcan,robotell,seeedstudio,serial,slcan,socketcan,socketcand,systec,udp_multicast,usb2can,vector,virtual}]
                 [-b BITRATE] [--fd] [--data-bitrate DATA_BITRATE]
                 [--timing TIMING_ARG [TIMING_ARG ...]]
                 [--filter {<can_id>:<can_mask>,<can_id>~<can_mask>} [{<can_id>:<can_mask>,<can_id>~<can_mask>} ...]]
                 [--bus-kwargs BUS_KWARG [BUS_KWARG ...]]
                 ...

Log CAN traffic, printing messages to stdout or to a given file.

options:
  -h, --help            show this help message and exit

logger arguments:
  -f, --file_name LOG_FILE
                        Path and base log filename, for supported types see
                        can.Logger.
  -a, --append          Append to the log file if it already exists.
  -s, --file_size FILE_SIZE
                        Maximum file size in bytes. Rotate log file when size
                        threshold is reached. (The resulting file sizes will
                        be consistent, but are not guaranteed to be exactly
                        what is specified here due to the rollover conditions
                        being logger implementation specific.)
  -v                    How much information do you want to see at the command
                        line? You can add several of these e.g., -vv is DEBUG
  --active              Start the bus as active, this is applied by default.
  --passive             Start the bus as passive.
  extra_args            The remaining arguments will be used for logger/player
                        initialisation. For example, `can_logger -i virtual -c
                        test -f logfile.blf --compression-level=9` passes the
                        keyword argument `compression_level=9` to the
                        BlfWriter.

bus arguments:
  -c, --channel CHANNEL
                        Most backend interfaces require some sort of channel.
                        For example with the serial interface the channel
                        might be a rfcomm device: "/dev/rfcomm0". With the
                        socketcan interface valid channel examples include:
                        "can0", "vcan0".
  -i, --interface {canalystii,cantact,etas,gs_usb,iscan,ixxat,kvaser,neousys,neovi,nican,nixnet,pcan,robotell,seeedstudio,serial,slcan,socketcan,socketcand,systec,udp_multicast,usb2can,vector,virtual}
                        Specify the backend CAN interface to use. If left
                        blank, fall back to reading from configuration files.
  -b, --bitrate BITRATE
                        Bitrate to use for the CAN bus.
  --fd                  Activate CAN-FD support
  --data-bitrate DATA_BITRATE
                        Bitrate to use for the data phase in case of CAN-FD.
  --timing TIMING_ARG [TIMING_ARG ...]
                        Configure bit rate and bit timing. For example, use
                        `--timing f_clock=8_000_000 tseg1=5 tseg2=2 sjw=2
                        brp=2 nof_samples=1` for classical CAN or `--timing
                        f_clock=80_000_000 nom_tseg1=119 nom_tseg2=40
                        nom_sjw=40 nom_brp=1 data_tseg1=29 data_tseg2=10
                        data_sjw=10 data_brp=1` for CAN FD. Check the python-
                        can documentation to verify whether your CAN interface
                        supports the `timing` argument.
  --filter {<can_id>:<can_mask>,<can_id>~<can_mask>} [{<can_id>:<can_mask>,<can_id>~<can_mask>} ...]
                        R|Space separated CAN filters for the given CAN
                        interface: <can_id>:<can_mask> (matches when
                        <received_can_id> & mask == can_id & mask)
                        <can_id>~<can_mask> (matches when <received_can_id> &
                        mask != can_id & mask) Fx to show only frames with ID
                        0x100 to 0x103 and 0x200 to 0x20F: python -m
                        can.viewer --filter 100:7FC 200:7F0 Note that the ID
                        and mask are always interpreted as hex values
  --bus-kwargs BUS_KWARG [BUS_KWARG ...]
                        Pass keyword arguments down to the instantiation of
                        the bus class. For example, `-i vector -c 1 --bus-
                        kwargs app_name=MyCanApp serial=1234` is equivalent to
                        opening the bus with `can.Bus('vector', channel=1,
                        app_name='MyCanApp', serial=1234)`
```

--------------------------------

### Registering a custom message reader entry point

Source: https://python-can.readthedocs.io/en/stable/_sources/notifier.rst.txt

Configuration format for registering a custom message reader via entry points in setup.py or pyproject.toml.

```python
entry_points={
    'can.io.message_reader': [
       '.asc = my_package.io.asc:ASCReader'
   ]
}
```

--------------------------------

### Define CAN filter structure

Source: https://python-can.readthedocs.io/en/stable/_modules/can/bus.html

Example of the dictionary structure required for defining CAN message filters.

```python
[{"can_id": 0x11, "can_mask": 0x21, "extended": False}]
```

--------------------------------

### Get Logger for Suffix

Source: https://python-can.readthedocs.io/en/stable/_modules/can/io/logger.html

Retrieves the appropriate writer class for a given file suffix.

```python
def _get_logger_for_suffix(suffix: str) -> type[MessageWriter]:
    try:
        return MESSAGE_WRITERS[suffix]
    except KeyError:
        raise ValueError(
            f'No write support for unknown log format "{suffix}"'
        ) from None
```

--------------------------------

### Get Channel Information

Source: https://python-can.readthedocs.io/en/stable/_modules/can/interfaces/kvaser/canlib.html

Helper function to initialize buffers for retrieving channel information.

```python
def get_channel_info(channel):
    name = ctypes.create_string_buffer(80)
    serial = ctypes.c_uint64()
    number = ctypes.c_uint()
```

--------------------------------

### Initialize Bus with configuration context

Source: https://python-can.readthedocs.io/en/stable/_sources/configuration.rst.txt

Loads specific configuration sections from the config file when initializing a Bus.

```python
from can.interface import Bus

hs_bus = Bus(config_context='HS')
ms_bus = Bus(config_context='MS')
```

--------------------------------

### Get Serial Number

Source: https://python-can.readthedocs.io/en/stable/_modules/can/interfaces/robotell.html

Reads the device serial number from the interface configuration registers.

```python
def get_serial_number(self, timeout: Optional[int]) -> Optional[str]:
        """Get serial number of the slcan interface.

        :param timeout:
            seconds to wait for serial number or None to wait indefinitely
        :return:
            None on timeout or a str object.
        """

        sn1 = self._readconfig(self._CAN_READ_SERIAL1, timeout)
        if sn1 is None:
            return None
        sn2 = self._readconfig(self._CAN_READ_SERIAL2, timeout)
        if sn2 is None:
            return None

        serial = ""
        for idx in range(0, 8, 2):
            serial += f"{sn1[idx]:02X}{sn1[idx + 1]:02X}-"
        for idx in range(0, 4, 2):
            serial += f"{sn2[idx]:02X}{sn2[idx + 1]:02X}-"
        return serial[:-1]
```

--------------------------------

### Detect Available Configurations

Source: https://python-can.readthedocs.io/en/stable/_modules/can/interfaces/systec/ucanbus.html

Enumerates available hardware and returns a list of configurations for each channel.

```python
@staticmethod
def _detect_available_configs():
    configs = []
    try:
        # index, is_used, hw_info_ex, init_info
        for _, _, hw_info_ex, _ in Ucan.enumerate_hardware():
            configs.append(
                {
                    "interface": "systec",
                    "channel": Channel.CHANNEL_CH0,
                    "device_number": hw_info_ex.device_number,
                }
            )
            if Ucan.check_support_two_channel(hw_info_ex):
                configs.append(
                    {
                        "interface": "systec",
                        "channel": Channel.CHANNEL_CH1,
                        "device_number": hw_info_ex.device_number,
                    }
                )
    except Exception:
        log.warning("The SYSTEC ucan library has not been initialized.")
    return configs
```

--------------------------------

### Get Device Serial Number

Source: https://python-can.readthedocs.io/en/stable/_modules/can/interfaces/ics_neovi/neovi_bus.html

Decodes and returns the ICS device serial string.

```python
@staticmethod
    def get_serial_number(device):
        """Decode (if needed) and return the ICS device serial string

        :param device: ics device
        :return: ics device serial string
        :rtype: str
        """
        if int("0A0000", 36) < device.SerialNumber < int("ZZZZZZ", 36):
            return ics.base36enc(device.SerialNumber)
        else:
            return str(device.SerialNumber)
```

--------------------------------

### Display can.logconvert help information

Source: https://python-can.readthedocs.io/en/stable/scripts.html

Run this command to view the usage instructions, positional arguments, and available options for the log conversion utility.

```bash
$ python -m can.logconvert -h
usage: logconvert.py [-h] [-s FILE_SIZE] INFILE OUTFILE

Convert a log file from one format to another.

positional arguments:
  INFILE                Input filename. The type is dependent on the suffix,
                        see can.LogReader.
  OUTFILE               Output filename. The type is dependent on the suffix,
                        see can.Logger.

options:
  -h, --help            show this help message and exit
  -s, --file_size FILE_SIZE
                        Maximum file size in bytes. Rotate log file when size
                        threshold is reached.
```

--------------------------------

### Enable socketcan with systemd-networkd

Source: https://python-can.readthedocs.io/en/stable/interfaces/socketcand.html

Create a network configuration file to automatically start the can0 interface.

```bash
cat >/etc/systemd/network/80-can.network <<'EOT'
[Match]
Name=can0
[CAN]
BitRate=250K
RestartSec=100ms
EOT

```

```bash
sudo systemctl enable systemd-networkd
sudo systemctl start systemd-networkd

```

--------------------------------

### IXXATBus.__init__

Source: https://python-can.readthedocs.io/en/stable/_modules/can/interfaces/ixxat/canlib_vcinpl2.html

Initializes a new IXXATBus instance to communicate with the CAN hardware.

```APIDOC
## IXXATBus.__init__

### Description
Initializes the IXXAT CAN bus interface. Note that message filtering must be configured during initialization via the `can_filters` parameter, as `set_filters` is not supported.

### Parameters
- **channel** (int) - Required - The Channel id to create this bus with.
- **can_filters** (list) - Optional - List of filters to apply.
- **receive_own_messages** (int) - Optional - Enable self-reception of sent messages (default: False).
- **unique_hardware_id** (int) - Optional - Unique hardware ID to connect.
- **extended** (bool) - Optional - Enables the capability to use extended IDs (default: True).
- **rx_fifo_size** (int) - Optional - Receive fifo size (default: 1024).
- **tx_fifo_size** (int) - Optional - Transmit fifo size (default: 128).
- **bitrate** (int) - Optional - Channel bitrate in bit/s (default: 500000).
- **data_bitrate** (int) - Optional - Channel bitrate in bit/s for CAN-FD (default: 2000000).
- **sjw_abr** (int) - Optional - Bus timing value sample jump width (arbitration).
- **tseg1_abr** (int) - Optional - Bus timing value tseg1 (arbitration).
- **tseg2_abr** (int) - Optional - Bus timing value tseg2 (arbitration).
- **sjw_dbr** (int) - Optional - Bus timing value sample jump width (data).
- **tseg1_dbr** (int) - Optional - Bus timing value tseg1 (data).
- **tseg2_dbr** (int) - Optional - Bus timing value tseg2 (data).
- **ssp_dbr** (int) - Optional - Secondary sample point (data).
```
Tokens:
Raw