libmodbus

https://github.com/stephane/libmodbus
Admin
libmodbus is a free software library for sending and receiving data with devices using the Modbus...
Tokens:29,710
Snippets:334
Trust Score:7.3
License:LGPL-2.1
Update:1 month ago
Show doc for...
Tokens:
Raw
### Install and Serve Documentation

Source: https://github.com/stephane/libmodbus/blob/master/README.md

Commands to install the documentation generator and start a local development server.

```shell
pip install mkdocs-material
mkdocs serve
```

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

### Full Allocation Example

Source: https://github.com/stephane/libmodbus/blob/master/docs/modbus_mapping_new_start_address.md

Complete example showing allocation and error handling for the mapping structure.

```c
/* The first value of each array is accessible at the defined address.
The end address is ADDRESS + NB - 1. */
mb_mapping = modbus_mapping_new_start_address(
    BITS_ADDRESS, BITS_NB,
    INPUT_BITS_ADDRESS, INPUT_BITS_NB,
    REGISTERS_ADDRESS, REGISTERS_NB,
    INPUT_REGISTERS_ADDRESS, INPUT_REGISTERS_NB
);
if (mb_mapping == NULL) {
    fprintf(
        stderr, "Failed to allocate the mapping: %s\n",
        modbus_strerror(errno)
    );
    modbus_free(ctx);
    return -1;
}
```

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

### Install libmodbus dependencies

Source: https://github.com/stephane/libmodbus/wiki/Libmodbus-on-Raspberry-pi

Install the necessary build tools on a Debian-based system.

```bash
sudo apt-get install -y autoconf libtool
```

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

### Save Indication Timeout Example

Source: https://github.com/stephane/libmodbus/blob/master/docs/modbus_get_indication_timeout.md

Example usage showing how to store the current timeout values before modification.

```c
uint32_t to_sec;
uint32_t to_usec;

/* Save original timeout */
modbus_get_indication_timeout(ctx, &to_sec, &to_usec);
```

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

### Reading Modbus Registers Example

Source: https://github.com/stephane/libmodbus/blob/master/docs/modbus_read_registers.md

Example demonstrating connection to a TCP server and reading 10 registers into a local array.

```c
modbus_t *ctx;
uint16_t tab_reg[64];
int rc;
int i;

ctx = modbus_new_tcp("127.0.0.1", 502);
if (modbus_connect(ctx) == -1) {
    fprintf(stderr, "Connection failed: %s\n", modbus_strerror(errno));
    modbus_free(ctx);
    return -1;
}

rc = modbus_read_registers(ctx, 0, 10, tab_reg);
if (rc == -1) {
    fprintf(stderr, "%s\n", modbus_strerror(errno));
    return -1;
}

for (i=0; i < rc; i++) {
    printf("reg[%d]=%d (0x%X)\n", i, tab_reg[i], tab_reg[i]);
}

modbus_close(ctx);
modbus_free(ctx);
```

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

### Example usage of modbus_new_tcp

Source: https://github.com/stephane/libmodbus/blob/master/docs/modbus_new_tcp.md

Demonstrates initializing a context and establishing a connection to a Modbus TCP server.

```c
modbus_t *ctx;

ctx = modbus_new_tcp("127.0.0.1", 502);
if (ctx == NULL) {
    fprintf(stderr, "Unable to allocate libmodbus context\n");
    return -1;
}

if (modbus_connect(ctx) == -1) {
    fprintf(stderr, "Connection failed: %s\n", modbus_strerror(errno));
    modbus_free(ctx);
    return -1;
}
```

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

### Example usage of modbus_new_tcp_pi

Source: https://github.com/stephane/libmodbus/blob/master/docs/modbus_new_tcp_pi.md

Demonstrates initializing a context and establishing a connection to a server using IPv6 loopback.

```c
modbus_t *ctx;

ctx = modbus_new_tcp_pi("::1", "502");
if (ctx == NULL) {
    fprintf(stderr, "Unable to allocate libmodbus context\n");
    return -1;
}

if (modbus_connect(ctx) == -1) {
    fprintf(stderr, "Connection failed: %s\n", modbus_strerror(errno));
    modbus_free(ctx);
    return -1;
}
```

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

### TCP PI Server Implementation

Source: https://github.com/stephane/libmodbus/blob/master/docs/modbus_tcp_pi_listen.md

A basic example demonstrating how to initialize a context, listen for connections, and handle incoming requests.

```c
...

ctx = modbus_new_tcp_pi("::0", "502");
s = modbus_tcp_pi_listen(ctx, 1);
modbus_tcp_pi_accept(ctx, &s);

for (;;) {
    rc = modbus_receive(ctx, query);
    modbus_reply(ctx, query, rc, mb_mapping);
}
...

close(s);
modbus_free(ctx);
```

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

### modbus_tcp_accept usage example

Source: https://github.com/stephane/libmodbus/blob/master/docs/modbus_tcp_accept.md

Basic usage pattern for initializing a TCP server and accepting a connection.

```c
...

ctx = modbus_new_tcp("127.0.0.1", 502);
s = modbus_tcp_listen(ctx, 1);
modbus_tcp_accept(ctx, &s);

...

close(s);
modbus_free(ctx);
```

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

### Example usage of modbus_receive_confirmation

Source: https://github.com/stephane/libmodbus/blob/master/docs/modbus_receive_confirmation.md

Basic implementation showing buffer allocation and function call.

```c
uint8_t rsp[MODBUS_MAX_ADU_LENGTH];
rc = modbus_receive_confirmation(ctx, rsp);
```

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

### Example usage of modbus_tcp_listen

Source: https://github.com/stephane/libmodbus/blob/master/docs/modbus_tcp_listen.md

Demonstrates initializing a TCP context, setting up the listener, and using select to manage the socket.

```c
...

/* To listen any addresses on port 502 */
ctx = modbus_new_tcp(NULL, 502);

/* Handle until 10 established connections */
server_socket = modbus_tcp_listen(ctx, 10);

/* Clear the reference set of socket */
FD_ZERO(&refset);

/* Add the server socket */
FD_SET(server_socket, &refset);

if (select(server_socket + 1, &refset, NULL, NULL, NULL) == -1) {
}

...

close(server_socket);
modbus_free(ctx);
```

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

### Example usage of modbus_connect

