Struct AsyncSerialClient 

pub struct AsyncSerialClient<const ASCII: bool = false> { /* private fields */ }

Async Modbus serial client facade.

Supports both RTU and ASCII framing. All Modbus request methods (read_holding_registers, write_single_coil, etc.) are available directly on this type via Deref to AsyncClientCore.

Implementations

impl<const ASCII: bool> AsyncSerialClient<ASCII>

pub fn connect_with_transport<T>( transport: T, config: ModbusConfig, poll_interval: Duration, ) -> Result<AsyncSerialClient<ASCII>, AsyncError>

where T: AsyncTransport + Send + 'static,

👎Deprecated:

use AsyncSerialClient::new_with_transport(…) and then client.connect().await

Deprecated constructor alias.

pub fn new_with_transport<T>( transport: T, config: ModbusConfig, _poll_interval: Duration, ) -> Result<AsyncSerialClient<ASCII>, AsyncError>

where T: AsyncTransport + Send + 'static,

Creates an async serial client from a caller-provided transport without connecting.

This is the escape hatch for custom serial drivers and integration tests that inject a mock transport. The config must be ModbusConfig::Serial(_) or the call returns AsyncError::Mbus(MbusError::InvalidTransport). Call AsyncClientCore::connect on the returned client before sending requests.

Methods from Deref<Target = AsyncClientCore>

pub async fn connect(&self) -> Result<(), AsyncError>

Establishes the underlying transport connection.

Must be called once before issuing Modbus requests. Can be called again after a disconnect to reconnect.

pub async fn disconnect(&self) -> Result<(), AsyncError>

Disconnects the underlying transport.

Drains all in-flight and queued requests with MbusError::ConnectionClosed and closes the transport. After this call, connect can be called to reconnect.

This is an explicit, graceful disconnect. The background task continues running so the client can be reconnected later. Dropping the client handle entirely also stops the background task.

pub fn has_pending_requests(&self) -> bool

Returns true when there are requests in-flight awaiting a response.

This is a synchronous check — no .await required.

pub fn set_request_timeout(&self, timeout: Duration)

Sets a per-request deadline applied to every subsequent request call.

If a response is not received within timeout, the method returns AsyncError::Timeout. The in-flight entry remains in the background task until the transport delivers or errors; calling connect resets transport state.

The timeout can be updated at any time and takes effect on the next request. Call clear_request_timeout to remove it.

pub fn clear_request_timeout(&self)

Removes the per-request timeout set by set_request_timeout, allowing requests to wait indefinitely for a server response.

pub async fn read_multiple_coils( &self, unit_id: u8, address: u16, quantity: u16, ) -> Result<Coils, AsyncError>

Reads multiple coils (FC 01) from address with the given quantity.

Returns the coil values packed into a Coils object.

pub async fn write_single_coil( &self, unit_id: u8, address: u16, value: bool, ) -> Result<(u16, bool), AsyncError>

Writes a single coil (FC 05) at address with the given boolean value.

Returns (address, value) echoed back by the server.

pub async fn write_multiple_coils( &self, unit_id: u8, address: u16, coils: &Coils, ) -> Result<(u16, u16), AsyncError>

Writes multiple coils (FC 15) starting at address.

Returns (starting_address, quantity) echoed back by the server.

