### Simple RTU Client Setup

Source: https://github.com/arduino-libraries/arduinomodbus/blob/master/_autodocs/configuration.md

Example of setting up an Arduino as an RTU Modbus client. Includes serial communication and timeout configuration.

```cpp
// RTU_CLIENT.ino
#include <ArduinoRS485.h>
#include <ArduinoModbus.h>

void setup() {
  Serial.begin(9600);
  ModbusRTUClient.begin(9600, SERIAL_8N1);
  ModbusRTUClient.setTimeout(2000);
}

void loop() {
  long temp = ModbusRTUClient.holdingRegisterRead(1, 100);
  if (temp >= 0) {
    Serial.println(temp);
  }
  delay(1000);
}
```

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

### Simple RTU Server Setup

Source: https://github.com/arduino-libraries/arduinomodbus/blob/master/_autodocs/configuration.md

Example of setting up an Arduino as an RTU Modbus server. Configures holding registers and polls for incoming requests.

```cpp
// RTU_SERVER.ino
#include <ArduinoRS485.h>
#include <ArduinoModbus.h>

void setup() {
  Serial.begin(9600);
  ModbusRTUServer.begin(1, 9600, SERIAL_8N1);
  ModbusRTUServer.configureHoldingRegisters(0, 200);
}

void loop() {
  int temp = analogRead(A0);
  ModbusRTUServer.holdingRegisterWrite(100, temp);
  ModbusRTUServer.poll();
}
```

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

### Example Modbus RTU Server Setup and Usage

Source: https://github.com/arduino-libraries/arduinomodbus/blob/master/_autodocs/api-reference/modbus-server.md

Demonstrates how to initialize a Modbus RTU server, configure its memory areas, and handle client requests within the main loop. This includes reading sensor data and controlling an LED via coils.

```cpp
#include <ArduinoRS485.h>
#include <ArduinoModbus.h>

void setup() {
  Serial.begin(9600);
  
  // Start the Modbus RTU server with ID 1
  if (!ModbusRTUServer.begin(1, 9600)) {
    Serial.println("Failed to start Modbus RTU Server!");
    while (1);
  }
  
  // Configure memory areas
  ModbusRTUServer.configureCoils(0, 8);
  ModbusRTUServer.configureDiscreteInputs(0, 8);
  ModbusRTUServer.configureHoldingRegisters(0, 100);
  ModbusRTUServer.configureInputRegisters(0, 50);
  
  Serial.println("Modbus RTU Server started");
}

void loop() {
  // Read analog sensor and publish as input register
  int sensorValue = analogRead(A0);
  ModbusRTUServer.inputRegisterWrite(0, sensorValue);
  
  // Poll for requests
  if (ModbusRTUServer.poll()) {
    // Request was processed by the poll method
    
    // Read and respond to coil writes from clients
    int coilValue = ModbusRTUServer.coilRead(0);
    if (coilValue == 1) {
      digitalWrite(LED_PIN, HIGH);
    } else {
      digitalWrite(LED_PIN, LOW);
    }
  }
}
```

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

### Initialize ModbusTCPServer

Source: https://github.com/arduino-libraries/arduinomodbus/blob/master/_autodocs/api-reference/modbus-tcp-server.md

Initializes the Modbus TCP server. Call this in your setup() function. It returns false if the server fails to start.

```cpp
#include <ArduinoModbus.h>

ModbusTCPServer modbusServer;

void setup() {
  if (!modbusServer.begin()) {
    Serial.println("Failed to start server");
  }
}
```

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

### Complete Modbus RTU Server Example

Source: https://github.com/arduino-libraries/arduinomodbus/blob/master/_autodocs/api-reference/modbus-rtu-server.md

This example demonstrates a complete Modbus RTU server setup. It configures coils, holding registers, and input registers, simulates sensor readings, publishes them as input registers, and processes client requests to modify holding registers.

```cpp
#include <ArduinoRS485.h>
#include <ArduinoModbus.h>

struct SensorData {
  uint16_t temperature;
  uint16_t humidity;
  uint16_t pressure;
};

SensorData sensors;

void setup() {
  Serial.begin(9600);
  
  if (!ModbusRTUServer.begin(1, 9600)) {
    while (1);
  }
  
  // Configure multiple register blocks
  ModbusRTUServer.configureCoils(0, 16);
  ModbusRTUServer.configureHoldingRegisters(0, 100);
  ModbusRTUServer.configureInputRegisters(0, 100);
}

void readSensors() {
  // Simulate sensor readings
  sensors.temperature = 2500;  // 25.00°C
  sensors.humidity = 6500;     // 65.00%
  sensors.pressure = 10100;    // 1010 hPa
}

void publishSensorData() {
  // Publish as input registers (client can only read)
  ModbusRTUServer.inputRegisterWrite(0, sensors.temperature);
  ModbusRTUServer.inputRegisterWrite(1, sensors.humidity);
  ModbusRTUServer.inputRegisterWrite(2, sensors.pressure);
}

void loop() {
  readSensors();
  publishSensorData();
  
  // Process client requests
  if (ModbusRTUServer.poll()) {
    // Check holding registers written by client
    long setTemp = ModbusRTUServer.holdingRegisterRead(0);
    Serial.print("Target temperature set to: ");
    Serial.println(setTemp);
  }
}
```

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

### ModbusTCPClient Initialization Example

Source: https://github.com/arduino-libraries/arduinomodbus/blob/master/_autodocs/api-reference/modbus-tcp-client.md

Demonstrates how to initialize the ModbusTCPClient with an EthernetClient and include necessary libraries.

```cpp
#include <Ethernet.h>
#include <ArduinoModbus.h>

EthernetClient ethClient;
ModbusTCPClient modbusTCPClient(ethClient);
```

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

### modbusTCPClient.begin()

Source: https://github.com/arduino-libraries/arduinomodbus/blob/master/docs/api.md

