### Start RP1210 Read Thread and Process Messages

Source: https://context7.com/heavy-vehicle-networking-at-u-tulsa/pyrp1210/llms.txt

Initializes and starts a thread to read messages from an RP1210 device using a specified protocol (e.g., CAN). It then enters a loop to process received messages from a queue, decoding and printing CAN message details.

```python
read_thread = RP1210ReadMessageThread(
    parent=None,
    rx_queue=rx_queue,
    RP1210_ReadMessage=RP1210.ReadMessage,
    nClientID=client_id,
    protocol="CAN",
    filename="CANTraffic"
)
read_thread.setDaemon(True)
read_thread.start()

while True:
    if rx_queue.qsize() > 0:
        message = rx_queue.get()
        timestamp, vda_time, can_id, dlc, data = message
        hex_data = " ".join(f"{b:02X}" for b in data)
        print(f"ID: 0x{can_id:08X} DLC: {dlc} Data: {hex_data}")
```

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

### RP1210 Hardware Status and Version Info

Source: https://context7.com/heavy-vehicle-networking-at-u-tulsa/pyrp1210/llms.txt

This snippet demonstrates how to use `RP1210Class` to retrieve and display hardware status and version information from connected RP1210 devices. It includes examples for showing version dialogs and programmatically accessing status data.

```APIDOC
## Hardware Status and Version Information

### Description
The `RP1210Class` provides methods to query connected hardware status and display version information through PyQt5 dialogs. It also allows programmatic access to hardware status data.

### Method
Python Script

### Endpoint
N/A (Local Script Execution)

### Parameters
N/A

### Request Example
```python
from RP1210 import RP1210Class

RP1210 = RP1210Class("NULN2R32")
client_id = RP1210.get_client_id("J1939", 1, "250000")

# Display version dialog (shows DLL and API versions)
RP1210.display_version()

# Display detailed version from connected device
RP1210.display_detailed_version(client_id)

# Display hardware status dialog
RP1210.get_hardware_status(client_id)

# Get hardware status data programmatically
# Returns: (vda_connected, can_active, j1939_active, j1708_active, iso_active)
vda, can, j1939, j1708, iso = RP1210.get_hardware_status_data(client_id)
print(f"VDA Connected: {vda}")
print(f"CAN Traffic: {can}")
print(f"J1939 Traffic: {j1939}")
print(f"J1708 Traffic: {j1708}")
print(f"ISO15765 Traffic: {iso}")
```

### Response
N/A (Displays dialogs and prints status information to console)
```

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

### RP1210 Message Reading and Processing

Source: https://context7.com/heavy-vehicle-networking-at-u-tulsa/pyrp1210/llms.txt

This snippet demonstrates how to start a read thread to capture RP1210 messages and process them in a loop. It shows how to extract CAN message details like ID, DLC, and data.

```APIDOC
## RP1210 Message Reading and Processing

### Description
This section shows how to initialize and start a thread for reading messages from an RP1210 device and then process these messages in a loop. It specifically details the processing of CAN messages.

### Method
Python Script

### Endpoint
N/A (Local Script Execution)

### Parameters
N/A

### Request Example
```python
# Assuming RP1210 and rx_queue are already initialized
# from RP1210 import RP1210Class
# from queue import Queue

# RP1210 = RP1210Class("Your_DLL_Name.dll")
# client_id = RP1210.get_client_id("CAN", 1, "250000")
# rx_queue = Queue()
# read_thread = RP1210ReadMessageThread(
#     parent=None,
#     rx_queue=rx_queue,
#     RP1210_ReadMessage=RP1210.ReadMessage,
#     nClientID=client_id,
#     protocol="CAN",
#     filename="CANTraffic"
# )
# read_thread.setDaemon(True)
# read_thread.start()

# while True:
#     if not rx_queue.empty():
#         message = rx_queue.get()
#         timestamp, vda_time, can_id, dlc, data = message
#         hex_data = " ".join(f"{b:02X}" for b in data)
#         print(f"ID: 0x{can_id:08X} DLC: {dlc} Data: {hex_data}")
```

### Response
N/A (Prints to console)
```

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

### SelectRP1210 - GUI Device Selection

Source: https://context7.com/heavy-vehicle-networking-at-u-tulsa/pyrp1210/llms.txt

This snippet illustrates how to use the `SelectRP1210` class to present a graphical dialog for users to select RP1210 devices, protocols, and communication speeds. It then shows how to use these selections to initialize the RP1210 connection.