pub async fn read_holding_registers( &self, unit_id: u8, address: u16, quantity: u16, ) -> Result<Registers<mbus_core::::models::register::model::HoldingRegisters::{constant#0}>, AsyncError>

Reads holding registers (FC 03) from address with the given quantity.

Returns the register values as a HoldingRegisters object.

pub async fn read_input_registers( &self, unit_id: u8, address: u16, quantity: u16, ) -> Result<Registers<mbus_core::::models::register::model::InputRegisters::{constant#0}, Input>, AsyncError>

Reads input registers (FC 04) from address with the given quantity.

Returns the register values as an InputRegisters object.

pub async fn write_single_register( &self, unit_id: u8, address: u16, value: u16, ) -> Result<(u16, u16), AsyncError>

Writes a single holding register (FC 06) at address with value.

Returns (address, value) echoed back by the server.

pub async fn write_multiple_registers( &self, unit_id: u8, address: u16, values: &[u16], ) -> Result<(u16, u16), AsyncError>

Writes multiple holding registers (FC 16) starting at address.

Returns (starting_address, quantity) echoed back by the server.

pub async fn read_write_multiple_registers( &self, unit_id: u8, read_address: u16, read_quantity: u16, write_address: u16, write_values: &[u16], ) -> Result<Registers<mbus_core::::models::register::model::HoldingRegisters::{constant#0}>, AsyncError>

Performs a combined read/write on holding registers (FC 23).

Reads read_quantity registers starting at read_address and simultaneously writes write_values starting at write_address. Returns the read registers.

pub async fn mask_write_register( &self, unit_id: u8, address: u16, and_mask: u16, or_mask: u16, ) -> Result<(), AsyncError>

Applies an AND/OR bitmask to a holding register (FC 22).

The resulting register value is (current & and_mask) | (or_mask & !and_mask).

pub async fn read_discrete_inputs( &self, unit_id: u8, address: u16, quantity: u16, ) -> Result<DiscreteInputs, AsyncError>

Reads discrete inputs (FC 02) from address with the given quantity.

Returns the input states as a DiscreteInputs object.

pub async fn read_fifo_queue( &self, unit_id: u8, address: u16, ) -> Result<FifoQueue, AsyncError>

Reads the FIFO queue (FC 24) at address.

Returns up to 31 words from the FIFO queue as a FifoQueue object.

pub async fn read_file_record( &self, unit_id: u8, sub_request: &SubRequest, ) -> Result<Vec<SubRequestParams>, AsyncError>

Reads a file record (FC 20) described by sub_request.

Returns the sub-request response parameters for each requested record.

pub async fn write_file_record( &self, unit_id: u8, sub_request: &SubRequest, ) -> Result<(), AsyncError>

Writes a file record (FC 21) described by sub_request.

pub async fn read_device_identification( &self, unit_id: u8, read_device_id_code: ReadDeviceIdCode, object_id: ObjectId, ) -> Result<DeviceIdentificationResponse, AsyncError>

Reads device identification objects (FC 43 / MEI 14).

pub async fn encapsulated_interface_transport( &self, unit_id: u8, mei_type: EncapsulatedInterfaceType, data: &[u8], ) -> Result<(EncapsulatedInterfaceType, Vec<u8>), AsyncError>

Sends an encapsulated interface transport request (FC 43).

Returns the (mei_type, data) pair from the server response.

pub async fn read_exception_status(&self, unit_id: u8) -> Result<u8, AsyncError>

Reads the device exception status (FC 07).

pub async fn diagnostics( &self, unit_id: u8, sub_function: DiagnosticSubFunction, data: &[u16], ) -> Result<DiagnosticsDataResponse, AsyncError>

Sends a diagnostics request (FC 08).

Returns DiagnosticsDataResponse with echoed sub_function and data.

pub async fn get_comm_event_counter( &self, unit_id: u8, ) -> Result<(u16, u16), AsyncError>

Reads the communication event counter (FC 11).

Returns (status_word, event_count).

pub async fn get_comm_event_log( &self, unit_id: u8, ) -> Result<(u16, u16, u16, Vec<u8>), AsyncError>

Reads the communication event log (FC 12).

Returns (status, event_count, message_count, events).

pub async fn report_server_id(&self, unit_id: u8) -> Result<Vec<u8>, AsyncError>

Requests the server identifier data (FC 17).

Returns the raw server ID byte array.

Trait Implementations

impl<const ASCII: bool> Deref for AsyncSerialClient<ASCII>

type Target = AsyncClientCore

The resulting type after dereferencing.

fn deref(&self) -> &<AsyncSerialClient<ASCII> as Deref>::Target

Dereferences the value.