Tokio Modbus

https://docs.rs/tokio-modbus/0.16.3/tokio_modbus/
Admin
A pure Rust Modbus library based on tokio, offering asynchronous and synchronous client and server...
Tokens:26,637
Snippets:159
Trust Score:9.7
Update:1 year ago
Show doc for...
Tokens:
Raw
### Install tokio-modbus with TCP server feature

Source: https://docs.rs/tokio-modbus/0.16.3/tokio_modbus/index

Illustrates the Cargo.toml setup for activating the asynchronous TCP server feature of tokio-modbus, excluding default features.

```toml
[dependencies]
tokio-modbus = { version = "*", default-features = false, features = ["tcp-server"] }
```

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

### tokio-modbus Crate Overview

Source: https://docs.rs/tokio-modbus/0.16.3/tokio_modbus/index

Provides an overview of the tokio-modbus crate, its purpose, features, installation, and usage examples.

```APIDOC
## Crate tokio_modbus

A pure Rust Modbus library based on tokio.

Modbus is based on a _master/slave_ communication pattern. To avoid confusion with the Tokio terminology the _master_ is called _client_ and the _slave_ is called _server_ in this library.

### Features
  * Pure Rust library
  * Modbus TCP or RTU at your choice
  * Both `async` (non-blocking, default) and `sync` (blocking, optional)
  * Client API
  * Server implementations 
    * for _out-of-the-box_ usage or
    * as a starting point for a customized implementation
  * Open source (MIT/Apache-2.0)

### Installation
Add this to your `Cargo.toml`:
```toml
[dependencies]
tokio-modbus = "*"
```

#### Cargo Features
  * `"rtu"`: Asynchronous RTU client (default)
  * `"tcp"`: Asynchronous TCP client (default)
  * `"rtu-sync`: Synchronous RTU client
  * `"tcp-sync`: Synchronous TCP client
  * `"rtu-server"`: (Asynchronous) RTU server
  * `"tcp-server"`: (Asynchronous) TCP server
  * `"rtu-over-tcp-server"`: (Asynchronous) RTU over TCP server

##### Examples
If you only need an asynchronous TCP client add the following line to your Cargo.toml file:
```toml
[dependencies]
tokio-modbus = { version = "*", default-features = false, features = ["tcp"] }
```

For an asynchronous RTU client:
```toml
[dependencies]
tokio-modbus = { version = "*", default-features = false, features = ["rtu"] }
```

For an RTU server:
```toml
[dependencies]
tokio-modbus = { version = "*", default-features = false, features = ["rtu-server"] }
```

For a TCP server:
```toml
[dependencies]
tokio-modbus = { version = "*", default-features = false, features = ["tcp-server"] }
```

### Examples
Various examples for Modbus RTU and TCP using either the asynchronous or synchronous API can be found in the examples folder.

### Testing
The workspace contains documentation, tests, and examples for all available features.
```bash
cargo test --workspace
cargo test --workspace --all-features
```

### Protocol-Specification
  * Modbus Application Protocol Specification v1.1b3 (PDF)
  * Modbus over serial line specification and implementation guide v1.02 (PDF)
  * Modbus Messaging on TCP/IP Implementation Guide v1.0b (PDF)

### License
Copyright (c) 2017-2024 slowtec GmbH
MIT/Apache-2.0
```

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

### Create Tokio Modbus TCP Server

Source: https://docs.rs/tokio-modbus/0.16.3/tokio_modbus/server/tcp/struct

Instantiates a new Modbus TCP server by attaching it to a given TCP listener. This is the entry point for starting a Modbus server instance.

```rust
pub fn new(listener: TcpListener) -> Self
```

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

### Start Modbus RTU over TCP Server (Rust)

Source: https://docs.rs/tokio-modbus/0.16.3/tokio_modbus/server/rtu_over_tcp/struct

Listens for incoming TCP connections and starts a Modbus RTU over TCP server task for each. It handles connection establishment and processing, with options for error handling and connection rejection.

```rust
pub async fn serve<S, T, F, OnConnected, OnProcessError>(
    &self,
    on_connected: &OnConnected,
    on_process_error: OnProcessError,
) -> Result<()>
where
    S: Service + Send + Sync + 'static,
    S::Request: From<RequestAdu<'static>> + Send,
    T: AsyncRead + AsyncWrite + Unpin + Send + 'static,
    OnConnected: Fn(TcpStream, SocketAddr) -> F,
    F: Future<Output = Result<Option<(S, T)>>>, 
    OnProcessError: FnOnce(Error) + Clone + Send + 'static,