```APIDOC
## SelectRP1210 - GUI Device Selection Dialog

### Description
Provides a PyQt5 dialog for selecting RP1210 devices, protocols, and speeds by parsing the system's RP1210 INI configuration files. After selection, it allows for initializing the RP1210 connection with the chosen parameters.

### Method
Python Script using PyQt5

### Endpoint
N/A (Local GUI Application)

### Parameters
N/A

### Request Example
```python
from PyQt5.QtWidgets import QApplication
from RP1210Select import SelectRP1210
from RP1210 import RP1210Class
import sys

app = QApplication(sys.argv)

# Show the device selection dialog
selection = SelectRP1210("Vehicle Diagnostics Tool")
selection.show_dialog()

# Access selected values after dialog closes
if selection.dll_name:
    print(f"Selected DLL: {selection.dll_name}")
    print(f"Protocol: {selection.protocol}")
    print(f"Device ID: {selection.deviceID}")
    print(f"Speed: {selection.speed}")

    # Connect using selected parameters
    RP1210 = RP1210Class(selection.dll_name)
    client_id = RP1210.get_client_id(
        selection.protocol,
        selection.deviceID,
        selection.speed
    )
```

### Response
N/A (Prints selected values to console and establishes RP1210 connection.
```

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

### RP1210 Device Selection GUI with PyQt5

Source: https://context7.com/heavy-vehicle-networking-at-u-tulsa/pyrp1210/llms.txt

Provides a PyQt5 dialog for selecting RP1210 devices, protocols, and speeds. It parses system INI files to populate options and allows users to connect to a device using their selections.

```python
from PyQt5.QtWidgets import QApplication
from RP1210Select import SelectRP1210
from RP1210 import RP1210Class
import sys

app = QApplication(sys.argv)

# Show the device selection dialog
selection = SelectRP1210("Vehicle Diagnostics Tool")
selection.show_dialog()

# Access selected values after dialog closes
if selection.dll_name:
    print(f"Selected DLL: {selection.dll_name}")
    print(f"Protocol: {selection.protocol}")
    print(f"Device ID: {selection.deviceID}")
    print(f"Speed: {selection.speed}")

    # Connect using selected parameters
    RP1210 = RP1210Class(selection.dll_name)
    client_id = RP1210.get_client_id(
        selection.protocol,
        selection.deviceID,
        selection.speed
    )
```

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

### RP1210Class - Main Interface

Source: https://context7.com/heavy-vehicle-networking-at-u-tulsa/pyrp1210/llms.txt

Initialize the RP1210Class with a specific vendor's DLL and connect to a vehicle diagnostic adapter using a chosen protocol and speed.

```APIDOC
## RP1210Class - Main Interface for Vehicle Diagnostic Adapters

### Description
The `RP1210Class` is the primary interface for loading manufacturer DLLs and communicating with vehicle diagnostic adapters. It wraps all standard RP1210 functions including ClientConnect, ClientDisconnect, SendMessage, ReadMessage, and SendCommand.

### Method
`RP1210Class(dll_name: str)`

### Endpoint
N/A (This is a class constructor)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```python
from ctypes import *
from RP1210 import RP1210Class
from RP1210Functions import *

# Initialize with the DLL name (without .dll extension)
# Common DLLs: DGDPA5MA, NULN2R32, DLAUSB32, CIL7R32
RP1210 = RP1210Class("NULN2R32")

# Connect to a device with a specific protocol
# Protocols: "J1939", "CAN", "J1708", "J1850", "ISO15765"
# deviceID comes from the vendor's INI file (typically 1)
# speed is baud rate: "250000", "500000", "1000000" for CAN/J1939
client_id = RP1210.get_client_id(
    protocol="J1939",
    deviceID=1,
    speed="250000"
)

if client_id is not None:
    print(f"Connected with Client ID: {client_id}")
else:
    print("Connection failed. Check drivers and hardware.")
```

### Response
#### Success Response (200)
- **client_id** (int) - A unique identifier for the established client connection.

#### Response Example
```json
{
  "client_id": 1
}
```
```

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

### Connect to Vehicle Diagnostic Adapter with PyRP1210

Source: https://context7.com/heavy-vehicle-networking-at-u-tulsa/pyrp1210/llms.txt

Initializes the RP1210Class and connects to a vehicle diagnostic adapter using a specified protocol, device ID, and speed. Handles potential connection failures.