Source: https://github.com/stephane/libmodbus/blob/master/docs/modbus_connect.md

Demonstrates initializing a TCP context and connecting to a server, including error handling.

```c
modbus_t *ctx;

ctx = modbus_new_tcp("127.0.0.1", 502);
if (modbus_connect(ctx) == -1) {
    fprintf(stderr, "Connection failed: %s\n", modbus_strerror(errno));
    modbus_free(ctx);
    return -1;
}
```

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

### Initialize and connect to an RTU device

Source: https://github.com/stephane/libmodbus/blob/master/docs/modbus_new_rtu.md

Example showing how to create a context, connect to a serial port, and set the slave ID for communication.

```c
const int REMOTE_ID = 10;
modbus_t *ctx;
uint16_t tab_reg[10];

ctx = modbus_new_rtu("/dev/ttyUSB0", 115200, 'N', 8, 1);
if (ctx == NULL) {
    fprintf(stderr, "Unable to create the libmodbus context\n");
    return -1;
}

if (modbus_connect(ctx) == -1) {
    fprintf(stderr, "Connection failed: %s\n", modbus_strerror(errno));
    modbus_free(ctx);
    return -1;
}

modbus_set_slave(ctx, REMOTE_ID);

// Read 2 registers from address 0 of server ID 10.
modbus_read_registers(ctx, 0, 2, tab_reg);
```

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

### Example usage of modbus_get_response_timeout

Source: https://github.com/stephane/libmodbus/blob/master/docs/modbus_get_response_timeout.md

Demonstrates saving the current timeout before applying a new one.

```c
uint32_t old_response_to_sec;
uint32_t old_response_to_usec;

/* Save original timeout */
modbus_get_response_timeout(ctx, &old_response_to_sec, &old_response_to_usec);

/* Define a new and too short timeout! */
modbus_set_response_timeout(ctx, 0, 0);
```

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

### Example usage of modbus_receive

Source: https://github.com/stephane/libmodbus/blob/master/docs/modbus_receive.md

Basic implementation showing buffer allocation and function call.

```c
uint8_t req[MODBUS_MAX_ADU_LENGTH];
rc = modbus_receive(ctx, req);
```

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

### Example usage of modbus_mapping_new

Source: https://github.com/stephane/libmodbus/blob/master/docs/modbus_mapping_new.md

Demonstrates allocating a mapping structure and handling potential allocation failures.

```c
/* The first value of each array is accessible from the 0 address. */
mb_mapping = modbus_mapping_new(
    BITS_ADDRESS + BITS_NB,
    INPUT_BITS_ADDRESS + INPUT_BITS_NB,
    REGISTERS_ADDRESS + REGISTERS_NB,
    INPUT_REGISTERS_ADDRESS + INPUT_REGISTERS_NB
);
if (mb_mapping == NULL) {
    fprintf(
        stderr, "Failed to allocate the mapping: %s\n",
        modbus_strerror(errno)
    );
    modbus_free(ctx);
    return -1;
}
```

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

### Example debug output

Source: https://github.com/stephane/libmodbus/blob/master/docs/modbus_set_debug.md

Shows the format of verbose messages displayed when the debug flag is enabled.

```text
[00][14][00][00][00][06][12][03][00][6B][00][03]
Waiting for a confirmation...
<00><14><00><00><00><09><12><03><06><02><2B><00><00><00><00>
```

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

### Allocate Specific Register Range

Source: https://github.com/stephane/libmodbus/blob/master/docs/modbus_mapping_new_start_address.md

Example of allocating memory for registers starting at address 340.

```c
mb_mapping = modbus_mapping_new_start_address(0, 0, 0, 0, 340, 10, 0, 0);
```

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

### Setting the slave ID in an RTU context

Source: https://github.com/stephane/libmodbus/blob/master/docs/modbus_set_slave.md

Example demonstrating the initialization of an RTU context and setting the slave ID before establishing a connection.

```c
modbus_t *ctx;

ctx = modbus_new_rtu("/dev/ttyUSB0", 115200, 'N', 8, 1);
if (ctx == NULL) {
    fprintf(stderr, "Unable to create the libmodbus context\n");
    return -1;
}

rc = modbus_set_slave(ctx, YOUR_DEVICE_ID);
if (rc == -1) {
    fprintf(stderr, "Invalid slave ID\n");
    modbus_free(ctx);
    return -1;
}

if (modbus_connect(ctx) == -1) {
    fprintf(stderr, "Connection failed: %s\n", modbus_strerror(errno));
    modbus_free(ctx);
    return -1;
}
```

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

### Example usage of raw request sending

Source: https://github.com/stephane/libmodbus/blob/master/docs/modbus_send_raw_request_tid.md

Demonstrates constructing a raw request array and sending it via a TCP context.

```c
modbus_t *ctx;
/* Read 5 holding registers from address 1 */
uint8_t raw_req[] = { 0xFF, MODBUS_FC_READ_HOLDING_REGISTERS, 0x00, 0x01, 0x0, 0x05 };
int req_length;
uint8_t rsp[MODBUS_TCP_MAX_ADU_LENGTH];

ctx = modbus_new_tcp("127.0.0.1", 502);
if (modbus_connect(ctx) == -1) {
    fprintf(stderr, "Connection failed: %s\n", modbus_strerror(errno));
    modbus_free(ctx);
    return -1;
}

req_length = modbus_send_raw_request(ctx, raw_req, 6 * sizeof(uint8_t), 0);
modbus_receive_confirmation(ctx, rsp);

modbus_close(ctx);
modbus_free(ctx);
```

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

### Get Indication Timeout Synopsis

Source: https://github.com/stephane/libmodbus/blob/master/docs/modbus_get_indication_timeout.md

Function signature for retrieving the indication timeout.

```c
int modbus_get_indication_timeout(modbus_t *ctx, uint32_t *to_sec, uint32_t *to_usec);
```

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

### Enable RTS mode with positive polarity

Source: https://github.com/stephane/libmodbus/blob/master/docs/modbus_rtu_set_rts.md

Example demonstrating how to initialize an RTU context, set the serial mode to RS485, and enable RTS with positive polarity.