```

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

### Install tokio-modbus with RTU server feature

Source: https://docs.rs/tokio-modbus/0.16.3/tokio_modbus/index

Provides the Cargo.toml configuration for enabling the asynchronous RTU server functionality of tokio-modbus, while disabling default features.

```toml
[dependencies]
tokio-modbus = { version = "*", default-features = false, features = ["rtu-server"] }
```

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

### Read Modbus Coils

Source: https://docs.rs/tokio-modbus/0.16.3/tokio_modbus/client/struct

Asynchronously reads multiple Modbus coils starting from a specified address with a given count.

```rust
pub fn read_coils<'a, 'async_trait>(
    &'a mut self,
    addr: Address,
    cnt: Quantity,
) -> Pin<Box<dyn Future<Output = Result<Vec<bool>>> + Send + 'async_trait>>
where
    Self: 'async_trait,
    'a: 'async_trait,
```

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

### Install tokio-modbus with RTU client feature

Source: https://docs.rs/tokio-modbus/0.16.3/tokio_modbus/index

Shows the Cargo.toml configuration for using tokio-modbus with only the asynchronous RTU client feature, excluding default features.

```toml
[dependencies]
tokio-modbus = { version = "*", default-features = false, features = ["rtu"] }
```

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

### Read Modbus Discrete Inputs

Source: https://docs.rs/tokio-modbus/0.16.3/tokio_modbus/client/struct

Asynchronously reads multiple Modbus discrete inputs starting from a specified address with a given count.

```rust
pub fn read_discrete_inputs<'a, 'async_trait>(
    &'a mut self,
    addr: Address,
    cnt: Quantity,
) -> Pin<Box<dyn Future<Output = Result<Vec<bool>>> + Send + 'async_trait>>
where
    Self: 'async_trait,
    'a: 'async_trait,
```

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

### Install tokio-modbus with TCP client feature

Source: https://docs.rs/tokio-modbus/0.16.3/tokio_modbus/index

Demonstrates how to configure Cargo.toml to include tokio-modbus with only the asynchronous TCP client feature enabled, disabling default features.

```toml
[dependencies]
tokio-modbus = { version = "*", default-features = false, features = ["tcp"] }
```

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

### Write Multiple Modbus Coils

Source: https://docs.rs/tokio-modbus/0.16.3/tokio_modbus/client/struct

Asynchronously writes multiple Modbus coils (Function 0x0F) starting from the specified address with the provided boolean values.

```rust
pub fn write_multiple_coils<'a, 'life0, 'async_trait>(
    &'a mut self,
    addr: Address,
    coils: &'life0 [bool],
) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
where
    Self: 'async_trait,
    'a: 'async_trait,
    'life0: 'async_trait,
```

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

### Start Abortable Modbus RTU over TCP Server (Rust)

Source: https://docs.rs/tokio-modbus/0.16.3/tokio_modbus/server/rtu_over_tcp/struct

Starts an abortable Modbus RTU over TCP server task. This function allows for external signals to terminate the server's operation, but requests are not scoped and can be cancelled at any await point.

```rust
pub async fn serve_until<S, T, F, X, OnConnected, OnProcessError>(
    self,
    on_connected: &OnConnected,
    on_process_error: OnProcessError,
    abort_signal: X,
) -> Result<Terminated>
where
    S: Service + Send + Sync + 'static,
    S::Request: From<RequestAdu<'static>> + Send,
    T: AsyncRead + AsyncWrite + Unpin + Send + 'static,
    X: Future<Output = ()> + Sync + Send + Unpin + 'static,
    OnConnected: Fn(TcpStream, SocketAddr) -> F,
    F: Future<Output = Result<Option<(S, T)>>>, 
    OnProcessError: FnOnce(Error) + Clone + Send + 'static,
```

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

### Context Timeout Management

Source: https://docs.rs/tokio-modbus/0.16.3/tokio_modbus/client/sync/struct

Methods for getting and setting the timeout duration for Modbus operations.

```rust
pub const fn timeout(&self) -> Option<Duration>