```python
from ctypes import *
from RP1210 import RP1210Class
from RP1210Functions import *

# Initialize with the DLL name (without .dll extension)
# Common DLLs: DGDPA5MA, NULN2R32, DLAUSB32, CIL7R32
RP1210 = RP1210Class("NULN2R32")

# Connect to a device with a specific protocol
# Protocols: "J1939", "CAN", "J1708", "J1850", "ISO15765"
# deviceID comes from the vendor's INI file (typically 1)
# speed is baud rate: "250000", "500000", "1000000" for CAN/J1939
client_id = RP1210.get_client_id(
    protocol="J1939",
    deviceID=1,
    speed="250000"
)

if client_id is not None:
    print(f"Connected with Client ID: {client_id}")
else:
    print("Connection failed. Check drivers and hardware.")
```

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

### Sending RP1210 Commands

Source: https://context7.com/heavy-vehicle-networking-at-u-tulsa/pyrp1210/llms.txt

Configure adapter and protocol settings using `send_command` with RP1210 command numbers.

```APIDOC
## Sending RP1210 Commands

### Description
The `send_command` method configures the adapter and protocol settings using RP1210 command numbers. Commands control filtering, echo mode, address claiming, and baud rate settings.

### Method
`RP1210Class.send_command(command_number: int, client_id: int, data: bytes)`

### Endpoint
N/A (This is a method of the `RP1210Class` instance)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **command_number** (int) - The specific RP1210 command to execute (e.g., `RP1210_Echo_Transmitted_Messages`).
- **client_id** (int) - The client ID obtained from `get_client_id`.
- **data** (bytes) - Command-specific data payload.

### Request Example
```python
from ctypes import c_short, byref, c_char
from RP1210 import RP1210Class
from RP1210Functions import *

RP1210 = RP1210Class("NULN2R32")
client_id = RP1210.get_client_id("J1939", 1, "250000")

# Enable echo mode to see transmitted messages
fpchClientCommand = (c_char * 8192)()
fpchClientCommand[0] = 1  # Echo mode ON
return_value = RP1210.send_command(
    RP1210_Echo_Transmitted_Messages,
    client_id,
    bytes([0x01])
)
print(f"Echo command result: {RP1210.get_error_code(return_value)}")

# Set all filters to pass (receive all messages)
return_value = RP1210.send_command(
    RP1210_Set_All_Filters_States_to_Pass,
    client_id,
    bytes()
)
print(f"Filter command result: {RP1210.get_error_code(return_value)}")

# J1939 Address Claim (required for sending on J1939 networks)
# Format: [SA, Identity(5 bytes), Function Instance, Function, Vehicle System, Arbitrary Addr]
claim_command = bytes([
    0xF9,  # Source Address (249 = diagnostic tool)
    0x01, 0x02, 0x03, 0x04,  # Identity field
    0x05,  # Function instance, ECU instance
    0x06,  # Function
    0x07,  # Vehicle System
    0x08,  # Arbitrary address capable, industry group
    0x02   # Return before completion
])
return_value = RP1210.send_command(
    RP1210_Protect_J1939_Address,
    client_id,
    claim_command
)
```

### Response
#### Success Response (200)
- **return_value** (int) - RP1210 status code indicating success or failure of the operation.

#### Response Example
```json
{
  "return_value": 0
}
```
```

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

### Configure RP1210 Adapter Settings with PyRP1210

Source: https://context7.com/heavy-vehicle-networking-at-u-tulsa/pyrp1210/llms.txt

Sends RP1210 commands to configure adapter and protocol settings, such as enabling echo mode, setting filter states, and performing J1939 address claiming.

```python
from ctypes import c_short, byref, c_char
from RP1210 import RP1210Class
from RP1210Functions import *

RP1210 = RP1210Class("NULN2R32")
client_id = RP1210.get_client_id("J1939", 1, "250000")

# Enable echo mode to see transmitted messages
fpchClientCommand = (c_char * 8192)()
fpchClientCommand[0] = 1  # Echo mode ON
return_value = RP1210.send_command(
    RP1210_Echo_Transmitted_Messages,
    client_id,
    bytes([0x01])
)
print(f"Echo command result: {RP1210.get_error_code(return_value)}")

# Set all filters to pass (receive all messages)
return_value = RP1210.send_command(
    RP1210_Set_All_Filters_States_to_Pass,
    client_id,
    bytes()
)
print(f"Filter command result: {RP1210.get_error_code(return_value)}")

# J1939 Address Claim (required for sending on J1939 networks)
# Format: [SA, Identity(5 bytes), Function Instance, Function, Vehicle System, Arbitrary Addr]
claim_command = bytes([
    0xF9,  # Source Address (249 = diagnostic tool)
    0x01, 0x02, 0x03, 0x04,  # Identity field
    0x05,  # Function instance, ECU instance
    0x06,  # Function
    0x07,  # Vehicle System
    0x08,  # Arbitrary address capable, industry group
    0x02   # Return before completion
])
return_value = RP1210.send_command(
    RP1210_Protect_J1939_Address,
    client_id,
    claim_command
)
```

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