```c
modbus_t *ctx;
uint16_t tab_reg[10];

ctx = modbus_new_rtu("/dev/ttyS0", 115200, 'N', 8, 1);
modbus_set_slave(ctx, 1);

if (modbus_connect(ctx) == -1) {
    fprintf(stderr, "Connection failed: %s\n", modbus_strerror(errno));
    modbus_free(ctx);
    return -1;
}

modbus_rtu_set_serial_mode(ctx, MODBUS_RTU_RS485);
modbus_rtu_set_rts(ctx, MODBUS_RTU_RTS_UP);

rc = modbus_read_registers(ctx, 0, 7, tab_reg);
if (rc == -1) {
    fprintf(stderr, "%s\n", modbus_strerror(errno));
    return -1;
}

modbus_close(ctx);
modbus_free(ctx);
```

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

### Displaying a connection error

Source: https://github.com/stephane/libmodbus/blob/master/docs/modbus_strerror.md

Usage example for displaying an error message when a Modbus connection fails.

```c
if (modbus_connect(ctx) == -1) {
    fprintf(stderr, "Connection failed: %s\n", modbus_strerror(errno));
    abort();
}
```

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

### Example usage of modbus_set_response_timeout

Source: https://github.com/stephane/libmodbus/blob/master/docs/modbus_set_response_timeout.md

Demonstrates saving the current timeout settings and applying a new 200ms response timeout.

```c
uint32_t old_response_to_sec;
uint32_t old_response_to_usec;

/* Save original timeout */
modbus_get_response_timeout(ctx, &old_response_to_sec, &old_response_to_usec);

/* Define a new timeout of 200ms */
modbus_set_response_timeout(ctx, 0, 200000);
```

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

### Implementing a TCP-to-RTU gateway

Source: https://github.com/stephane/libmodbus/blob/master/docs/modbus_proxy.md

Example demonstrating the use of modbus_proxy to bridge a TCP frontend and an RTU backend.

```c
modbus_t *tcp_ctx;
modbus_t *rtu_ctx;
uint8_t query[MODBUS_TCP_MAX_ADU_LENGTH];
int rc;

tcp_ctx = modbus_new_tcp("0.0.0.0", 1502);
rtu_ctx = modbus_new_rtu("/dev/ttyUSB0", 38400, 'E', 8, 1);

int s = modbus_tcp_listen(tcp_ctx, 1);
modbus_connect(rtu_ctx);

for (;;) {
    modbus_tcp_accept(tcp_ctx, &s);

    for (;;) {
        rc = modbus_receive(tcp_ctx, query);
        if (rc < 0)
            break;
        if (rc == 0)
            continue;

        /* Forward the TCP request to the RTU device and relay the response */
        modbus_proxy(tcp_ctx, rtu_ctx, query, rc);
    }

    modbus_close(tcp_ctx);
}

modbus_close(rtu_ctx);
modbus_free(tcp_ctx);
modbus_free(rtu_ctx);
```

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

### Example usage of modbus_set_socket

Source: https://github.com/stephane/libmodbus/blob/master/docs/modbus_set_socket.md

Demonstrates assigning a master socket to a context within a select-based server loop.

```c
ctx = modbus_new_tcp("127.0.0.1", 502);
server_socket = modbus_tcp_listen(ctx, NB_CONNECTION);

FD_ZERO(&rdset);
FD_SET(server_socket, &rdset);

/* .... */

if (FD_ISSET(master_socket, &rdset)) {
    modbus_set_socket(ctx, master_socket);
    rc = modbus_receive(ctx, query);
    if (rc != -1) {
        modbus_reply(ctx, query, rc, mb_mapping);
    }
}
```

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

### modbus_mapping_new_start_address

Source: https://github.com/stephane/libmodbus/blob/master/docs/modbus_mapping_new_start_address.md

Allocates four arrays of bits and registers accessible from their starting addresses.

```APIDOC
## modbus_mapping_new_start_address

### Description
Allocates four arrays to store bits, input bits, registers, and input registers. The pointers are stored in a modbus_mapping_t structure, and all values are initialized to zero. This allows mapping data to specific address ranges.

### Signature
modbus_mapping_t* modbus_mapping_new_start_address(unsigned int start_bits, unsigned int nb_bits, unsigned int start_input_bits, unsigned int nb_input_bits, unsigned int start_registers, unsigned int nb_registers, unsigned int start_input_registers, unsigned int nb_input_registers);

### Parameters
- **start_bits** (unsigned int) - Starting address for bits.
- **nb_bits** (unsigned int) - Number of bits to allocate.
- **start_input_bits** (unsigned int) - Starting address for input bits.
- **nb_input_bits** (unsigned int) - Number of input bits to allocate.
- **start_registers** (unsigned int) - Starting address for registers.
- **nb_registers** (unsigned int) - Number of registers to allocate.
- **start_input_registers** (unsigned int) - Starting address for input registers.
- **nb_input_registers** (unsigned int) - Number of input registers to allocate.

### Return Value
Returns a pointer to the new allocated modbus_mapping_t structure if successful, or NULL if an error occurs (sets errno).

### Errors
- **EINVAL**: One of the requested array dimensions exceeds 65536 entries.
- **ENOMEM**: Not enough memory available.
```

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

### Enabling and disabling modbus quirks

Source: https://github.com/stephane/libmodbus/blob/master/docs/modbus_disable_quirks.md

Example showing how to enable specific quirks and subsequently reset all of them using the MODBUS_QUIRK_ALL mask.

```c
modbus_enable_quirks(ctx, MODBUS_QUIRK_MAX_SLAVE | MODBUS_QUIRK_REPLY_TO_BROADCAST);

...

// Reset all quirks
modbus_disable_quirks(ctx, MODBUS_QUIRK_ALL);
```

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

### Function Synopsis

Source: https://github.com/stephane/libmodbus/blob/master/docs/modbus_mapping_new_start_address.md

The function signature for allocating Modbus mapping structures with custom start addresses.

```c
modbus_mapping_t* modbus_mapping_new_start_address(
    unsigned int start_bits, unsigned int nb_bits,
    unsigned int start_input_bits, unsigned int nb_input_bits,
    unsigned int start_registers, unsigned int nb_registers,
    unsigned int start_input_registers, unsigned int nb_input_registers);
```

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

### Example usage of modbus_set_error_recovery

Source: https://github.com/stephane/libmodbus/blob/master/docs/modbus_set_error_recovery.md

Enables both link and protocol error recovery modes for the provided context.