Start the Modbus TCP client with the specified parameters.

```APIDOC
## modbusTCPClient.begin()

### Description
Start the Modbus TCP client with the specified parameters.

### Syntax
```
modbusTCPClient.begin(ip, port);
```

### Parameters
- ip - the IP Address the client will connect to
- port - port to the client will connect to

### Returns
1 on success, 0 on failure
```

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

### Start Modbus TCP Client - modbusTCPClient.begin()

Source: https://github.com/arduino-libraries/arduinomodbus/blob/master/docs/api.md

Start the Modbus TCP client, connecting to the specified IP address and port.

```cpp
modbusTCPClient.begin(ip, port);
```

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

### Modbus RTU Client Initialization Example

Source: https://github.com/arduino-libraries/arduinomodbus/blob/master/_autodocs/api-reference/modbus-rtu-client.md

Example demonstrating how to initialize the Modbus RTU client with a baud rate of 9600. Includes error handling for failed initialization.

```cpp
#include <ArduinoRS485.h>
#include <ArduinoModbus.h>

void setup() {
  Serial.begin(9600);
  
  // Initialize RTU client at 9600 baud
  if (!ModbusRTUClient.begin(9600)) {
    Serial.println("Failed to start Modbus RTU Client!");
    while (1);
  }
  
  Serial.println("Modbus RTU Client started");
}
```

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

### Modbus TCP Server begin() with Ethernet

Source: https://github.com/arduino-libraries/arduinomodbus/blob/master/_autodocs/configuration.md

Configure a Modbus TCP server to listen for client connections using an Ethernet connection. This setup involves initializing Ethernet, starting a TCP server listener, and then starting the Modbus TCP server. Memory for coils and holding registers must be configured.

```cpp
#include <SPI.h>
#include <Ethernet.h>
#include <ArduinoModbus.h>

byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
IPAddress ip(192, 168, 1, 100);

EthernetServer ethServer(502);
ModbusTCPServer modbusServer;

void setup() {
  Serial.begin(9600);
  
  // Start Ethernet
  Ethernet.begin(mac, ip);
  delay(1000);
  
  // Start TCP server listener
  ethServer.begin();
  
  // Start Modbus TCP server
  if (!modbusServer.begin()) {
    Serial.println("Failed to start Modbus TCP Server");
    while (1);
  }
  
  // Configure memory
  modbusServer.configureCoils(0, 16);
  modbusServer.configureHoldingRegisters(0, 100);
}

void loop() {
  // Check for incoming connections
  EthernetClient client = ethServer.available();
  if (client) {
    modbusServer.accept(client);
  }
  
  // Poll for requests
  modbusServer.poll();
}
```

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

### modbusTCPServer.begin()

Source: https://github.com/arduino-libraries/arduinomodbus/blob/master/docs/api.md

Starts the Modbus TCP server, optionally setting the slave ID.

```APIDOC
### modbusTCPServer.begin()

#### Description

Start the Modbus TCP server.

#### Syntax

```c
modbusTCPserver.begin();
modbusTCPserver.begin(id);
```

#### Parameters
- id - the (slave) id of the server, defaults to 0xff (TCP);


#### Returns
1 on success, 0 on failure
```

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

### Example: Calculate Post-delay for 9600 Baud

Source: https://github.com/arduino-libraries/arduinomodbus/blob/master/_autodocs/api-reference/modbus-rtu-delay.md

Demonstrates how to calculate the post-transmission delay for a 9600 baud rate, which is the same as the pre-delay.

```cpp
unsigned long delay = ModbusRTUDelay::postDelay(9600);
// Returns approximately 3,680 microseconds (same as preDelay)
```

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

### Custom RS485 Constructor Example

Source: https://github.com/arduino-libraries/arduinomodbus/blob/master/_autodocs/api-reference/modbus-rtu-server.md

Shows how to instantiate ModbusRTUServerClass with a custom RS485 hardware instance.

```cpp
#include <ArduinoRS485.h>
#include <ArduinoModbus.h>

ModbusRTUServerClass customServer(RS485);
```

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

### ModbusRTUClient.begin()

Source: https://github.com/arduino-libraries/arduinomodbus/blob/master/docs/api.md

Start the Modbus RTU client with the specified parameters.

```APIDOC
## ModbusRTUClient.begin()

### Description
Start the Modbus RTU client with the specified parameters.

### Syntax
```
ModbusRTUClient.begin(baudrate);
ModbusRTUClient.begin(baudrate, config);
```

### Parameters
- baudrate - Baud rate to use for serial
- config - Config to use for serial (see Serial.begin(...) for more info.) defaults to SERIAL_8N1 if not provided

### Returns
1 on success, 0 on failure
```

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

### Ethernet TCP Client Setup

Source: https://github.com/arduino-libraries/arduinomodbus/blob/master/_autodocs/configuration.md

Example of setting up an Arduino as an Ethernet TCP Modbus client. Connects to a Modbus TCP server and reads holding registers.

```cpp
// TCP_CLIENT.ino
#include <SPI.h>
#include <Ethernet.h>
#include <ArduinoModbus.h>

byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
IPAddress ip(192, 168, 1, 10);
IPAddress serverIP(192, 168, 1, 100);

EthernetClient client;
ModbusTCPClient modbusClient(client);

void setup() {
  Ethernet.begin(mac, ip);
  modbusClient.begin(serverIP, 502);
}

void loop() {
  if (!modbusClient.connected()) {
    modbusClient.begin(serverIP, 502);
  } else {
    long value = modbusClient.holdingRegisterRead(0);
  }
  delay(1000);
}
```

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

### Start Modbus RTU Client - modbusRTUClient.begin()

Source: https://github.com/arduino-libraries/arduinomodbus/blob/master/docs/api.md

Start the Modbus RTU client with the specified baud rate and optional serial configuration.