### Query RP1210 Hardware Status and Version Info

Source: https://context7.com/heavy-vehicle-networking-at-u-tulsa/pyrp1210/llms.txt

Utilizes the `RP1210Class` to query connected hardware status and display version information. It provides methods to show version dialogs and retrieve hardware status data programmatically.

```python
from RP1210 import RP1210Class

RP1210 = RP1210Class("NULN2R32")
client_id = RP1210.get_client_id("J1939", 1, "250000")

# Display version dialog (shows DLL and API versions)
RP1210.display_version()

# Display detailed version from connected device
RP1210.display_detailed_version(client_id)

# Display hardware status dialog
RP1210.get_hardware_status(client_id)

# Get hardware status data programmatically
# Returns: (vda_connected, can_active, j1939_active, j1708_active, iso_active)
vda, can, j1939, j1708, iso = RP1210.get_hardware_status_data(client_id)
print(f"VDA Connected: {vda}")
print(f"CAN Traffic: {can}")
print(f"J1939 Traffic: {j1939}")
print(f"J1708 Traffic: {j1708}")
print(f"ISO15765 Traffic: {iso}")
```

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

### RP1210 Command Constants

Source: https://context7.com/heavy-vehicle-networking-at-u-tulsa/pyrp1210/llms.txt

This snippet lists and explains various RP1210 command constants available in `RP1210Functions`. These constants are used with the `send_command` function to control device behavior, filtering, and protocol settings.

```APIDOC
## RP1210 Command Constants

### Description
The library defines standard RP1210 command constants for use with the `send_command` function. These constants control device behavior, filtering, and protocol-specific settings.

### Method
Python Script

### Endpoint
N/A (Constants for local use)

### Parameters
N/A

### Request Example
```python
from RP1210Functions import *

# Device control commands
# RP1210_Reset_Device                       # 0 - Reset the adapter
# RP1210_Set_All_Filters_States_to_Pass     # 3 - Receive all messages
# RP1210_Set_All_Filters_States_to_Discard  # 17 - Block all messages
# RP1210_Echo_Transmitted_Messages          # 16 - Echo TX messages back

# Protocol-specific filtering
# RP1210_Set_Message_Filtering_For_J1939    # 4
# RP1210_Set_Message_Filtering_For_CAN      # 5
# RP1210_Set_Message_Filtering_For_J1708    # 7
# RP1210_Set_Message_Filtering_For_ISO15765 # 9

# J1939 specific
# RP1210_Protect_J1939_Address              # 19 - Claim address
# RP1210_Release_J1939_Address              # 31 - Release address
# RP1210_Set_J1939_Interpacket_Time         # 27 - Transport timing
# RP1210_Set_J1939_Baud                     # 37 - Set baud rate

# Baud rate constants
# BLOCKING_IO = 1      # Block until message received
# NON_BLOCKING_IO = 0  # Return immediately
# RP1210_BAUD_250k = 0x05
# RP1210_BAUD_500k = 0x06

# Example usage (assuming RP1210 and client_id are initialized):
# RP1210.send_command(client_id, RP1210_Set_All_Filters_States_to_Pass)
```

### Response
N/A (Constants are for use within the library.
```

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

### RP1210 Utility Functions

Source: https://context7.com/heavy-vehicle-networking-at-u-tulsa/pyrp1210/llms.txt

This snippet showcases utility functions from `RP1210Functions` for data conversion (bytes to hex string and vice versa) and error code lookup. It demonstrates practical usage for data manipulation and error handling.

```APIDOC
## Utility Functions for Data Conversion

### Description
The `RP1210Functions` module provides helper functions for converting between bytes and hex strings, along with RP1210 constants and error code definitions.

### Method
Python Script

### Endpoint
N/A (Local Script Execution)

### Parameters
N/A

### Request Example
```python
from RP1210Functions import (
    bytes_to_hex_string,
    hex_string_to_bytes,
    get_printable_chars,
    RP1210Errors
)