```c
modbus_set_error_recovery(
    ctx,
    MODBUS_ERROR_RECOVERY_LINK | MODBUS_ERROR_RECOVERY_PROTOCOL
);
```

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

### Example usage of modbus_report_slave_id

Source: https://github.com/stephane/libmodbus/blob/master/docs/modbus_report_slave_id.md

Demonstrates how to call the function and check the run status indicator from the response buffer.

```c
uint8_t tab_bytes[MODBUS_MAX_PDU_LENGTH];

...

rc = modbus_report_slave_id(ctx, MODBUS_MAX_PDU_LENGTH, tab_bytes);
if (rc > 1) {
    printf("Run Status Indicator: %s\n", tab_bytes[1] ? "ON" : "OFF");
}
```

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

### Sending a Raw Modbus Request Example

Source: https://github.com/stephane/libmodbus/blob/master/docs/modbus_send_raw_request.md

Demonstrates constructing a raw request for reading holding registers and sending it via a TCP context.

```c
modbus_t *ctx;
/* Read 5 holding registers from address 1 */
uint8_t raw_req[] = { 0xFF, MODBUS_FC_READ_HOLDING_REGISTERS, 0x00, 0x01, 0x0, 0x05 };
int req_length;
uint8_t rsp[MODBUS_TCP_MAX_ADU_LENGTH];

ctx = modbus_new_tcp("127.0.0.1", 502);
if (modbus_connect(ctx) == -1) {
    fprintf(stderr, "Connection failed: %s\n", modbus_strerror(errno));
    modbus_free(ctx);
    return -1;
}

req_length = modbus_send_raw_request(ctx, raw_req, 6 * sizeof(uint8_t));
modbus_receive_confirmation(ctx, rsp);

modbus_close(ctx);
modbus_free(ctx);
```

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

### Get RTS delay in C

Source: https://github.com/stephane/libmodbus/blob/master/docs/modbus_rtu_get_rts_delay.md

Retrieves the RTS delay for a context using the RTU backend.

```c
int modbus_rtu_get_rts_delay(modbus_t *ctx);
```

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

### void modbus_set_bits_from_byte(uint8_t *dest, int index, const uint8_t value)

Source: https://github.com/stephane/libmodbus/blob/master/docs/modbus_set_bits_from_byte.md

Sets 8 bits from a single byte value into the destination array starting at the specified index.

```APIDOC
## void modbus_set_bits_from_byte(uint8_t *dest, int index, const uint8_t value)

### Description
The modbus_set_bits_from_byte() function sets 8 bits from a single byte value. All 8 bits from the byte `value` are written to the `dest` array starting at the `index` position.

### Parameters
- **dest** (uint8_t *) - The destination array where bits will be written.
- **index** (int) - The starting position in the destination array.
- **value** (const uint8_t) - The byte value containing the bits to be set.

### Return Value
This function does not return a value.
```

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

### Get RTS mode in C

Source: https://github.com/stephane/libmodbus/blob/master/docs/modbus_rtu_get_rts.md

Retrieves the current RTS mode for an RTU backend context. Requires a valid modbus_t context initialized for RTU.

```c
int modbus_rtu_get_rts(modbus_t *ctx);
```

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

### int modbus_send_raw_request(modbus_t *ctx, const uint8_t *raw_req, int raw_req_length)

Source: https://github.com/stephane/libmodbus/blob/master/docs/modbus_send_raw_request.md

Sends a raw Modbus request via the provided context. The function automatically appends backend-specific headers or CRC, requiring the raw_req buffer to start with the slave/unit identifier and function code.

```APIDOC
## int modbus_send_raw_request(modbus_t *ctx, const uint8_t *raw_req, int raw_req_length)

### Description
Sends a raw request via the socket of the context `ctx`. This function is intended for debugging or sending requests not natively handled by the library. The user must provide a valid request starting with the slave/unit identifier and function code.

### Parameters
- **ctx** (modbus_t *) - Required - The libmodbus context.
- **raw_req** (const uint8_t *) - Required - The raw request buffer containing at least the slave/unit identifier and function code.
- **raw_req_length** (int) - Required - The length of the raw request buffer.

### Return Value
Returns the full message length (including backend-specific headers/CRC) on success. Returns -1 and sets errno on failure.
```

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

### Compile random-test-server with pkg-config

Source: https://github.com/stephane/libmodbus/blob/master/tests/README.md

Use pkg-config to link the necessary libmodbus libraries and include paths when compiling the test server.

```bash
gcc random-test-server.c -o random-test-server $(pkg-config --libs --cflags libmodbus)
```

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

### Get slave number in C

Source: https://github.com/stephane/libmodbus/blob/master/docs/modbus_get_slave.md

Retrieves the slave number from the provided libmodbus context.

```c
int modbus_get_slave(modbus_t *ctx);
```

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

### Clone and build libmodbus

Source: https://github.com/stephane/libmodbus/wiki/Libmodbus-on-Raspberry-pi

Commands to clone the repository, enter the directory, and compile the library.

```bash
git clone https://github.com/stephane/libmodbus/
```

```bash
cd libmodbus
```

```bash
./autogen.sh && ./configure --prefix=/usr && make && sudo make install
```

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

### Accept a TCP PI Modbus connection

Source: https://github.com/stephane/libmodbus/blob/master/docs/modbus_tcp_pi_accept.md

Demonstrates the sequence of creating a context, listening for connections, and accepting a new connection.

```c
...

ctx = modbus_new_tcp_pi("::0", "502");
s = modbus_tcp_pi_listen(ctx, 1);
modbus_tcp_pi_accept(ctx, &s);

...

close(s);
modbus_free(ctx);
```

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

### Get Serial Mode Function Signature

Source: https://github.com/stephane/libmodbus/blob/master/docs/modbus_rtu_get_serial_mode.md

The function returns the serial mode constant or -1 on error.

```c
int modbus_rtu_get_serial_mode(modbus_t *ctx);
```

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

### Compile libmodbus applications

Source: https://github.com/stephane/libmodbus/wiki/Libmodbus-on-Raspberry-pi

Use pkg-config to link the libmodbus library during compilation.

```bash
gcc filename.c -o filename $(pkg-config --libs --cflags libmodbus) 
```

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

### Get the current socket of the context

Source: https://github.com/stephane/libmodbus/blob/master/docs/modbus_get_socket.md