Returns the current timeout.
```

```rust
pub fn set_timeout(&mut self, duration: impl Into<Option<Duration>>)

Sets a timeout duration for all subsequent operations.
The timeout is disabled by passing `None`.
```

```rust
pub fn reset_timeout(&mut self)

Disables the timeout for all subsequent operations.
```

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

### Read Modbus Input Registers

Source: https://docs.rs/tokio-modbus/0.16.3/tokio_modbus/client/struct

Asynchronously reads multiple Modbus input registers starting from a specified address with a given count.

```rust
pub fn read_input_registers<'a, 'async_trait>(
    &'a mut self,
    addr: Address,
    cnt: Quantity,
) -> Pin<Box<dyn Future<Output = Result<Vec<u16>>> + Send + 'async_trait>>
where
    Self: 'async_trait,
    'a: 'async_trait,
```

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

### Add tokio-modbus to Cargo.toml

Source: https://docs.rs/tokio-modbus/0.16.3/tokio_modbus/index

This code snippet shows how to add the tokio-modbus crate as a dependency in your Cargo.toml file for a basic project setup.

```toml
[dependencies]
tokio-modbus = "*"
```

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

### Write Multiple Modbus Registers

Source: https://docs.rs/tokio-modbus/0.16.3/tokio_modbus/client/struct

Asynchronously writes multiple Modbus holding registers (Function 0x10) starting from the specified address with the provided data.

```rust
pub fn write_multiple_registers<'a, 'life0, 'async_trait>(
    &'a mut self,
    addr: Address,
    data: &'life0 [u16],
) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
where
    Self: 'async_trait,
    'a: 'async_trait,
    'life0: 'async_trait,
```

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

### Read Modbus Holding Registers

Source: https://docs.rs/tokio-modbus/0.16.3/tokio_modbus/client/struct

Asynchronously reads multiple Modbus holding registers starting from a specified address with a given count.

```rust
pub fn read_holding_registers<'a, 'async_trait>(
    &'a mut self,
    addr: Address,
    cnt: Quantity,
) -> Pin<Box<dyn Future<Output = Result<Vec<u16>>> + Send + 'async_trait>>
where
    Self: 'async_trait,
    'a: 'async_trait,
```

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

### tokio-modbus Writer: write_multiple_coils Method

Source: https://docs.rs/tokio-modbus/0.16.3/tokio_modbus/client/sync/trait

Method signature for writing multiple coils starting from a specified address. Accepts a slice of booleans representing the coils to write. Returns a `Result`. This is part of the synchronous `Writer` trait.

```rust
fn write_multiple_coils(
        &mut self,
        addr: Address,
        coils: &[bool],
    ) -> Result<()>
```

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

### tokio-modbus RTU Server Serve Forever

Source: https://docs.rs/tokio-modbus/0.16.3/tokio_modbus/server/rtu/struct

Starts the RTU server to continuously process Modbus requests. It requires a service that implements the `Service` trait and can handle requests derived from `RequestAdu<'static>`. This method runs indefinitely until the task is cancelled or the program terminates. It returns a Result indicating success or failure during operation.

```rust
pub async fn serve_forever<S>(self, service: S) -> Result<()>
where
    S: Service + Send + Sync + 'static,
    S::Request: From<RequestAdu<'static>> + Send,
```

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

### Serve Modbus TCP Connections with Abort Signal

Source: https://docs.rs/tokio-modbus/0.16.3/tokio_modbus/server/tcp/struct

Starts an abortable Modbus TCP server, allowing the serving process to be terminated via a provided future. This function offers a way to control the server's lifecycle. Note the warning about request processing cancellation points.

```rust
pub async fn serve_until<
    S,
    T,
    F,
    X,
    OnConnected,
    OnProcessError,
>(
    self,
    on_connected: &OnConnected,
    on_process_error: OnProcessError,
    abort_signal: X,
) -> Result<Terminated>
where
    S: Service + Send + Sync + 'static,
    S::Request: From<RequestAdu<'static>> + Send,
    T: AsyncRead + AsyncWrite + Unpin + Send + 'static,
    X: Future<Output = ()> + Sync + Send + Unpin + 'static,
    OnConnected: Fn(TcpStream, SocketAddr) -> F,
    F: Future<Output = Result<Option<(S, T)>>>,
    OnProcessError: FnOnce(Error) + Clone + Send + 'static,
```

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