```cpp
ModbusRTUClient.begin(baudrate);
ModbusRTUClient.begin(baudrate, config);
```

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

### Ethernet TCP Server Setup

Source: https://github.com/arduino-libraries/arduinomodbus/blob/master/_autodocs/configuration.md

Example of setting up an Arduino as an Ethernet TCP Modbus server. Listens for incoming TCP connections and handles Modbus requests.

```cpp
// TCP_SERVER.ino
#include <SPI.h>
#include <Ethernet.h>
#include <ArduinoModbus.h>

byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
IPAddress ip(192, 168, 1, 100);

EthernetServer server(502);
ModbusTCPServer modbusServer;

void setup() {
  Ethernet.begin(mac, ip);
  server.begin();
  modbusServer.begin();
  modbusServer.configureHoldingRegisters(0, 100);
}

void loop() {
  EthernetClient client = server.available();
  if (client) {
    modbusServer.accept(client);
  }
  modbusServer.poll();
}
```

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

### WiFi-Based Modbus TCP Server Setup

Source: https://github.com/arduino-libraries/arduinomodbus/blob/master/_autodocs/api-reference/modbus-tcp-server.md

This snippet demonstrates how to set up a Modbus TCP server over WiFi. It includes connecting to a WiFi network, starting the WiFi server, and initializing the Modbus TCP server with holding and input registers. Ensure you replace 'YourSSID' and 'YourPassword' with your actual WiFi credentials.

```cpp
#include <WiFi.h>
#include <ArduinoRS485.h>
#include <ArduinoModbus.h>

const char* ssid = "YourSSID";
const char* password = "YourPassword";

WiFiServer wifiServer(502);
ModbusTCPServer modbusServer;

void setup() {
  Serial.begin(9600);
  while (!Serial);
  
  // Connect to WiFi
  Serial.println("Connecting to WiFi...");
  WiFi.begin(ssid, password);
  
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  
  Serial.println("\nWiFi connected");
  Serial.print("IP address: ");
  Serial.println(WiFi.localIP());
  
  // Start WiFi server listener
  wifiServer.begin();
  
  // Start Modbus TCP server
  if (!modbusServer.begin()) {
    Serial.println("Failed to start Modbus TCP Server!");
    while (1);
  }
  
  modbusServer.configureHoldingRegisters(0, 100);
  modbusServer.configureInputRegisters(0, 50);
  
  Serial.println("Modbus TCP Server ready");
}

void loop() {
  // Check for incoming WiFi connections
  WiFiClient client = wifiServer.available();
  
  if (client) {
    Serial.println("WiFi client connected");
    modbusServer.accept(client);
  }
  
  // Update sensor data
  int temp = readTemperatureSensor();
  modbusServer.inputRegisterWrite(0, temp);
  
  // Process Modbus requests
  modbusServer.poll();
}

int readTemperatureSensor() {
  // Simulate temperature sensor
  return 2500;  // 25.00°C
}

```

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

### Example: Calculate Pre-delay for 9600 Baud

Source: https://github.com/arduino-libraries/arduinomodbus/blob/master/_autodocs/api-reference/modbus-rtu-delay.md

Demonstrates how to calculate the pre-transmission delay for a 9600 baud rate, returning approximately 3680 microseconds.

```cpp
unsigned long delay = ModbusRTUDelay::preDelay(9600);
// Returns approximately 3,680 microseconds (3.68 ms)
```

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

### Modbus TCP Client Usage Example

Source: https://github.com/arduino-libraries/arduinomodbus/blob/master/_autodocs/api-reference/modbus-tcp-client.md

This example demonstrates how to initialize the Ethernet connection, connect to a Modbus TCP server, read a holding register, and write to a coil. It includes error handling for connection and read/write operations. Ensure you have the necessary libraries (SPI, Ethernet, ArduinoRS485, ArduinoModbus) included.

```cpp
#include <SPI.h>
#include <Ethernet.h>
#include <ArduinoRS485.h>
#include <ArduinoModbus.h>

byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
IPAddress ip(192, 168, 1, 177);
IPAddress serverIP(192, 168, 1, 100);

EthernetClient ethClient;
ModbusTCPClient modbusTCPClient(ethClient);

void setup() {
  Serial.begin(9600);
  while (!Serial);
  
  // Initialize Ethernet
  Ethernet.begin(mac, ip);
  delay(1000);
  
  Serial.println("Attempting to connect to Modbus TCP server");
}

void loop() {
  if (!modbusTCPClient.connected()) {
    // Client not connected, attempt to connect
    if (modbusTCPClient.begin(serverIP, 502)) {
      Serial.println("Connected to Modbus TCP server");
    } else {
      Serial.println("Failed to connect, retrying...");
      delay(1000);
      return;
    }
  }
  
  // Read holding register at address 100 from unit 1
  long value = modbusTCPClient.holdingRegisterRead(1, 100);
  if (value >= 0) {
    Serial.print("Value: ");
    Serial.println(value);
  } else {
    Serial.print("Read error: ");
    Serial.println(modbusTCPClient.lastError());
    modbusTCPClient.stop();
  }
  
  delay(1000);
  
  // Write coil at address 0 for unit 1
  if (!modbusTCPClient.coilWrite(1, 0, 1)) {
    Serial.print("Write error: ");
    Serial.println(modbusTCPClient.lastError());
    modbusTCPClient.stop();
  }
  
  delay(1000);
}

```

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

### modbusRTUServer.begin()

Source: https://github.com/arduino-libraries/arduinomodbus/blob/master/docs/api.md

Starts the Modbus RTU server with the specified slave ID and baud rate, optionally configuring serial communication.