Retrieves the file descriptor or socket currently used by the provided modbus_t context.

```c
int modbus_get_socket(modbus_t *ctx);
```

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

### int modbus_connect(modbus_t *ctx)

Source: https://github.com/stephane/libmodbus/blob/master/docs/modbus_connect.md

Establishes a connection to a Modbus server using the provided context.

```APIDOC
## int modbus_connect(modbus_t *ctx)

### Description
The modbus_connect() function establishes a connection to a Modbus server, a network, or a bus using the context information provided in the argument.

### Parameters
- **ctx** (modbus_t*) - Required - The libmodbus context to connect.

### Return Value
Returns 0 if successful. Otherwise, returns -1 and sets errno to a value defined by the underlying platform system calls.

### Example
```c
modbus_t *ctx;

ctx = modbus_new_tcp("127.0.0.1", 502);
if (modbus_connect(ctx) == -1) {
    fprintf(stderr, "Connection failed: %s\n", modbus_strerror(errno));
    modbus_free(ctx);
    return -1;
}
```
```

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

### Establish a Modbus connection

Source: https://github.com/stephane/libmodbus/blob/master/docs/modbus_connect.md

The function signature for establishing a connection.

```c
int modbus_connect(modbus_t *ctx);
```

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

### int modbus_tcp_pi_listen(modbus_t *ctx, int nb_connection)

Source: https://github.com/stephane/libmodbus/blob/master/docs/modbus_tcp_pi_listen.md

Creates a socket and listens for incoming connections on the specified nodes.

```APIDOC
## int modbus_tcp_pi_listen(modbus_t *ctx, int nb_connection)

### Description
The modbus_tcp_pi_listen function creates a socket and listens to a maximum of nb_connection incoming connections on the specified nodes. The context ctx must be initialized with modbus_new_tcp_pi before calling this function.

### Parameters
- **ctx** (modbus_t *) - Required - The Modbus context initialized with modbus_new_tcp_pi.
- **nb_connection** (int) - Required - The maximum number of incoming connections to listen for.

### Return Value
Returns a new socket descriptor if successful. Returns -1 and sets errno on failure.
```

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

### Synopsis of modbus_new_tcp_pi

Source: https://github.com/stephane/libmodbus/blob/master/docs/modbus_new_tcp_pi.md

Function signature for allocating and initializing a libmodbus TCP context.

```c
modbus_t *modbus_new_tcp_pi(const char *node, const char *service);
```

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

### Function Synopsis

Source: https://github.com/stephane/libmodbus/blob/master/docs/modbus_tcp_pi_listen.md

The function signature for creating and listening on a TCP PI Modbus socket.

```c
int modbus_tcp_pi_listen(modbus_t *ctx, int nb_connection);
```

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

### uint8_t modbus_get_byte_from_bits(const uint8_t *src, int index, unsigned int nb_bits)

Source: https://github.com/stephane/libmodbus/blob/master/docs/modbus_get_byte_from_bits.md

Extracts a value from a sequence of bits starting at a specific index.

```APIDOC
## modbus_get_byte_from_bits

### Description
The modbus_get_byte_from_bits function extracts a value from multiple bits. It reads `nb_bits` from the `src` array starting at the specified `index` and returns them as a single byte.

### Signature
`uint8_t modbus_get_byte_from_bits(const uint8_t *src, int index, unsigned int nb_bits);`

### Parameters
- **src** (const uint8_t *) - The source array containing the bits.
- **index** (int) - The starting position in the source array.
- **nb_bits** (unsigned int) - The number of bits to read. Set to 8 to obtain a full byte.

### Return Value
Returns a byte containing the bits read.
```

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

### Synopsis of modbus_mapping_new

Source: https://github.com/stephane/libmodbus/blob/master/docs/modbus_mapping_new.md

Function signature for allocating Modbus mapping structures.

```c
modbus_mapping_t* modbus_mapping_new(int nb_bits, int nb_input_bits, int nb_registers, int nb_input_registers);
```

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

### int modbus_tcp_listen(modbus_t *ctx, int nb_connection)

Source: https://github.com/stephane/libmodbus/blob/master/docs/modbus_tcp_listen.md

Creates a socket and listens for up to nb_connection incoming connections on the IP address specified in the context.

```APIDOC
## int modbus_tcp_listen(modbus_t *ctx, int nb_connection)

### Description
The modbus_tcp_listen() function creates a socket and listens to a maximum of nb_connection incoming connections on the specified IP address. The context ctx must be initialized with modbus_new_tcp before calling this function.

### Parameters
- **ctx** (modbus_t *) - Required - The Modbus context initialized with modbus_new_tcp.
- **nb_connection** (int) - Required - The maximum number of incoming connections to listen for.

### Return Value
Returns a new socket descriptor if successful. Returns -1 on failure and sets errno.
```

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

### Enable Modbus quirks

Source: https://github.com/stephane/libmodbus/blob/master/docs/modbus_enable_quirks.md

Use this function to apply specific workarounds for non-standard Modbus device behavior.

```c
int modbus_enable_quirks(modbus_t *ctx, unsigned int quirks_mask);
```

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

### int modbus_read_input_bits(modbus_t *ctx, int addr, int nb, uint8_t *dest)

Source: https://github.com/stephane/libmodbus/blob/master/docs/modbus_read_input_bits.md

Reads the content of nb input bits starting at address addr from the remote device.

```APIDOC
## int modbus_read_input_bits(modbus_t *ctx, int addr, int nb, uint8_t *dest)

### Description
The modbus_read_input_bits function reads the content of the `nb` input bits starting at address `addr` of the remote device. The result is stored in the `dest` array as unsigned bytes set to TRUE or FALSE.

### Parameters
- **ctx** (modbus_t *) - Required - The Modbus context.
- **addr** (int) - Required - The starting address of the input bits.
- **nb** (int) - Required - The number of input bits to read.
- **dest** (uint8_t *) - Required - The destination array to store the results. Must be allocated with at least `nb * sizeof(uint8_t)` bytes.

### Return Value
Returns the number of read input status if successful. Returns -1 on failure and sets errno.

### Errors
- **EINVAL**: The `ctx` or `dest` argument is NULL, or `nb` is less than 1.
- **EMBXILVAL**: Too many discrete inputs requested (nb > MODBUS_MAX_READ_BITS).
```

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