### Server Initialization and Serving

Source: https://docs.rs/tokio-modbus/0.16.3/tokio_modbus/server/rtu_over_tcp/struct

This section covers the initialization of the Modbus server and how to serve incoming connections, both indefinitely and until an abort signal.

```APIDOC
## POST /websites/rs_tokio-modbus_0_16_3_tokio_modbus/server/rtu_over_tcp

### Description
Handles the creation and management of a Modbus RTU over TCP server.

### Method
POST

### Endpoint
/websites/rs_tokio-modbus_0_16_3_tokio_modbus/server/rtu_over_tcp

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
* **listener** (TcpListener) - Required - The TCP listener to attach the Modbus server to.
* **on_connected** (Fn(TcpStream, SocketAddr) -> F) - Required - A function that creates the service and transport layer for each new connection. It returns a Future that resolves to `Result<Option<(S, T)>>`.
* **on_process_error** (FnOnce(Error)) - Required - A callback function executed when an error occurs during Modbus request processing.
* **abort_signal** (X) - Optional - A Future that, when completed, will stop the server. Used with `serve_until`.

### Request Example
```json
{
  "listener": "tcp_listener_instance",
  "on_connected": "connection_handler_function",
  "on_process_error": "error_handler_function"
}
```

### Response
#### Success Response (200)
- **Terminated** (enum) - Indicates the status of the server when it stops (e.g., 'Success', 'Aborted').

#### Response Example
```json
{
  "status": "Success"
}
```
```

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

### tokio-modbus RTU Server Initialization (Path)

Source: https://docs.rs/tokio-modbus/0.16.3/tokio_modbus/server/rtu/struct

Initializes a new tokio-modbus RTU server instance using a serial interface path and baud rate. This method is suitable when you have the serial port's file path available. It returns a Result which will contain the server instance on success or an error on failure.

```rust
pub fn new_from_path<P: AsRef<Path>>(p: P, baud_rate: u32) -> Result<Self>
```

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

### CloneToUninit Implementation

Source: https://docs.rs/tokio-modbus/0.16.3/tokio_modbus/struct

An experimental nightly-only API for copying data to uninitialized memory.

```rust
unsafe fn clone_to_uninit(&self, dest: *mut u8)
```

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

### Slave Implementations: Formatting

Source: https://docs.rs/tokio-modbus/0.16.3/tokio_modbus/slave/struct

Covers the `Debug` and `Display` trait implementations for `Slave`, which enable formatted output for debugging and user-friendly display of slave addresses.

```rust
impl Debug for Slave
	fn fmt(&self, f: &mut Formatter<'_>) -> Result
```

```rust
impl Display for Slave
	fn fmt(&self, f: &mut Formatter<'_>) -> Result
```

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

### TypeId Implementation

Source: https://docs.rs/tokio-modbus/0.16.3/tokio_modbus/struct

Provides a method to get the TypeId of a type, used for runtime type identification.

```rust
fn type_id(&self) -> TypeId
```

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

### Get Type ID of Context

Source: https://docs.rs/tokio-modbus/0.16.3/tokio_modbus/client/struct

Returns the `TypeId` of the `Context` struct, useful for runtime type identification.

```rust
fn type_id(&self) -> TypeId
```

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

### Convert Context to Client

Source: https://docs.rs/tokio-modbus/0.16.3/tokio_modbus/client/struct

Converts a `Context` struct into a boxed dynamic client (`Box<dyn Client>`).

```rust
pub fn from(val: Context) -> Self
```

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

### Modules and Types

Source: https://docs.rs/tokio-modbus/0.16.3/tokio_modbus/index

Details on the modules and key types exposed by the tokio-modbus crate, including client, server, and slave-related components.

```APIDOC
## Re-exports

`pub use self::slave::Slave;`

`pub use self::slave::SlaveId;`

`pub use bytes;`

## Modules

### client
    Modbus clients

### prelude
    Common types and traits

### server
    Modbus server skeletons

### slave
    Modbus devices

## Structs

### ExceptionResponse
    A server (slave) exception response.

### SlaveRequest
    A Modbus request with slave included

## Enums

### Error
    Protocol or transport errors.

### ExceptionCode
    A server (slave) exception.

### FunctionCode
    A Modbus function code.

### ProtocolError
     _Modbus_ protocol error.

### Request
    A request represents a message from the client (master) to the server (slave).

### Response
    The data of a successful request.

## Type Aliases

### Address
    A Modbus protocol address is represented by 16 bit from `0` to `65535`.

### Quantity
    Number of items to process.

### Result
    Specialized `std::result::Result` type for type-checked responses of the _Modbus_ client API.
```

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