```APIDOC
## ModbusRTUServer Class

### modbusRTUServer.begin()

#### Description

Start the Modbus RTU server with the specified parameters.

#### Syntax

```c
ModbusRTUServer.begin(id, baudrate);
ModbusRTUServer.begin(id, baudrate, config);
```

#### Parameters
- id - (slave) id of the server baudrate - Baud rate to use for serial
- config - Config to use for serial (see Serial.begin(...) for more info.) defaults to SERIAL_8N1 if not provided


#### Returns
1 on success, 0 on failure
```

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

### Default Constructor Example

Source: https://github.com/arduino-libraries/arduinomodbus/blob/master/_autodocs/api-reference/modbus-rtu-server.md

Demonstrates the usage of the default constructor for ModbusRTUServerClass, which utilizes the global RS485 instance.

```cpp
#include <ArduinoModbus.h>

void setup() {
  // ModbusRTUServer uses the global RS485 instance
}
```

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

### Initialize ModbusRTUClient with Default RS485

Source: https://github.com/arduino-libraries/arduinomodbus/blob/master/_autodocs/api-reference/modbus-rtu-client.md

Example of setting up the ModbusRTUClient using the global RS485 instance. Ensure ArduinoModbus library is included.

```cpp
#include <ArduinoModbus.h>

void setup() {
  // ModbusRTUClient uses the global RS485 instance
}
```

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

### RTU Server Example

Source: https://github.com/arduino-libraries/arduinomodbus/blob/master/_autodocs/README.md

Initializes an RTU server and configures holding registers. Use this to create a Modbus RTU slave device.

```cpp
#include <ArduinoRS485.h>
#include <ArduinoModbus.h>

void setup() {
  Serial.begin(9600);
  
  // Initialize RTU server with ID 1
  if (!ModbusRTUServer.begin(1, 9600)) {
    Serial.println("Failed to start Modbus RTU Server!");
    while (1);
  }
  
  // Configure 100 holding registers starting at address 0
  ModbusRTUServer.configureHoldingRegisters(0, 100);
}

void loop() {
  // Poll for requests
  ModbusRTUServer.poll();
}
```

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

### Example: Calculate Pre-delay for 115200 Baud

Source: https://github.com/arduino-libraries/arduinomodbus/blob/master/_autodocs/api-reference/modbus-rtu-delay.md

Demonstrates how to calculate the pre-transmission delay for a 115200 baud rate, returning approximately 307 microseconds.

```cpp
unsigned long delay = ModbusRTUDelay::preDelay(115200);
// Returns approximately 307 microseconds (0.307 ms)
```

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

### Direct Usage Example

Source: https://github.com/arduino-libraries/arduinomodbus/blob/master/_autodocs/api-reference/modbus-rtu-delay.md

Demonstrates how to directly use the ModbusRTUDelay class to calculate and set RTU timing delays for the RS485 communication.

```APIDOC
## Direct Usage Example

```cpp
#include <ArduinoRS485.h>

void setup() {
  // Calculate delays for 9600 baud
  unsigned long preDelay = ModbusRTUDelay::preDelay(9600);
  unsigned long postDelay = ModbusRTUDelay::postDelay(9600);
  
  Serial.println(preDelay);   // ~3680
  Serial.println(postDelay);  // ~3680
  
  // Configure RS485 with calculated delays
  RS485.setDelays(preDelay, postDelay);
  RS485.begin(9600);
}
```
```

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

### Start Modbus TCP Server

Source: https://github.com/arduino-libraries/arduinomodbus/blob/master/docs/api.md

Starts the Modbus TCP server. An optional slave ID can be provided, defaulting to 0xff.

```cpp
modbusTCPserver.begin();
modbusTCPserver.begin(id);
```

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

### Start Modbus RTU Server

Source: https://github.com/arduino-libraries/arduinomodbus/blob/master/docs/api.md

Starts the Modbus RTU server with the specified ID and baud rate. An optional configuration parameter can be provided.

```cpp
ModbusRTUServer.begin(id, baudrate);
ModbusRTUServer.begin(id, baudrate, config);
```

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

### Configure Server Coils - modbusServer.configureCoils()

Source: https://github.com/arduino-libraries/arduinomodbus/blob/master/docs/api.md

Configure the server's coils, specifying the start address and number of coils.

```cpp
int configureCoils(int startAddress, int nb);
```

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

### ModbusTCPClient connected() Example

Source: https://github.com/arduino-libraries/arduinomodbus/blob/master/_autodocs/api-reference/modbus-tcp-client.md

Prints the connection status of the Modbus TCP client to the serial monitor.

```cpp
if (modbusTCPClient.connected()) {
  Serial.println("Modbus TCP client is connected");
} else {
  Serial.println("Modbus TCP client is disconnected");
}
```

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

### client.write()

Source: https://github.com/arduino-libraries/arduinomodbus/blob/master/docs/api.md

Set the values of a write operation started by beginTransmission(...).

```APIDOC
## client.write()

### Description
Set the values of a write operation started by beginTransmission(...).

### Syntax
```
int write(unsigned int value);
```

### Parameters
- value - value to write

### Returns
1 on success, 0 on failure
```

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

### Configure Server Discrete Inputs - modbusServer.configureDiscreteInputs()

Source: https://github.com/arduino-libraries/arduinomodbus/blob/master/docs/api.md

Configure the server's discrete inputs, specifying the start address and number of inputs.

```cpp
int configureDiscreteInputs(int startAddress, int nb);
```

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

### RTU Client Example

Source: https://github.com/arduino-libraries/arduinomodbus/blob/master/_autodocs/README.md

Initializes an RTU client and reads a holding register from a slave device. Use this to communicate with Modbus RTU slaves.

```cpp
#include <ArduinoRS485.h>
#include <ArduinoModbus.h>

void setup() {
  Serial.begin(9600);
  
  // Initialize RTU client at 9600 baud
  if (!ModbusRTUClient.begin(9600)) {
    Serial.println("Failed to start Modbus RTU Client!");
    while (1);
  }
}

void loop() {
  // Read holding register from slave 1, address 100
  long value = ModbusRTUClient.holdingRegisterRead(1, 100);
  
  if (value >= 0) {
    Serial.println(value);
  } else {
    Serial.println(ModbusRTUClient.lastError());
  }
  
  delay(1000);
}
```

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

