### Install python-can-isotp

Source: https://github.com/pylessard/python-can-isotp/blob/v2.x/README.rst

Install the package using pip. Requires Python 3.7+.

```bash
pip install can-isotp
```

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

### Normal Addressing Example

Source: https://github.com/pylessard/python-can-isotp/blob/v2.x/doc/source/isotp/addressing.md

Demonstrates reception of a 10-byte payload using normal addressing. Requires matching rxid for reception and txid for flow control.

```default
0x123    [8]   10 0A 00 01 02 03 04    // First frame
0x456    [4]   30 00 08 00             // Flow control
0x123    [6]   21 05 06 07 08 09       // Consecutive frame
```

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

### ISOTP Message Reception Example

Source: https://github.com/pylessard/python-can-isotp/blob/v2.x/doc/source/isotp/addressing.md

Illustrates the frame sequence for receiving a 10-byte payload using ISOTP with specific IDs and extensions.

```default
// Reception of a 10 bytes payload
0x123        [8]   99 10 0A 00 01 02 03 04   // First frame
0x18DAAA55   [4]   30 00 08 00               // Flow control
0x123        [7]   99 21 05 06 07 08 09      // Consecutive frame
```

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

### Mixed Addressing (11-bits) Example

Source: https://github.com/pylessard/python-can-isotp/blob/v2.x/doc/source/isotp/addressing.md

Demonstrates reception of a 10-byte payload using mixed addressing with 11-bit CAN identifiers. The address extension is used as the payload prefix. Requires matching rxid and the address extension in the payload's first byte for reception.

```default
0x123    [8]   99 10 0A 00 01 02 03    // First frame
0x456    [5]   99 30 00 08 00          // Flow control
0x123    [8]   99 21 04 05 06 07 08 09 // consecutive frame
```

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

### Extended Addressing Example

Source: https://github.com/pylessard/python-can-isotp/blob/v2.x/doc/source/isotp/addressing.md

Shows reception of a 10-byte payload with extended addressing. An additional source address is prepended to the payload. Requires matching rxid and the source address in the payload's first byte for reception.

```default
0x123    [8]   55 10 0A 00 01 02 03    // First frame
0x456    [5]   AA 30 00 08 00          // Flow control
0x123    [8]   55 21 04 05 06 07 08 09 // consecutive frame
```

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

### Normal Fixed Addressing Example

Source: https://github.com/pylessard/python-can-isotp/blob/v2.x/doc/source/isotp/addressing.md

Illustrates reception of a 10-byte payload using normal fixed addressing. The target and source addresses are encoded within the CAN arbitration ID. Requires extended 29-bit CAN identifiers.

```default
0x18DA55AA    [8]   10 0A 00 01 02 03 04  // First frame
0x18DAAA55    [4]   30 00 08 00           // Flow control
0x18DA55AA    [6]   21 05 06 07 08 09     // Consecutive frame
```

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

### Mixed Addressing (29-bits) Example

Source: https://github.com/pylessard/python-can-isotp/blob/v2.x/doc/source/isotp/addressing.md

Illustrates reception of a 10-byte payload using mixed addressing with 29-bit CAN identifiers. The CAN ID encodes target and source addresses, and the payload prefix is the address extension. Requires matching target/source addresses in the ID and the address extension in the payload's first byte for reception.

```default
0x18CE55AA    [8]   99 10 0A 00 01 02 03    // First frame
0x18CEAA55    [5]   99 30 00 08 00          // Flow control
0x18CE55AA    [8]   99 21 04 05 06 07 08 09 // consecutive frame
```

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

### Configure and Use Raw IsoTP Sockets (Linux)

Source: https://github.com/pylessard/python-can-isotp/blob/v2.x/doc/source/isotp/socket.md

Demonstrates how to configure and use raw ISO-TP sockets on Linux using the standard `socket` module. This requires manual configuration of socket options and binding with specific CAN interface and IDs.

```python
SOL_CAN_ISOTP = 106 # These constants exist in the linux source code, not in Python
CAN_ISOTP_RECV_FC = 2
# Many more exists.

import socket
import struct

s = socket.socket(socket.AF_CAN, socket.SOCK_DGRAM, socket.CAN_ISOTP)
s2 = socket.socket(socket.AF_CAN, socket.SOCK_DGRAM, socket.CAN_ISOTP)
# Configuring the sockets with ugly struct.pack() that requires knowledge of the driver
s.setsockopt(SOL_CAN_ISOTP, CAN_ISOTP_RECV_FC, struct.pack("=BBB", 0x10, 3,0)) #bs, stmin, wftmax
#s.setsockopt(SOL_CAN_ISOTP, CAN_ISOTP_OPTS, struct.pack(...))
#s.setsockopt(SOL_CAN_ISOTP, CAN_ISOTP_LL_OPTS, struct.pack(...))

s.bind(("vcan0", 0x123, 0x456)) #rxid, txid with confusing order.
s2.bind(("vcan0", 0x456, 0x123)) #rxid, txid
s2.send(b"Hello, this is a long payload sent in small chunks of 8 bytes.")
print(s.recv(4095))
```

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