### Convert Client to Context

Source: https://docs.rs/tokio-modbus/0.16.3/tokio_modbus/client/struct

Converts a boxed dynamic client (`Box<dyn Client>`) into a `Context` struct.

```rust
pub fn from(client: Box<dyn Client>) -> Self
```

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

### Generic Trait Implementations

Source: https://docs.rs/tokio-modbus/0.16.3/tokio_modbus/client/sync/struct

Demonstrates various auto-trait and blanket implementations available for the `Context` struct, including `Send`, `Unpin`, `Any`, `Borrow`, `BorrowMut`, `From`, `Into`, `TryFrom`, and `TryInto`.

```rust
impl !Freeze for Context

```

```rust
impl !RefUnwindSafe for Context

```

```rust
impl Send for Context

```

```rust
impl !Sync for Context

```

```rust
impl Unpin for Context

```

```rust
impl !UnwindSafe for Context

```

```rust
impl<T> Any for T where T: 'static + ?Sized

fn type_id(&self) -> TypeId
```

```rust
impl<T> Borrow<T> for T where T: ?Sized

fn borrow(&self) -> &T
```

```rust
impl<T> BorrowMut<T> for T where T: ?Sized

fn borrow_mut(&mut self) -> &mut T
```

```rust
impl<T> From<T> for T

fn from(t: T) -> T
```

```rust
impl<T, U> Into<U> for T where U: From<T>

fn into(self) -> U
```

```rust
impl<T, U> TryFrom<U> for T where U: Into<T>

type Error = Infallible
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
```

```rust
impl<T, U> TryInto<U> for T where U: TryFrom<T>

type Error = <U as TryFrom<T>>::Error
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
```

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

### Initialize Modbus RTU over TCP Server (Rust)

Source: https://docs.rs/tokio-modbus/0.16.3/tokio_modbus/server/rtu_over_tcp/struct

Creates a new Modbus RTU over TCP server instance, binding it to a specified TCP listener.

```rust
pub struct Server { /* private fields */ }

pub fn new(listener: TcpListener) -> Self
```

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

### Rust: Simple Value Conversion with From and Into

Source: https://docs.rs/tokio-modbus/0.16.3/tokio_modbus/slave/struct

Facilitates straightforward conversions between types where ownership is transferred. The `from` method creates a new value from an existing one, and `into` calls the corresponding `from` implementation.

```Rust
impl<T> From<T> for T {
    fn from(t: T) -> T;
}
```

```Rust
impl<T, U> Into<U> for T
where
    U: From<T>,
{
    fn into(self) -> U;
}
```

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

### tokio_modbus::server::tcp::Server

Source: https://docs.rs/tokio-modbus/0.16.3/tokio_modbus/server/tcp/struct

Provides functionality to set up and manage a Modbus TCP server.

```APIDOC
## POST /server/tcp/new

### Description
Initializes a new Modbus TCP server instance bound to a given TCP listener.

### Method
POST

### Endpoint
/server/tcp/new

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **listener** (TcpListener) - Required - The TCP listener to which the Modbus server will be attached.

### Request Example
```json
{
  "listener": "your_tcp_listener_instance"
}
```

### Response
#### Success Response (200)
- **server** (Server) - An instance of the Server struct representing the initialized Modbus TCP server.

#### Response Example
```json
{
  "server": "initialized_server_instance"
}
```
```

```APIDOC
## POST /server/tcp/serve

### Description
Starts listening for incoming Modbus TCP connections and serves them. This method handles the lifecycle of server tasks for each connection.

### Method
POST

### Endpoint
/server/tcp/serve

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **server** (Server) - Required - The server instance to use for serving connections.
- **on_connected** (Fn) - Required - A closure that is called for each new incoming connection, responsible for setting up the service and transport.
- **on_process_error** (FnOnce) - Required - A closure called when an error occurs during Modbus request processing.

### Request Example
```json
{
  "server": "server_instance",
  "on_connected": "closure_for_on_connected",
  "on_process_error": "closure_for_on_process_error"
}
```

### Response
#### Success Response (200)
- **result** (Result<()>) - Indicates success or failure of the serve operation.

#### Response Example
```json
{
  "result": "Ok(())"
}
```
```