### Direct Usage Example in Arduino

Source: https://github.com/arduino-libraries/arduinomodbus/blob/master/_autodocs/api-reference/modbus-rtu-delay.md

A complete Arduino sketch demonstrating direct usage of ModbusRTUDelay to calculate and set RS485 delays before initializing the serial communication.

```cpp
#include <ArduinoRS485.h>

void setup() {
  // Calculate delays for 9600 baud
  unsigned long preDelay = ModbusRTUDelay::preDelay(9600);
  unsigned long postDelay = ModbusRTUDelay::postDelay(9600);
  
  Serial.println(preDelay);   // ~3680
  Serial.println(postDelay);  // ~3680
  
  // Configure RS485 with calculated delays
  RS485.setDelays(preDelay, postDelay);
  RS485.begin(9600);
}
```

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

### Configure Server Input Registers - modbusServer.configureInputRegisters()

Source: https://github.com/arduino-libraries/arduinomodbus/blob/master/docs/api.md

Configure the server's input registers, specifying the start address and number of registers.

```cpp
int configureInputRegisters(int startAddress, int nb);
```

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

### Configure Server Holding Registers - modbusServer.configureHoldingRegisters()

Source: https://github.com/arduino-libraries/arduinomodbus/blob/master/docs/api.md

Configure the server's holding registers, specifying the start address and number of registers.

```cpp
int configureHoldingRegisters(int startAddress, int nb);
```

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

### TCP Server Example (Ethernet)

Source: https://github.com/arduino-libraries/arduinomodbus/blob/master/_autodocs/README.md

Initializes a Modbus TCP server using Ethernet and configures holding registers. Use this to create a Modbus TCP server accessible over Ethernet.

```cpp
#include <SPI.h>
#include <Ethernet.h>
#include <ArduinoModbus.h>

byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
IPAddress ip(192, 168, 1, 100);

EthernetServer server(502);
ModbusTCPServer modbusServer;

void setup() {
  Ethernet.begin(mac, ip);
  server.begin();
  
  modbusServer.begin();
  modbusServer.configureHoldingRegisters(0, 100);
}

void loop() {
  EthernetClient client = server.available();
  if (client) {
    modbusServer.accept(client);
  }
  
  modbusServer.poll();
}
```

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

### configureDiscreteInputs

Source: https://github.com/arduino-libraries/arduinomodbus/blob/master/_autodocs/api-reference/modbus-server.md

Configures the server's discrete input memory area. It allocates a specified number of discrete inputs starting from a given address.

```APIDOC
## configureDiscreteInputs

### Description
Configures the server's discrete input memory area. It allocates a specified number of discrete inputs starting from a given address.

### Method
int configureDiscreteInputs(int startAddress, int nb)

### Parameters
#### Path Parameters
- **startAddress** (int) - Yes - Starting address for discrete inputs
- **nb** (int) - Yes - Number of discrete inputs to allocate

### Returns
1 on success, 0 on failure

### Example
```cpp
// Configure 16 discrete inputs starting at address 0
ModbusRTUServer.configureDiscreteInputs(0, 16);
```
```

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

### TCP Client Example (Ethernet)

Source: https://github.com/arduino-libraries/arduinomodbus/blob/master/_autodocs/README.md

Initializes a Modbus TCP client using Ethernet and reads a holding register. Use this to connect to Modbus TCP servers over an Ethernet network.

```cpp
#include <SPI.h>
#include <Ethernet.h>
#include <ArduinoModbus.h>

byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
IPAddress serverIP(192, 168, 1, 100);

EthernetClient client;
ModbusTCPClient modbusClient(client);

void setup() {
  Ethernet.begin(mac);
  modbusClient.begin(serverIP, 502);
}

void loop() {
  if (modbusClient.connected()) {
    long value = modbusClient.holdingRegisterRead(0, 100);
    Serial.println(value);
  }
  delay(1000);
}
```

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

### Handling Multiple Modbus TCP Servers

Source: https://github.com/arduino-libraries/arduinomodbus/blob/master/_autodocs/api-reference/modbus-tcp-server.md

This example shows how to manage multiple Modbus TCP server instances simultaneously. Each server requires its own WiFi server instance and is initialized and polled independently. This is useful for applications needing to serve multiple clients or different Modbus configurations concurrently.

```cpp
ModbusTCPServer server1;
ModbusTCPServer server2;

WiFiServer wifiServer1(502);
WiFiServer wifiServer2(502);

void setup() {
  // Initialize both servers
  server1.begin();
  server2.begin();
  
  server1.configureHoldingRegisters(0, 100);
  server2.configureHoldingRegisters(0, 100);
}

void loop() {
  // Handle server 1
  WiFiClient client1 = wifiServer1.available();
  if (client1) {
    server1.accept(client1);
  }
  if (server1.poll()) {
    // Process server 1 request
  }
  
  // Handle server 2
  WiFiClient client2 = wifiServer2.available();
  if (client2) {
    server2.accept(client2);
  }
  if (server2.poll()) {
    // Process server 2 request
  }
}

```

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

### Modbus RTU Server Initialization and Operation

Source: https://github.com/arduino-libraries/arduinomodbus/blob/master/_autodocs/api-reference/modbus-rtu-server.md

Initializes the Modbus RTU server, configures data registers, and handles incoming Modbus requests. This example reads an analog sensor, a digital input, and controls an LED based on coil status.