### Configure and Use IsoTP Sockets with python-can-isotp

Source: https://github.com/pylessard/python-can-isotp/blob/v2.x/doc/source/isotp/socket.md

Shows how to configure and use ISO-TP sockets with the `isotp.socket` wrapper. This provides a more Pythonic interface for setting flow control options and binding sockets.

```python
import isotp

s = isotp.socket()
s2 = isotp.socket()
# Configuring the sockets.
s.set_fc_opts(stmin=5, bs=10)
#s.set_general_opts(...)
#s.set_ll_opts(...)

s.bind("vcan0", isotp.Address(rxid=0x123, txid=0x456))
s2.bind("vcan0", isotp.Address(rxid=0x456, txid=0x123))
s2.send(b"Hello, this is a long payload sent in small chunks of 8 bytes.")
print(s.recv())
```

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

### IsoTP Addressing Modes

Source: https://github.com/pylessard/python-can-isotp/blob/v2.x/doc/source/isotp/examples.md

Demonstrates the creation of IsoTP addresses for various addressing modes, including Normal, Extended, and Mixed modes with both 11-bit and 29-bit arbitration IDs. Also shows how to configure asymmetric addresses.

```python
import isotp

isotp.Address(isotp.AddressingMode.Normal_11bits, rxid=0x123, txid=0x456)
isotp.Address(isotp.AddressingMode.Normal_29bits, rxid=0x123456, txid=0x789ABC)
isotp.Address(isotp.AddressingMode.NormalFixed_29bits, source_address=0x11, target_address=0x22)
isotp.Address(isotp.AddressingMode.Extended_11bits, rxid=0x123, txid=0x456, source_address=0x55, target_address=0xAA)
isotp.Address(isotp.AddressingMode.Extended_29bits, rxid=0x123456, txid=0x789ABC, source_address=0x55, target_address=0xAA)
isotp.Address(isotp.AddressingMode.Mixed_11bits, rxid=0x123, txid=0x456, address_extension=0x99)
isotp.Address(isotp.AddressingMode.Mixed_29bits, source_address=0x11, target_address=0x22, address_extension=0x99)

# Asymmetric Addresses
isotp.AsymmetricAddress(
    tx_addr=isotp.Address(isotp.AddressingMode.NormalFixed_29bits, target_address=ta, source_address=sa, tx_only=True),
    rx_addr=isotp.Address(isotp.AddressingMode.Mixed_11bits, rxid=0x123, address_extension=0x99, rx_only=True)   # txid is not required
)
```

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

### Asymmetric Address Configuration

Source: https://github.com/pylessard/python-can-isotp/blob/v2.x/doc/source/isotp/addressing.md

Configure an asymmetric address for sending and receiving with different address schemes. Both tx_addr and rx_addr must be partial addresses.

```python
import isotp
address = isotp.AsymmetricAddress(
    tx_addr=isotp.Address(isotp.AddressingMode.NormalFixed_29bits, target_address=ta, source_address=sa, tx_only=True),
    rx_addr=isotp.Address(isotp.AddressingMode.Mixed_11bits, rxid=0x123, address_extension=0x99, rx_only=True)   # txid is not required
)
```

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

### Define Partial RXFN and TXFN with Hardware Handle

Source: https://github.com/pylessard/python-can-isotp/blob/v2.x/doc/source/isotp/examples.md

Use functools.partial to pass a hardware handle to custom receive (rxfn) and transmit (txfn) functions when your hardware API requires it. This ensures the handle is available within the functions called by the TransportLayer.

```python
import isotp
import functools
from typing import Optional

# hardware_handle is passed through partial func
def my_rxfn(hardware_handle, timeout:float) -> Optional[isotp.CanMesage]:
    msg = my_hardware_api_recv(timeout) # Blocking read are encouraged for better timing.
    if msg is None:
        return None # Return None if no message available
    return isotp.CanMesage(arbitration_id=msg.get_id(), data=msg.get_data(), dlc=msg.get_dlc(), extended_id=msg.is_extended_id())

# hardware_handle is passed through partial func
def my_txfn(hardware_handle, isotp_msg:isotp.CanMesage):
    # all set_something functions and my_hardware_something are fictive.
    msg = my_hardware_api_make_msg()
    msg.set_id(isotp_msg.arbitration_id)
    msg.set_data(isotp_msg.data)
    msg.set_dlc(isotp_msg.dlc)
    msg.set_extended_id(isotp_msg.is_extended_id)
    my_hardware_api_send(hardware_handle, msg)

hardware_handle = my_hardware_open()    # Fictive handle mechanism
addr = isotp.Address(isotp.AddressingMode.Normal_29bits, txid=0x123456, rxid = 0x123457)

# This is where the magic happens
partial_rxfn = functools.partial(my_rxfn, hardware_handle)
partial_txfn = functools.partial(my_txfn, hardware_handle)
layer = isotp.TransportLayer(rxfn=partial_rxfn, txfn=partial_txfn, address=addr)

layer.start()
# ... rest of programs
# ...
layer.stop()
my_hardware_close()
```

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