```APIDOC
## POST /server/tcp/serve_until

### Description
Starts an abortable Modbus TCP server task. The server will continue to serve connections until an abort signal is received.

### Method
POST

### Endpoint
/server/tcp/serve_until

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **server** (Server) - Required - The server instance to use.
- **on_connected** (Fn) - Required - A closure that is called for each new incoming connection.
- **on_process_error** (FnOnce) - Required - A closure called when an error occurs during Modbus request processing.
- **abort_signal** (Future) - Required - A future that, when it completes, will signal the server to stop.

### Request Example
```json
{
  "server": "server_instance",
  "on_connected": "closure_for_on_connected",
  "on_process_error": "closure_for_on_process_error",
  "abort_signal": "abort_signal_future"
}
```

### Response
#### Success Response (200)
- **result** (Result<Terminated>) - The result of the server operation, potentially including termination status.

#### Response Example
```json
{
  "result": "Ok(Terminated { .. })"
}
```
```

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

### Get TypeId

Source: https://docs.rs/tokio-modbus/0.16.3/tokio_modbus/prelude/struct

Implements the `Any` trait's `type_id` method for a generic type `T`. This method returns the unique `TypeId` of the instance, which is useful for runtime type introspection.

```rust
fn type_id(&self) -> TypeId
```

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

### Writer Trait Documentation

Source: https://docs.rs/tokio-modbus/0.16.3/tokio_modbus/client/trait

Documentation for the `Writer` trait in `tokio_modbus::client`, outlining methods for asynchronous Modbus writes.

```APIDOC
## Writer Trait

### Description
Asynchronous Modbus writer

### Methods

#### `write_single_coil`

##### Description
Write a single coil (0x05)

##### Method
`async fn write_single_coil(&mut self, addr: Address, coil: bool) -> Result<()>`

##### Parameters

*   **addr** (Address) - The address of the coil to write.
*   **coil** (bool) - The boolean value to write to the coil.

#### `write_single_register`

##### Description
Write a single holding register (0x06)

##### Method
`async fn write_single_register(&mut self, addr: Address, word: u16) -> Result<()>`

##### Parameters

*   **addr** (Address) - The address of the register to write.
*   **word** (u16) - The u16 value to write to the register.

#### `write_multiple_coils`

##### Description
Write multiple coils (0x0F)

##### Method
`async fn write_multiple_coils(&mut self, addr: Address, coils: &[bool]) -> Result<()>`

##### Parameters

*   **addr** (Address) - The starting address of the coils to write.
*   **coils** ([bool]) - A slice of boolean values to write to the coils.

#### `write_multiple_registers`

##### Description
Write multiple holding registers (0x10)

##### Method
`async fn write_multiple_registers(&mut self, addr: Address, words: &[u16]) -> Result<()>`

##### Parameters

*   **addr** (Address) - The starting address of the registers to write.
*   **words** ([u16]) - A slice of u16 values to write to the registers.

#### `masked_write_register`

##### Description
Set or clear individual bits of a holding register (0x16)

##### Method
`async fn masked_write_register(&mut self, addr: Address, and_mask: u16, or_mask: u16) -> Result<()>`

##### Parameters

*   **addr** (Address) - The address of the register to modify.
*   **and_mask** (u16) - The AND mask to apply to the register.
*   **or_mask** (u16) - The OR mask to apply to the register.

### Implementors

*   `impl Writer for Context`
```

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

### Slave Constants and Methods

Source: https://docs.rs/tokio-modbus/0.16.3/tokio_modbus/slave/struct

Explains the constants and methods available for the Slave struct, including broadcast, device addressing, and address type checking.

```APIDOC
## Slave Implementations

### Constants
- `broadcast()`: Returns the special address for broadcasting to all slave devices.
- `min_device()`: Returns the minimum address for a single Modbus slave device.
- `max_device()`: Returns the maximum address for a single Modbus slave device.
- `tcp_device()`: Returns the reserved address for directly connected Modbus TCP devices.

### Methods
- `is_broadcast()`: Checks if the SlaveId is used for broadcasting.
- `is_single_device()`: Checks if the SlaveId addresses a single device.
- `is_reserved()`: Checks if the SlaveId is reserved.
```

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