```cpp
#include <ArduinoRS485.h>
#include <ArduinoModbus.h>

const int ledPin = LED_BUILTIN;
const int sensorPin = A0;

void setup() {
  Serial.begin(9600);
  while (!Serial);
  
  // Initialize RTU server with ID 1
  if (!ModbusRTUServer.begin(1, 9600)) {
    Serial.println("Failed to start Modbus RTU Server!");
    while (1);
  }
  
  // Configure coils (writable outputs)
  ModbusRTUServer.configureCoils(0, 8);
  
  // Configure discrete inputs (read-only inputs)
  ModbusRTUServer.configureDiscreteInputs(0, 8);
  
  // Configure holding registers (writable data)
  ModbusRTUServer.configureHoldingRegisters(0, 100);
  
  // Configure input registers (read-only sensor data)
  ModbusRTUServer.configureInputRegisters(0, 50);
  
  pinMode(ledPin, OUTPUT);
  digitalWrite(ledPin, LOW);
  
  Serial.println("Modbus RTU Server initialized");
}

void loop() {
  // Read analog sensor and publish as input register
  int sensorValue = analogRead(sensorPin);
  ModbusRTUServer.inputRegisterWrite(0, sensorValue);
  
  // Read digital sensor and publish as discrete input
  int digitalValue = digitalRead(2);
  ModbusRTUServer.discreteInputWrite(0, digitalValue ? 1 : 0);
  
  // Poll for Modbus requests
  if (ModbusRTUServer.poll()) {
    // A request has been processed
    
    // Check if a client has written to the coil
    int ledControl = ModbusRTUServer.coilRead(0);
    if (ledControl) {
      digitalWrite(ledPin, HIGH);
    } else {
      digitalWrite(ledPin, LOW);
    }
  }
}
```

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

### Basic Modbus TCP Server with Ethernet

Source: https://github.com/arduino-libraries/arduinomodbus/blob/master/_autodocs/api-reference/modbus-tcp-server.md

This snippet shows how to set up a Modbus TCP server on an Arduino using the Ethernet shield. It initializes the Ethernet connection, starts the TCP server, and configures Modbus data areas. It also includes logic to handle incoming client connections and poll for Modbus requests, including writing to a digital output based on a coil status.

```cpp
#include <SPI.h>
#include <Ethernet.h>
#include <ArduinoRS485.h>
#include <ArduinoModbus.h>

byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
IPAddress ip(192, 168, 1, 100);

EthernetServer ethServer(502);  // Modbus TCP port
ModbusTCPServer modbusServer;

void setup() {
  Serial.begin(9600);
  while (!Serial);
  
  // Start Ethernet
  Ethernet.begin(mac, ip);
  delay(1000);
  
  // Start TCP server socket listener
  ethServer.begin();
  
  // Start Modbus TCP server
  if (!modbusServer.begin()) {
    Serial.println("Failed to start Modbus TCP Server!");
    while (1);
  }
  
  // Configure data areas
  modbusServer.configureCoils(0, 16);
  modbusServer.configureDiscreteInputs(0, 16);
  modbusServer.configureHoldingRegisters(0, 100);
  modbusServer.configureInputRegisters(0, 50);
  
  Serial.print("Modbus TCP Server started at ");
  Serial.println(Ethernet.localIP());
}

void loop() {
  // Check for new incoming connections
  EthernetClient client = ethServer.available();
  
  if (client) {
    Serial.println("New client connection");
    modbusServer.accept(client);
  }
  
  // Read and publish sensor data
  int sensorValue = analogRead(A0);
  modbusServer.inputRegisterWrite(0, sensorValue);
  
  // Poll for Modbus requests
  if (modbusServer.poll()) {
    // Check if coil was written by client
    int coilValue = modbusServer.coilRead(0);
    if (coilValue == 1) {
      digitalWrite(LED_BUILTIN, HIGH);
    } else {
      digitalWrite(LED_BUILTIN, LOW);
    }
  }
}
```

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

### begin

Source: https://github.com/arduino-libraries/arduinomodbus/blob/master/_autodocs/api-reference/modbus-tcp-client.md

Initializes the Modbus TCP client connection to a server.

```APIDOC
## begin

### Description
Initialize the Modbus TCP client connection to a server.

### Method
`int begin(IPAddress ip, uint16_t port = 502)`

### Parameters
#### Path Parameters
- **ip** (IPAddress) - Required - IP address of the Modbus TCP server
- **port** (uint16_t) - Optional - Default: 502 - TCP port number (standard Modbus TCP port)

### Returns
1 on success, 0 on failure

### Request Example
```cpp
#include <Ethernet.h>
#include <ArduinoModbus.h>

EthernetClient ethClient;
ModbusTCPClient modbusTCPClient(ethClient);

void setup() {
  // Start Ethernet
  Ethernet.begin(mac, ip);
  
  IPAddress serverIP(192, 168, 1, 100);
  
  // Connect to Modbus TCP server at 192.168.1.100:502
  if (!modbusTCPClient.begin(serverIP)) {
    Serial.println("Failed to connect to Modbus TCP server");
  } else {
    Serial.println("Connected to Modbus TCP server");
  }
}
```
```

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

### write

Source: https://github.com/arduino-libraries/arduinomodbus/blob/master/_autodocs/api-reference/modbus-client.md

Sets a value within a write operation that was previously started by `beginTransmission()`.

```APIDOC
## write

### Description
Set a value in a write operation started by `beginTransmission()`.

### Method
```cpp
int write(unsigned int value);
```

### Parameters
#### Path Parameters
* **value** (unsigned int) - Required - Value to write.

### Returns
1 on success, 0 on failure.

### Example
```cpp
ModbusRTUClient.beginTransmission(COILS, 0, 8);
for (int i = 0; i < 8; i++) {
  ModbusRTUClient.write(i % 2);
}
ModbusRTUClient.endTransmission();
```
```

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

### begin

Source: https://github.com/arduino-libraries/arduinomodbus/blob/master/_autodocs/api-reference/modbus-rtu-server.md