### modbus_new_rtu

Source: https://github.com/stephane/libmodbus/blob/master/docs/modbus_new_rtu.md

Initializes a new libmodbus context for RTU communication.

```APIDOC
## modbus_new_rtu(const char *device, int baud, char parity, int data_bit, int stop_bit)

### Description
Allocates and initializes a modbus_t structure to communicate in RTU mode on a serial line.

### Parameters
- **device** (const char *) - Required - The name of the serial port (e.g., "/dev/ttyS0").
- **baud** (int) - Required - The baud rate of the communication (e.g., 9600, 115200).
- **parity** (char) - Required - Parity setting: 'N' (none), 'E' (even), or 'O' (odd).
- **data_bit** (int) - Required - Number of data bits (5, 6, 7, or 8).
- **stop_bit** (int) - Required - Number of stop bits (1 or 2).

### Return Value
Returns a pointer to a modbus_t structure on success, or NULL on failure with errno set.

### Errors
- **EINVAL**: Invalid argument provided.
- **ENOMEM**: Out of memory.
```

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

### int modbus_read_input_registers(modbus_t *ctx, int addr, int nb, uint16_t *dest)

Source: https://github.com/stephane/libmodbus/blob/master/docs/modbus_read_input_registers.md

Reads the content of nb input registers starting at address addr from the remote device.

```APIDOC
## int modbus_read_input_registers(modbus_t *ctx, int addr, int nb, uint16_t *dest)

### Description
Reads the content of `nb` input registers starting at address `addr` of the remote device. The result is stored in the `dest` array as 16-bit word values.

### Parameters
- **ctx** (modbus_t *) - Required - The Modbus context.
- **addr** (int) - Required - The starting address of the input registers.
- **nb** (int) - Required - The number of registers to read.
- **dest** (uint16_t *) - Required - The destination array to store the read values. Must be allocated with at least `nb * sizeof(uint16_t)` bytes.

### Return Value
Returns the number of read input registers if successful. Returns -1 and sets errno on failure.

### Errors
- **EINVAL**: The `ctx` or `dest` argument is NULL, or `nb` is less than 1.
- **EMBXILVAL**: Too many input registers requested (nb > MODBUS_MAX_READ_REGISTERS).
```

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

### Synopsis of modbus_new_tcp

Source: https://github.com/stephane/libmodbus/blob/master/docs/modbus_new_tcp.md

The function signature for creating a new TCP Modbus context.

```c
modbus_t *modbus_new_tcp(const char *ip, int port);
```

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

### int modbus_read_registers(modbus_t *ctx, int addr, int nb, uint16_t *dest)

Source: https://github.com/stephane/libmodbus/blob/master/docs/modbus_read_registers.md

Reads the content of nb holding registers starting at address addr from the remote device and stores them in the dest array.

```APIDOC
## int modbus_read_registers(modbus_t *ctx, int addr, int nb, uint16_t *dest)

### Description
The modbus_read_registers function reads the content of the nb holding registers starting at address addr of the remote device. The result is stored in the dest array as 16-bit word values.

### Parameters
- **ctx** (modbus_t *) - Required - The Modbus context pointer.
- **addr** (int) - Required - The starting address of the registers to read.
- **nb** (int) - Required - The number of registers to read.
- **dest** (uint16_t *) - Required - The destination array to store the read register values. Must be allocated with at least nb * sizeof(uint16_t) bytes.

### Return Value
Returns the number of read registers if successful. Returns -1 and sets errno on failure.

### Errors
- **EINVAL**: The ctx or dest argument is NULL, or nb is less than 1.
- **EMBXILVAL**: Too many registers requested (nb > MODBUS_MAX_READ_REGISTERS).
```

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

### Synopsis of modbus_set_response_timeout

Source: https://github.com/stephane/libmodbus/blob/master/docs/modbus_set_response_timeout.md

Function signature for setting the response timeout in libmodbus.

```c
int modbus_set_response_timeout(modbus_t *ctx, uint32_t to_sec, uint32_t to_usec);
```

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

### int modbus_read_bits(modbus_t *ctx, int addr, int nb, uint8_t *dest)

Source: https://github.com/stephane/libmodbus/blob/master/docs/modbus_read_bits.md

Reads the status of 'nb' bits starting at address 'addr' from the remote device and stores the result in the 'dest' array.

```APIDOC
## int modbus_read_bits(modbus_t *ctx, int addr, int nb, uint8_t *dest)

### Description
The modbus_read_bits function reads the status of 'nb' bits (coils) starting at address 'addr' of the remote device. The result is stored in the 'dest' array as unsigned bytes set to TRUE or FALSE.

### Parameters
- **ctx** (modbus_t *) - Required - The Modbus context.
- **addr** (int) - Required - The starting address of the coils to read.
- **nb** (int) - Required - The number of bits to read.
- **dest** (uint8_t *) - Required - The destination array to store the results. Must be allocated with at least 'nb' bytes.

### Return Value
Returns the number of read bits if successful. Returns -1 and sets errno on failure.

### Errors
- **EINVAL**: The ctx or dest argument is NULL, or nb is less than 1.
- **EMBXILVAL**: Too many bits requested (nb > MODBUS_MAX_READ_BITS).
```

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

### Synopsis of modbus_set_socket

Source: https://github.com/stephane/libmodbus/blob/master/docs/modbus_set_socket.md

The function signature for setting the socket in a libmodbus context.

```c
int modbus_set_socket(modbus_t *ctx, int s);
```

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

### modbus_new_rtu function signature

Source: https://github.com/stephane/libmodbus/blob/master/docs/modbus_new_rtu.md

The function prototype for initializing an RTU context.

```c
modbus_t *modbus_new_rtu(const char *device, int baud, char parity, int data_bit, int stop_bit);
```

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

### Synopsis of modbus_get_response_timeout

Source: https://github.com/stephane/libmodbus/blob/master/docs/modbus_get_response_timeout.md

Function signature for retrieving the response timeout.

```c
int modbus_get_response_timeout(modbus_t *ctx, uint32_t *to_sec, uint32_t *to_usec);
```

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

### Synopsis of modbus_receive_confirmation

Source: https://github.com/stephane/libmodbus/blob/master/docs/modbus_receive_confirmation.md

Function signature for receiving a confirmation request.