### tokio_modbus::server::rtu::Server

Source: https://docs.rs/tokio-modbus/0.16.3/tokio_modbus/server/rtu/struct

Provides methods for creating and managing an RTU Modbus server.

```APIDOC
## POST /server/rtu

### Description
Initializes and starts an RTU Modbus server.

### Method
POST

### Endpoint
`/server/rtu`

### Parameters
#### Query Parameters
- **baud_rate** (u32) - Required - The baud rate for the serial connection.

#### Request Body
- **serial_path** (string) - Required - The path to the serial interface.

### Request Example
```json
{
  "serial_path": "/dev/ttyUSB0"
}
```

### Response
#### Success Response (200)
- **message** (string) - Indicates successful server initialization.

#### Response Example
```json
{
  "message": "RTU server started successfully."
}
```

---

## POST /server/rtu/stream

### Description
Initializes an RTU Modbus server using a pre-configured `SerialStream`.

### Method
POST

### Endpoint
`/server/rtu/stream`

### Parameters
#### Request Body
- **service** (object) - Required - The service to handle Modbus requests.
  - **request_type** (string) - Required - The type of request the service accepts (e.g., `RequestAdu<'static'>`).
  - **send_sync** (boolean) - Required - Indicates if the service is Send + Sync.
  - **static_lifetime** (boolean) - Required - Indicates if the service has a 'static lifetime.

### Request Example
```json
{
  "service": {
    "request_type": "RequestAdu<'static'>",
    "send_sync": true,
    "static_lifetime": true
  }
}
```

### Response
#### Success Response (200)
- **message** (string) - Indicates successful server initialization with a stream.

#### Response Example
```json
{
  "message": "RTU server started successfully using SerialStream."
}
```

---

## POST /server/rtu/serve_forever

### Description
Starts serving Modbus RTU requests indefinitely.

### Method
POST

### Endpoint
`/server/rtu/serve_forever`

### Parameters
#### Request Body
- **service** (object) - Required - The service to handle Modbus requests.
  - **request_type** (string) - Required - The type of request the service accepts (e.g., `RequestAdu<'static'>`).
  - **send_sync** (boolean) - Required - Indicates if the service is Send + Sync.
  - **static_lifetime** (boolean) - Required - Indicates if the service has a 'static lifetime.

### Request Example
```json
{
  "service": {
    "request_type": "RequestAdu<'static'>",
    "send_sync": true,
    "static_lifetime": true
  }
}
```

### Response
#### Success Response (200)
- **message** (string) - Indicates that the server is serving requests.

#### Response Example
```json
{
  "message": "Server is now serving requests indefinitely."
}
```

---

## POST /server/rtu/serve_until

### Description
Starts serving Modbus RTU requests until a specified abort signal is received.

### Method
POST

### Endpoint
`/server/rtu/serve_until`

### Parameters
#### Request Body
- **service** (object) - Required - The service to handle Modbus requests.
  - **request_type** (string) - Required - The type of request the service accepts (e.g., `RequestAdu<'static'>`).
  - **send_sync** (boolean) - Required - Indicates if the service is Send + Sync.
  - **static_lifetime** (boolean) - Required - Indicates if the service has a 'static lifetime.
- **abort_signal** (object) - Required - The future that signals when to stop serving.
  - **output_type** (string) - Required - The output type of the future.
  - **sync_unpin** (boolean) - Required - Indicates if the future is Sync + Unpin.
  - **static_lifetime** (boolean) - Required - Indicates if the future has a 'static lifetime.

### Request Example
```json
{
  "service": {
    "request_type": "RequestAdu<'static'>",
    "send_sync": true,
    "static_lifetime": true
  },
  "abort_signal": {
    "output_type": "()",
    "sync_unpin": true,
    "static_lifetime": true
  }
}
```

### Response
#### Success Response (200)
- **message** (string) - Indicates that the server is serving requests until aborted.
- **terminated_status** (string) - The status of termination (e.g., 'aborted', 'completed').

#### Response Example
```json
{
  "message": "Server is serving requests until aborted.",
  "terminated_status": "aborted"
}
```
```

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