Initializes the Modbus RTU server. It can be configured with a device ID, baud rate, and optional serial configuration. An overload allows specifying a custom RS485 hardware instance.

```APIDOC
## begin

### Description
Initialize the Modbus RTU server with a device ID and serial configuration.

### Method Overloads
```cpp
int begin(int id, unsigned long baudrate, uint16_t config = SERIAL_8N1);
int begin(RS485Class& rs485, int id, unsigned long baudrate, uint16_t config = SERIAL_8N1);
```

### Parameters
#### Overload 1: `begin(int id, unsigned long baudrate, uint16_t config)`
- **id** (int) - Required - Slave ID for this server (1-247)
- **baudrate** (unsigned long) - Required - Serial baud rate (e.g., 9600, 19200)
- **config** (uint16_t) - Optional - Serial configuration: data bits, parity, stop bits (Default: SERIAL_8N1)

#### Overload 2: `begin(RS485Class& rs485, int id, unsigned long baudrate, uint16_t config)`
- **rs485** (RS485Class&) - Optional - Custom RS485 hardware instance
- **id** (int) - Required - Slave ID for this server (1-247)
- **baudrate** (unsigned long) - Required - Serial baud rate (e.g., 9600, 19200)
- **config** (uint16_t) - Optional - Serial configuration: data bits, parity, stop bits (Default: SERIAL_8N1)

### Returns
- `1` on success
- `0` on failure

### Notes
- **Slave ID**: Valid range is 1 to 247. ID 0 is reserved for broadcast/global calls.
- **Supported Baud Rates**: 300, 600, 1200, 2400, 4800, 9600, 14400, 19200, 28800, 38400, 57600, 115200
- **Serial Configuration Values**:
  - `SERIAL_8N1`: 8 data bits, no parity, 1 stop bit (most common)
  - `SERIAL_8E1`: 8 data bits, even parity, 1 stop bit
  - `SERIAL_8O1`: 8 data bits, odd parity, 1 stop bit

### Example
```cpp
#include <ArduinoRS485.h>
#include <ArduinoModbus.h>

void setup() {
  Serial.begin(9600);
  while (!Serial);
  
  // Start RTU server with ID 1 at 9600 baud
  if (!ModbusRTUServer.begin(1, 9600)) {
    Serial.println("Failed to start Modbus RTU Server!");
    while (1);
  }
  
  // Configure memory
  ModbusRTUServer.configureCoils(0, 10);
  ModbusRTUServer.configureHoldingRegisters(0, 50);
  
  Serial.println("Modbus RTU Server started with ID 1");
}
```
```

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

### Set Write Value - client.write()

Source: https://github.com/arduino-libraries/arduinomodbus/blob/master/docs/api.md

Sets the value for a write operation that was started with beginTransmission().

```cpp
int write(unsigned int value);
```

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

### Modbus TCP Client begin() with WiFi

Source: https://github.com/arduino-libraries/arduinomodbus/blob/master/_autodocs/configuration.md

Configure a Modbus TCP client to connect to a server using a WiFi connection. Include WiFi and Modbus libraries. The begin() method attempts to establish a connection to the specified IP address and port. The loop() function will attempt to reconnect if the connection is lost.

```cpp
#include <WiFi.h>
#include <ArduinoModbus.h>

const char* ssid = "YourSSID";
const char* password = "YourPassword";
IPAddress serverIP(192, 168, 1, 100);

WiFiClient wifiClient;
ModbusTCPClient modbusTCPClient(wifiClient);

void setup() {
  Serial.begin(9600);
  
  // Connect to WiFi
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
  }
  
  // Connect to Modbus TCP server
  modbusTCPClient.begin(serverIP, 502);
}

void loop() {
  if (!modbusTCPClient.connected()) {
    modbusTCPClient.begin(serverIP, 502);
  } else {
    long value = modbusTCPClient.holdingRegisterRead(0);
  }
  
  delay(1000);
}
```

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

### ModbusTCPClient stop() Example

Source: https://github.com/arduino-libraries/arduinomodbus/blob/master/_autodocs/api-reference/modbus-tcp-client.md

Calls the stop() method to disconnect the Modbus TCP client.

```cpp
modbusTCPClient.stop();
```

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

### Get Last Error - client.lastError()

Source: https://github.com/arduino-libraries/arduinomodbus/blob/master/docs/api.md

Read the last error reason as a C string.

```cpp
const char* lastError();
```

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

### begin

Source: https://github.com/arduino-libraries/arduinomodbus/blob/master/_autodocs/api-reference/modbus-tcp-server.md

Initializes the Modbus TCP server with an optional unit ID. The standard TCP unit ID is 0xFF.

```APIDOC
## begin

### Description
Initialize the Modbus TCP server.

### Method Signature
```cpp
int begin(int id = 0xff);
```

### Parameters
#### Path Parameters
- **id** (int) - Optional - Default: 0xff - Unit ID for TCP server (0xff is standard for TCP)

### Returns
- **int**: 1 on success, 0 on failure

### Example
```cpp
#include <Ethernet.h>
#include <ArduinoModbus.h>

byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
IPAddress ip(192, 168, 1, 100);

ModbusTCPServer modbusServer;

void setup() {
  Serial.begin(9600);
  
  Ethernet.begin(mac, ip);
  delay(1000);
  
  if (!modbusServer.begin()) {
    Serial.println("Failed to start Modbus TCP Server!");
    while (1);
  }
  
  modbusServer.configureCoils(0, 16);
  modbusServer.configureHoldingRegisters(0, 100);
  
  Serial.println("Modbus TCP Server started");
}
```
```

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

### ModbusTCPClient begin() Method

Source: https://github.com/arduino-libraries/arduinomodbus/blob/master/_autodocs/api-reference/modbus-tcp-client.md

Initializes the Modbus TCP client connection to a server. Returns 1 on success, 0 on failure. The port defaults to 502.