### Functional Addressing (Broadcast) with TransportLayer

Source: https://github.com/pylessard/python-can-isotp/blob/v2.x/doc/source/isotp/examples.md

Send a payload using functional addressing (broadcast) with the `TransportLayer`. The payload must fit a Single Frame, as functional addressing only works with Single Frames. Requires a `rxfn` and `txfn` to be defined.

```python
import isotp

addr = isotp.Address(isotp.AddressingMode.Normal_11bits, rxid=0x123, txid=0x456)
layer = isotp.TransportLayer(rxfn=..., txfn=..., address=addr)
try:
    layer.start()
    layer.send(b'Hello', isotp.TargetAddressType.Functional) # Payload must fit a Single Frame. Functional addressing only works with Single Frames
    while layer.transmitting():
        time.sleep(0.005)
finally:
    layer.stop()
    bus.shutdown()
```

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

### Custom Transport Layer with User-Defined Functions

Source: https://github.com/pylessard/python-can-isotp/blob/v2.x/doc/source/isotp/examples.md

Configure a `TransportLayer` to interact with a hardware different from python-can by defining custom receive (`rxfn`) and transmit (`txfn`) functions. These functions should abstract the hardware-specific API calls for sending and receiving CAN messages.

```python
import isotp
from typing import Optional

def my_rxfn(timeout:float) -> Optional[isotp.CanMesage]:
    # All my_hardware_something and get_something() function are fictive of course.
    msg = my_hardware_api_recv(timeout) # Blocking read are encouraged for better timing.
    if msg is None:
        return None # Return None if no message available
    return isotp.CanMesage(arbitration_id=msg.get_id(), data=msg.get_data(), dlc=msg.get_dlc(), extended_id=msg.is_extended_id())


def my_txfn(isotp_msg:isotp.CanMesage):
    # all set_something functions and my_hardware_something are fictive.
    msg = my_hardware_api_make_msg()
    msg.set_id(isotp_msg.arbitration_id)
    msg.set_data(isotp_msg.data)
    msg.set_dlc(isotp_msg.dlc)
    msg.set_extended_id(isotp_msg.is_extended_id)
    my_hardware_api_send(msg)

addr = isotp.Address(isotp.AddressingMode.Normal_29bits, txid=0x123456, rxid = 0x123457)
layer = isotp.TransportLayer(rxfn=my_rxfn, txfn=my_txfn, address=addr)
layer.start()

# ... rest of programs
# ...

layer.stop()
my_hardware_close()
```

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

### Non-blocking Transmission with python-can

Source: https://github.com/pylessard/python-can-isotp/blob/v2.x/doc/source/isotp/examples.md

Transmit a payload using a non-blocking send() method. This method does not raise exceptions on failure; use the provided error handler to monitor for issues. Ensure the `blocking_send` parameter is not set or is `False`.

```python
# In this example, we transmit a payload sing a non-blocking send()
import isotp
import logging
import time

from can.interfaces.socketcan import SocketcanBus

def my_error_handler(error):
    # Called from a different thread, needs to be thread safe
    logging.warning('IsoTp error happened : %s - %s' % (error.__class__.__name__, str(error)))

bus = SocketcanBus(channel='vcan0')
addr = isotp.Address(isotp.AddressingMode.Normal_11bits, rxid=0x123, txid=0x456)
stack = isotp.CanStack(bus, address=addr, error_handler=my_error_handler)

try:
    stack.start()

    stack.send(b'Hello, this is a long payload sent in small chunks')    # Non-blocking send, does not raise exception.
    while stack.transmitting():
        time.sleep(0.005)

    print("Payload transmission done.") # May have failed, use the error_handler to know
finally:
    stack.stop()
    bus.shutdown()
```

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

### Blocking Transmission with python-can

Source: https://github.com/pylessard/python-can-isotp/blob/v2.x/doc/source/isotp/examples.md

Transmit a payload using a blocking send() method. This method raises an exception on any kind of failure, including timeouts. Ensure the `blocking_send` parameter is set to `True` in the `CanStack` parameters.

```python
# In this example, we transmit a payload using a blocking send()
import isotp
import logging

from can.interfaces.socketcan import SocketcanBus

def my_error_handler(error):
    # Called from a different thread, needs to be thread safe
    logging.warning('IsoTp error happened : %s - %s' % (error.__class__.__name__, str(error)))

bus = SocketcanBus(channel='vcan0')
addr = isotp.Address(isotp.AddressingMode.Normal_11bits, rxid=0x123, txid=0x456)
params = {
    'blocking_send' : True
}
stack = isotp.CanStack(bus, address=addr, error_handler=my_error_handler, params=params)

try:
    stack.start()
    stack.send(b'Hello, this is a long payload sent in small chunks', timeout=2)    # Blocking send, raise on error
    print("Payload transmission successfully completed.")     # Success is guaranteed because send() can raise
except isotp.BlockingSendFailure:   # Happens for any kind of failure, including timeouts
    print("Send failed")
finally:
    stack.stop()
    bus.shutdown()
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.