### Rust: TryInto Conversion with TryInto and TryFrom

Source: https://docs.rs/tokio-modbus/0.16.3/tokio_modbus/slave/struct

Enables fallible conversions between types using `TryInto` and `TryFrom`. `try_into` attempts a conversion and returns a `Result`, while `TryFrom` defines the conversion logic and potential errors.

```Rust
impl<T, U> TryInto<U> for T
where
    U: TryFrom<T>,
{
    type Error = <U as TryFrom<T>>::Error;
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>;
}
```

```Rust
impl<T, U> TryFrom<U> for T
where
    U: Into<T>,
{
    type Error = Infallible;
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>;
}
```

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

### tokio-modbus Response Get Function Code

Source: https://docs.rs/tokio-modbus/0.16.3/tokio_modbus/enum

Implements a function to retrieve the Modbus FunctionCode associated with a given Response variant. This is useful for identifying the type of Modbus operation that generated the response.

```rust
/// Get the `FunctionCode` of the `Response`.
/// pub const fn function_code(&self) -> FunctionCode
```

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

### tokio-modbus Writer: write_multiple_registers Method

Source: https://docs.rs/tokio-modbus/0.16.3/tokio_modbus/client/sync/trait

Method signature for writing multiple holding registers starting from a specified address. Accepts a slice of 16-bit unsigned integers. Returns a `Result`. This is part of the synchronous `Writer` trait.

```rust
fn write_multiple_registers(
        &mut self,
        addr: Address,
        words: &[u16],
    ) -> Result<()>
```

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

### Client Request Handling

Source: https://docs.rs/tokio-modbus/0.16.3/tokio_modbus/client/sync/struct

Implementation of the `Client` trait for handling Modbus requests.

```rust
fn call(&mut self, req: Request<'_>) -> Result<Response>
```

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

### Run all workspace tests with all features

Source: https://docs.rs/tokio-modbus/0.16.3/tokio_modbus/index

This command runs all tests in the tokio-modbus workspace, including those enabled by all available feature flags.

```bash
cargo test --workspace --all-features
```

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

### Slave Implementations: Comparison Traits

Source: https://docs.rs/tokio-modbus/0.16.3/tokio_modbus/slave/struct

Shows the implementations of comparison traits like `PartialEq`, `Eq`, `Ord`, and `PartialOrd` for the `Slave` struct. These allow for comparing `Slave` addresses.

```rust
impl PartialEq for Slave
	fn eq(&self, other: &Slave) -> bool
```

```rust
impl Eq for Slave
```

```rust
impl Ord for Slave
	fn cmp(&self, other: &Slave) -> Ordering
```

```rust
impl PartialOrd for Slave
	fn partial_cmp(&self, other: &Slave) -> Option<Ordering>
```

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

### Rust: Unsafe Cloning to Uninitialized Memory with clone_to_uninit

Source: https://docs.rs/tokio-modbus/0.16.3/tokio_modbus/slave/struct

An experimental, nightly-only API for performing copy-assignment from `self` to a mutable pointer to uninitialized memory (`dest`). Requires `T` to implement `Clone`.

```Rust
impl<T> CloneToUninit for T
where
    T: Clone,
{
    unsafe fn clone_to_uninit(&self, dest: *mut u8);
}
```

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

### tokio-modbus RTU Server Serve Until Abort

Source: https://docs.rs/tokio-modbus/0.16.3/tokio_modbus/server/rtu/struct

Starts the RTU server to process Modbus requests until a specified abort signal is received or the server naturally terminates. This method is useful for controlled shutdown scenarios. It takes a service and a future that acts as the abort signal. Note that request processing is not scoped, which might lead to unexpected behavior upon cancellation.

```rust
pub async fn serve_until<S, X>(
    self,
    service: S,
    abort_signal: X,
) -> Result<Terminated>
where
    S: Service + Send + Sync + 'static,
    S::Request: From<RequestAdu<'static>> + Send,
    X: Future<Output = ()> + Sync + Send + Unpin + 'static,
```

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

### Run workspace tests for tokio-modbus

Source: https://docs.rs/tokio-modbus/0.16.3/tokio_modbus/index

This command executes all tests within the tokio-modbus workspace, ensuring the crate's functionality is validated.

```bash
cargo test --workspace
```
Tokens:
Raw