```cpp
int begin(IPAddress ip, uint16_t port = 502);
```

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

### writeInputRegisters

Source: https://github.com/arduino-libraries/arduinomodbus/blob/master/_autodocs/api-reference/modbus-server.md

Writes multiple input registers starting from the specified address. Returns 1 on success and 0 on failure.

```APIDOC
## writeInputRegisters

### Description
Writes multiple input registers.

### Method Signature
`int writeInputRegisters(int address, uint16_t values[], int nb);`

### Parameters
#### Path Parameters
- **address** (int) - Required - Starting address for write
- **values** (uint16_t[]) - Required - Array of values to write
- **nb** (int) - Required - Number of values to write

### Returns
- 1 on success, 0 on failure

### Example
```cpp
uint16_t sensorData[] = {1000, 1100, 1200, 1300};
ModbusRTUServer.writeInputRegisters(0, sensorData, 4);
```
```

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

### writeDiscreteInputs

Source: https://github.com/arduino-libraries/arduinomodbus/blob/master/_autodocs/api-reference/modbus-server.md

Writes multiple discrete inputs starting from the specified address. Returns 1 on success and 0 on failure.

```APIDOC
## writeDiscreteInputs

### Description
Writes multiple discrete inputs.

### Method Signature
`int writeDiscreteInputs(int address, uint8_t values[], int nb);`

### Parameters
#### Path Parameters
- **address** (int) - Required - Starting address for write
- **values** (uint8_t[]) - Required - Array of values to write
- **nb** (int) - Required - Number of values to write

### Returns
- 1 on success, 0 on failure

### Example
```cpp
uint8_t inputs[] = {1, 0, 1, 1, 0};
ModbusRTUServer.writeDiscreteInputs(0, inputs, 5);
```
```

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

### Begin Multiple Writes - client.beginTransmission()

Source: https://github.com/arduino-libraries/arduinomodbus/blob/master/docs/api.md

Initiates the process for writing multiple coils or holding registers. Use write() to set values and endTransmission() to send the request.

```cpp
int beginTransmission(int type, int address, int nb);
int beginTransmission(int id, int type, int address, int nb);
```

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

### Modbus TCP Client begin() with Ethernet

Source: https://github.com/arduino-libraries/arduinomodbus/blob/master/_autodocs/configuration.md

Configure a Modbus TCP client to connect to a server using an Ethernet connection. Ensure Ethernet and Modbus libraries are included. The begin() method attempts to establish a connection to the specified IP address and port.

```cpp
#include <SPI.h>
#include <Ethernet.h>
#include <ArduinoModbus.h>

byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
IPAddress ip(192, 168, 1, 177);
IPAddress serverIP(192, 168, 1, 100);

EthernetClient ethClient;
ModbusTCPClient modbusTCPClient(ethClient);

void setup() {
  Serial.begin(9600);
  
  // Initialize Ethernet
  Ethernet.begin(mac, ip);
  delay(1000);
  
  // Connect to Modbus TCP server
  if (!modbusTCPClient.begin(serverIP, 502)) {
    Serial.println("Failed to connect to server");
  }
}

void loop() {
  if (modbusTCPClient.connected()) {
    long value = modbusTCPClient.holdingRegisterRead(0);
  }
}
```

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

### configureCoils

Source: https://github.com/arduino-libraries/arduinomodbus/blob/master/_autodocs/api-reference/modbus-server.md

Configures the server's coil memory area. It allocates a specified number of coils starting from a given address.

```APIDOC
## configureCoils

### Description
Configures the server's coil memory area. It allocates a specified number of coils starting from a given address.

### Method
int configureCoils(int startAddress, int nb)

### Parameters
#### Path Parameters
- **startAddress** (int) - Yes - Starting address for coils
- **nb** (int) - Yes - Number of coils to allocate

### Returns
1 on success, 0 on failure (e.g., memory allocation error)

### Example
```cpp
// Configure 8 coils starting at address 0
if (!ModbusRTUServer.configureCoils(0, 8)) {
  Serial.println("Failed to configure coils");
}
```
```

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

### Initialize ModbusRTUClient with Custom RS485

Source: https://github.com/arduino-libraries/arduinomodbus/blob/master/_autodocs/api-reference/modbus-rtu-client.md

Demonstrates initializing the ModbusRTUClient with a custom RS485 hardware instance. Include both ArduinoRS485 and ArduinoModbus libraries.

```cpp
#include <ArduinoRS485.h>
#include <ArduinoModbus.h>

// Use a custom RS485 instance if needed
ModbusRTUClientClass customClient(RS485);
```

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

### client.beginTransmission()

Source: https://github.com/arduino-libraries/arduinomodbus/blob/master/docs/api.md

Begin the process of a writing multiple coils or holding registers. Use write(value) to set the values you want to send, and endTransmission() to send request on the wire.

```APIDOC
## client.beginTransmission()

### Description
Begin the process of a writing multiple coils or holding registers.
Use write(value) to set the values you want to send, and endTransmission() to send request on the wire.

### Syntax
```
int beginTransmission(int type, int address, int nb);
int beginTransmission(int id, int type, int address, int nb);
```

### Parameters
- id (slave) - id of target, defaults to 0x00 if not specified
- type - type of write to perform, either
    - COILS (FC 0x01)
    - HOLDING_REGISTERS (FC 0x03)
- address start address to use for operation
- nb - number of values to write

### Returns
1 on success, 0 on failure
```

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

### modbusServer.configureCoils()

Source: https://github.com/arduino-libraries/arduinomodbus/blob/master/docs/api.md

Configure the servers coils.

```APIDOC
## modbusServer.configureCoils()

### Description
Configure the servers coils.

### Syntax
```
int configureCoils(int startAddress, int nb);
```

### Parameters
- startAddress - start address of coils
- nb - number of coils to configure

### Returns
0 on success, 1 on failure
```