# Convert bytes to formatted hex string
data = b'\x18\xFE\xF1\x00\xFF\xFF\xFF\xFF'
hex_str = bytes_to_hex_string(data)
print(hex_str)  # Output: "18 FE F1 00 FF FF FF FF"

# Convert hex string back to bytes
restored = hex_string_to_bytes("18 FE F1 00 FF FF FF FF")
print(restored)  # Output: b'\x18\xfe\xf1\x00\xff\xff\xff\xff'

# Extract printable ASCII characters from data
printable = get_printable_chars(b'Engine\x00\xff\xfeModel')
print(printable)  # Output: "EngineModel"

# Look up error codes
error_code = 142
print(f"Error {error_code}: {RP1210Errors.get(error_code, 'Unknown')}")
# Output: "Error 142: ERR HARDWARE NOT RESPONDING"
```

### Response
N/A (Prints converted data and error messages to console)
```

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

### Threaded Message Reception with PyRP1210

Source: https://context7.com/heavy-vehicle-networking-at-u-tulsa/pyrp1210/llms.txt

Sets up a background thread for non-blocking reception of vehicle network messages using RP1210ReadMessageThread. Received messages are placed into a queue for processing.

```python
import queue
from RP1210 import RP1210Class, RP1210ReadMessageThread
from RP1210Functions import *

RP1210 = RP1210Class("NULN2R32")
client_id = RP1210.get_client_id("CAN", 1, "250000")

# Create a queue to receive messages
rx_queue = queue.Queue(100000)

```

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

### RP1210 Command Constants for Device Control

Source: https://context7.com/heavy-vehicle-networking-at-u-tulsa/pyrp1210/llms.txt

Defines constants for various RP1210 commands used with the `send_command` function. These constants control device behavior, set filtering states, manage J1939 addresses, and define baud rates.

```python
from RP1210Functions import *

# Device control commands
RP1210_Reset_Device                       # 0 - Reset the adapter
RP1210_Set_All_Filters_States_to_Pass     # 3 - Receive all messages
RP1210_Set_All_Filters_States_to_Discard  # 17 - Block all messages
RP1210_Echo_Transmitted_Messages          # 16 - Echo TX messages back

# Protocol-specific filtering
RP1210_Set_Message_Filtering_For_J1939    # 4
RP1210_Set_Message_Filtering_For_CAN      # 5
RP1210_Set_Message_Filtering_For_J1708    # 7
RP1210_Set_Message_Filtering_For_ISO15765 # 9

# J1939 specific
RP1210_Protect_J1939_Address              # 19 - Claim address
RP1210_Release_J1939_Address              # 31 - Release address
RP1210_Set_J1939_Interpacket_Time         # 27 - Transport timing
RP1210_Set_J1939_Baud                     # 37 - Set baud rate

# Baud rate constants
BLOCKING_IO = 1      # Block until message received
NON_BLOCKING_IO = 0  # Return immediately
RP1210_BAUD_250k = 0x05
RP1210_BAUD_500k = 0x06
```

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

### RP1210 Utility Functions for Data Conversion

Source: https://context7.com/heavy-vehicle-networking-at-u-tulsa/pyrp1210/llms.txt

Offers helper functions for converting between byte arrays and hexadecimal strings, extracting printable characters, and looking up RP1210 error codes. These utilities are essential for data manipulation and error handling.

```python
from RP1210Functions import (
    bytes_to_hex_string,
    hex_string_to_bytes,
    get_printable_chars,
    RP1210Errors
)

# Convert bytes to formatted hex string
data = b'\x18\xFE\xF1\x00\xFF\xFF\xFF\xFF'
hex_str = bytes_to_hex_string(data)
print(hex_str)  # Output: "18 FE F1 00 FF FF FF FF"

# Convert hex string back to bytes
restored = hex_string_to_bytes("18 FE F1 00 FF FF FF FF")
print(restored)  # Output: b'\x18\xfe\xf1\x00\xff\xff\xff\xff'

# Extract printable ASCII characters from data
printable = get_printable_chars(b'Engine\x00\xff\xfeModel')
print(printable)  # Output: "EngineModel"

# Look up error codes
error_code = 142
print(f"Error {error_code}: {RP1210Errors.get(error_code, 'Unknown')}")
# Output: "Error 142: ERR HARDWARE NOT RESPONDING"
```

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

### Send J1939 Message with PyRP1210

Source: https://context7.com/heavy-vehicle-networking-at-u-tulsa/pyrp1210/llms.txt

Transmits a J1939 formatted message to the connected vehicle network. The message includes PGN, priority, source address, destination address, and data payload.