```c
int modbus_receive_confirmation(modbus_t *ctx, uint8_t *rsp);
```

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

### int modbus_receive(modbus_t *ctx, uint8_t *req)

Source: https://github.com/stephane/libmodbus/blob/master/docs/modbus_receive.md

Receives an indication request from the socket of the provided context.

```APIDOC
## int modbus_receive(modbus_t *ctx, uint8_t *req)

### Description
The modbus_receive() function receives an indication request from the socket of the context `ctx`. This function is used by a Modbus slave/server to receive and analyze indication requests sent by masters/clients.

### Parameters
- **ctx** (modbus_t *) - Required - The Modbus context.
- **req** (uint8_t *) - Required - A buffer to store the received indication request. The buffer must be at least `MODBUS_MAX_ADU_LENGTH` bytes to ensure compatibility across backends.

### Return Value
Returns the request length if successful (can be 0 if the request is ignored). Returns -1 on failure and sets errno.
```

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

### int modbus_tcp_pi_accept(modbus_t *ctx, int *s)

Source: https://github.com/stephane/libmodbus/blob/master/docs/modbus_tcp_pi_accept.md

Accepts a new connection on a TCP PI Modbus socket. If available, it utilizes accept4 with SOCK_CLOEXEC for improved security.

```APIDOC
## int modbus_tcp_pi_accept(modbus_t *ctx, int *s)

### Description
The modbus_tcp_pi_accept function extracts the first connection on the queue of pending connections, creates a new socket, and stores it in the libmodbus context provided. It supports IPv6 and uses accept4 with SOCK_CLOEXEC if available.

### Parameters
- **ctx** (modbus_t*) - Required - The libmodbus context.
- **s** (int*) - Required - Pointer to the socket descriptor to be updated with the new connection.

### Return Value
- **int** - Returns the new socket descriptor on success, or -1 on failure (with errno set).
```

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

### modbus_send_raw_request Synopsis

Source: https://github.com/stephane/libmodbus/blob/master/docs/modbus_send_raw_request.md

Function signature for sending a raw request.

```c
int modbus_send_raw_request(modbus_t *ctx, const uint8_t *raw_req, int raw_req_length);
```

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

### Synopsis of modbus_receive

Source: https://github.com/stephane/libmodbus/blob/master/docs/modbus_receive.md

Function signature for receiving an indication request.

```c
int modbus_receive(modbus_t *ctx, uint8_t *req);
```

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

### int modbus_proxy(modbus_t *frontend_ctx, modbus_t *backend_ctx, const uint8_t *req, int req_length)

Source: https://github.com/stephane/libmodbus/blob/master/docs/modbus_proxy.md

Forwards a Modbus request received on frontend_ctx to a device connected through backend_ctx, and relays the response back to the original requester.

```APIDOC
## int modbus_proxy(modbus_t *frontend_ctx, modbus_t *backend_ctx, const uint8_t *req, int req_length)

### Description
The modbus_proxy function forwards a Modbus request received on frontend_ctx to a device connected through backend_ctx, and relays the response back to the original requester on frontend_ctx. It handles protocol translation and transaction identifier preservation automatically.

### Parameters
- **frontend_ctx** (modbus_t *) - Required - The frontend Modbus context.
- **backend_ctx** (modbus_t *) - Required - The backend Modbus context.
- **req** (const uint8_t *) - Required - The raw request buffer.
- **req_length** (int) - Required - The length of the request buffer.

### Return Value
Returns the length of the response sent on frontend_ctx if successful. Returns -1 and sets errno on failure.

### Errors
- **EINVAL**: frontend_ctx or backend_ctx is NULL, or req is NULL, or req_length is less than 1.
- **EMBBADDATA**: The PDU extracted from the request is invalid.
```

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

### void modbus_set_bits_from_bytes(uint8_t *dest, int index, unsigned int nb_bits, const uint8_t *tab_byte)

Source: https://github.com/stephane/libmodbus/blob/master/docs/modbus_set_bits_from_bytes.md

Sets multiple bits in a destination array by reading from an array of bytes.

```APIDOC
## void modbus_set_bits_from_bytes(uint8_t *dest, int index, unsigned int nb_bits, const uint8_t *tab_byte)

### Description
The modbus_set_bits_from_bytes function sets bits by reading an array of bytes. All the bits of the bytes read from the first position of the array `tab_byte` are written as bits in the `dest` array starting at position `index`.

### Parameters
- **dest** (uint8_t *) - The destination array where bits will be set.
- **index** (int) - The starting position in the `dest` array.
- **nb_bits** (unsigned int) - The number of bits to set.
- **tab_byte** (const uint8_t *) - The source array of bytes.

### Return Value
This function does not return a value.
```

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

### int modbus_report_slave_id(modbus_t *ctx, int max_dest, uint8_t *dest)

Source: https://github.com/stephane/libmodbus/blob/master/docs/modbus_report_slave_id.md

Sends a request to the controller to obtain a description of the controller and stores the response in the provided buffer.

```APIDOC
## int modbus_report_slave_id(modbus_t *ctx, int max_dest, uint8_t *dest)

### Description
The modbus_report_slave_id function sends a request to the controller to obtain a description of the controller. The response includes the slave ID, run indicator status, and additional controller-specific data.

### Parameters
- **ctx** (modbus_t *) - Required - The Modbus context.
- **max_dest** (int) - Required - The maximum number of bytes to write to the destination buffer.
- **dest** (uint8_t *) - Required - The buffer where the response data will be stored.

### Return Value
Returns the number of bytes read if successful. If the output was truncated, returns the number of bytes that would have been written. Returns -1 on failure and sets errno.

### Errors
- **EINVAL**: The context is NULL, dest is NULL, or max_dest is not positive.
```

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

### void modbus_set_indication_timeout(modbus_t *ctx, uint32_t to_sec, uint32_t to_usec)

Source: https://github.com/stephane/libmodbus/blob/master/docs/modbus_set_indication_timeout.md

Sets the timeout interval used by a server to wait for a request from a client.