```python
from ctypes import c_short, byref
from RP1210 import RP1210Class
from RP1210Functions import *

RP1210 = RP1210Class("NULN2R32")
client_id = RP1210.get_client_id("J1939", 1, "250000")

# J1939 message format: [PGN_LSB, PGN_MID, PGN_MSB, Priority, SA, DA, Data...]
# Example: Request PGN 65259 (Component ID) from address 0
pgn = 65259
message_bytes = bytes([
    pgn & 0xFF,           # PGN LSB
    (pgn >> 8) & 0xFF,    # PGN Middle byte
    (pgn >> 16) & 0xFF,   # PGN MSB
    6,                     # Priority (6 is typical for requests)
    0xF9,                  # Source Address (249 = Off-board diagnostic tool)
    0x00,                  # Destination Address
])

RP1210.send_message(client_id, message_bytes)
```

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

### Sending Messages on Vehicle Networks

Source: https://context7.com/heavy-vehicle-networking-at-u-tulsa/pyrp1210/llms.txt

Transmit data bytes to the connected vehicle network using the `send_message` method. Message formatting is protocol-dependent.

```APIDOC
## Sending Messages on Vehicle Networks

### Description
The `send_message` method transmits data bytes to the connected vehicle network. Message format varies by protocol - J1939 requires PGN and address information while CAN uses standard/extended identifiers.

### Method
`RP1210Class.send_message(client_id: int, message: bytes)`

### Endpoint
N/A (This is a method of the `RP1210Class` instance)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **client_id** (int) - The client ID obtained from `get_client_id`.
- **message** (bytes) - The message payload to send. Format depends on the protocol.

### Request Example
```python
from ctypes import c_short, byref
from RP1210 import RP1210Class
from RP1210Functions import *

RP1210 = RP1210Class("NULN2R32")
client_id = RP1210.get_client_id("J1939", 1, "250000")

# J1939 message format: [PGN_LSB, PGN_MID, PGN_MSB, Priority, SA, DA, Data...]
# Example: Request PGN 65259 (Component ID) from address 0
pgn = 65259
message_bytes = bytes([
    pgn & 0xFF,           # PGN LSB
    (pgn >> 8) & 0xFF,    # PGN Middle byte
    (pgn >> 16) & 0xFF,   # PGN MSB
    6,                     # Priority (6 is typical for requests)
    0xF9,                  # Source Address (249 = Off-board diagnostic tool)
    0x00,                  # Destination Address
])

RP1210.send_message(client_id, message_bytes)
```

### Response
#### Success Response (200)
- **return_value** (int) - RP1210 status code indicating success or failure of the operation.

#### Response Example
```json
{
  "return_value": 0 
}
```
```

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

### RP1210ReadMessageThread - Threaded Message Reception

Source: https://context7.com/heavy-vehicle-networking-at-u-tulsa/pyrp1210/llms.txt

Utilize `RP1210ReadMessageThread` for non-blocking message reception in a background thread, queuing messages for processing.

```APIDOC
## RP1210ReadMessageThread - Threaded Message Reception

### Description
The `RP1210ReadMessageThread` class provides non-blocking message reception by running in a background thread. Messages are placed in a queue for processing by the main application.

### Method
`RP1210ReadMessageThread(rx_queue: queue.Queue, client_id: int, rp1210_instance: RP1210Class)`

### Endpoint
N/A (This is a class constructor)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **rx_queue** (queue.Queue) - A Python queue object to store received messages.
- **client_id** (int) - The client ID obtained from `get_client_id`.
- **rp1210_instance** (RP1210Class) - An instance of the `RP1210Class`.

### Request Example
```python
import queue
from RP1210 import RP1210Class, RP1210ReadMessageThread
from RP1210Functions import *

RP1210 = RP1210Class("NULN2R32")
client_id = RP1210.get_client_id("CAN", 1, "250000")

# Create a queue to receive messages
rx_queue = queue.Queue(100000)

# Create and start the message reading thread
read_thread = RP1210ReadMessageThread(rx_queue, client_id, RP1210)
read_thread.start()

# Later, to process messages:
# while True:
#     try:
#         message = rx_queue.get_nowait()
#         # Process the message
#     except queue.Empty:
#         # No messages available
#         break

# To stop the thread:
# read_thread.stop()
```

### Response
#### Success Response (200)
This method does not return a direct response. Messages are placed into the provided `rx_queue`.

#### Response Example
```json
{
  "status": "Message received and queued"
}
```
```

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