```APIDOC
## void modbus_set_indication_timeout(modbus_t *ctx, uint32_t to_sec, uint32_t to_usec)

### Description
The modbus_set_indication_timeout function sets the timeout interval used by a server to wait for a request from a client. If both to_sec and to_usec are zero, the server will wait indefinitely.

### Parameters
- **ctx** (modbus_t *) - Required - The pointer to the modbus context.
- **to_sec** (uint32_t) - Required - The timeout interval in seconds.
- **to_usec** (uint32_t) - Required - The timeout interval in microseconds (must be in the range 0 to 999999).

### Return Value
Returns 0 on success. On failure, returns -1 and sets errno.

### Errors
- **EINVAL**: The argument ctx is NULL or to_usec is larger than 1000000.
```

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

### modbus_reply_exception function signature

Source: https://github.com/stephane/libmodbus/blob/master/docs/modbus_reply_exception.md

The function requires a modbus context, the original request buffer, and a specific exception code constant.

```c
int modbus_reply_exception(modbus_t *ctx, const uint8_t *req, unsigned int exception_code);
```

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

### void modbus_close(modbus_t *ctx)

Source: https://github.com/stephane/libmodbus/blob/master/docs/modbus_close.md

Closes the connection established with the backend set in the provided modbus_t context.

```APIDOC
## void modbus_close(modbus_t *ctx)

### Description
The modbus_close() function closes the connection established with the backend set in the context.

### Parameters
- **ctx** (modbus_t*) - Required - The pointer to the modbus_t context to be closed.

### Return Value
This function does not return a value.
```

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

### Retrieve header length in C

Source: https://github.com/stephane/libmodbus/blob/master/docs/modbus_get_header_length.md

Function signature for retrieving the header length from a modbus context.

```c
int modbus_get_header_length(modbus_t *ctx);
```

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

### modbus_tcp_pi_accept function signature

Source: https://github.com/stephane/libmodbus/blob/master/docs/modbus_tcp_pi_accept.md

The function signature for modbus_tcp_pi_accept.

```c
int modbus_tcp_pi_accept(modbus_t *ctx, int *s);
```

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

### int modbus_tcp_accept(modbus_t *ctx, int *s)

Source: https://github.com/stephane/libmodbus/blob/master/docs/modbus_tcp_accept.md

Accepts a new connection on a TCP Modbus socket (IPv4).

```APIDOC
## int modbus_tcp_accept(modbus_t *ctx, int *s)

### Description
The modbus_tcp_accept() function extracts the first connection on the queue of pending connections, creates a new socket, and stores it in the libmodbus context provided. If available, it utilizes accept4() with SOCK_CLOEXEC.

### Parameters
- **ctx** (modbus_t *) - Required - The libmodbus context.
- **s** (int *) - Required - Pointer to store the new socket descriptor.

### Return Value
Returns the new socket descriptor on success. Returns -1 on failure and sets errno.
```

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

### Write a single register in C

Source: https://github.com/stephane/libmodbus/blob/master/docs/modbus_write_register.md

Use this function to write a single holding register to a remote device. It returns 1 on success or -1 on failure with errno set.

```c
int modbus_write_register(modbus_t *ctx, int addr, const uint16_t value);
```

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

### int modbus_rtu_get_rts(modbus_t *ctx)

Source: https://github.com/stephane/libmodbus/blob/master/docs/modbus_rtu_get_rts.md

Retrieves the current RTS mode for the specified RTU context.

```APIDOC
## int modbus_rtu_get_rts(modbus_t *ctx)

### Description
The modbus_rtu_get_rts() function retrieves the current Request To Send (RTS) mode of the libmodbus context `ctx`. This function is only applicable for contexts using an RTU backend.

### Parameters
- **ctx** (modbus_t*) - Required - The libmodbus context initialized with an RTU backend.

### Return Value
Returns the current RTS mode if successful. Possible values include:
- MODBUS_RTU_RTS_NONE
- MODBUS_RTU_RTS_UP
- MODBUS_RTU_RTS_DOWN

Returns -1 on failure and sets errno.

### Errors
- **EINVAL** - The libmodbus backend is not RTU.
```

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

### int modbus_receive_confirmation(modbus_t *ctx, uint8_t *rsp)

Source: https://github.com/stephane/libmodbus/blob/master/docs/modbus_receive_confirmation.md

Receives a request via the socket of the context. This function is intended for debugging or receiving requests not handled by the library.

```APIDOC
## int modbus_receive_confirmation(modbus_t *ctx, uint8_t *rsp)

### Description
The modbus_receive_confirmation() function receives a request via the socket of the context `ctx`. It is intended for debugging purposes as the received response is not checked against the initial request.

### Parameters
- **ctx** (modbus_t *) - Required - The pointer to the modbus context.
- **rsp** (uint8_t *) - Required - The array to store the received request. Must be large enough to hold the response (e.g., MODBUS_MAX_ADU_LENGTH).

### Return Value
Returns the response length if successful. Returns 0 if the request is ignored. Returns -1 on failure and sets errno.
```

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

### int modbus_reply(modbus_t *ctx, const uint8_t *req, int req_length, modbus_mapping_t *mb_mapping)

Source: https://github.com/stephane/libmodbus/blob/master/docs/modbus_reply.md

Sends a response to a received Modbus request. The function analyzes the request, performs the read/write operation on the mapping, and sends the response or an exception if an error occurs.

```APIDOC
## int modbus_reply(modbus_t *ctx, const uint8_t *req, int req_length, modbus_mapping_t *mb_mapping)

### Description
Sends a response to a received Modbus request. This function is designed for use by Modbus servers to process incoming requests and update the provided modbus_mapping_t.

### Parameters
- **ctx** (modbus_t *) - The modbus context.
- **req** (const uint8_t *) - The received request buffer.
- **req_length** (int) - The length of the received request.
- **mb_mapping** (modbus_mapping_t *) - The modbus mapping containing the data to be manipulated.

### Return Value
Returns the length of the response sent on success. Returns -1 on failure and sets errno.
```

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

### modbus_rtu_set_rts Synopsis

Source: https://github.com/stephane/libmodbus/blob/master/docs/modbus_rtu_set_rts.md

Function signature for setting the RTS mode in an RTU context.

```c
int modbus_rtu_set_rts(modbus_t *ctx, int mode)
```

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

### Set RTS delay in RTU

Source: https://github.com/stephane/libmodbus/blob/master/docs/modbus_rtu_set_rts_delay.md

Sets the RTS delay period for a libmodbus context using the RTU backend.

```c
int modbus_rtu_set_rts_delay(modbus_t *ctx, int us);
```
Tokens:
Raw