### Basic C++ Example

Source: https://github.com/arduino-libraries/arduinors485/blob/master/_autodocs/INDEX.md

A simple C++ example demonstrating the initialization of the RS485 library with a baud rate of 9600.

```cpp
RS485.begin(9600);  // C++ example
```

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

### Custom RS485 Class Instance Example

Source: https://github.com/arduino-libraries/arduinors485/blob/master/_autodocs/types-and-constants.md

Example demonstrating how to create and use a custom instance of the RS485Class, alongside the global RS485 singleton. Shows initialization and basic transmission usage for both instances.

```cpp
#include <ArduinoRS485.h>

// Create custom instance
RS485Class myRS485(Serial1, 1, 2, 3);

void setup() {
  myRS485.begin(9600);  // Initialize custom instance
  RS485.begin(9600);    // Global instance also available
}

void loop() {
  // Use either instance
  RS485.beginTransmission();
  RS485.print("Global");
  RS485.endTransmission();
  
  myRS485.beginTransmission();
  myRS485.print("Custom");
  myRS485.endTransmission();
}

```

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

### RS485Class Initialization Methods

Source: https://github.com/arduino-libraries/arduinors485/blob/master/_autodocs/types-and-constants.md

Starts serial communication with specified baud rate and optional configuration or delays.

```cpp
// Initialization
void begin(unsigned long baudrate);
void begin(unsigned long baudrate, uint16_t config);
void begin(unsigned long baudrate, int predelay, int postdelay);
void begin(unsigned long baudrate, uint16_t config, int predelay, int postdelay);
```

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

### Typical Usage on SAMD Boards

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

Example of initializing RS485 communication on SAMD-based boards like Arduino Zero. This configuration supports full-duplex communication.

```cpp
#include <ArduinoRS485.h>

void setup() {
  RS485.begin(9600);  // Full duplex with both DE and RE
}
```

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

### Include Arduino RS485 Library

Source: https://github.com/arduino-libraries/arduinors485/blob/master/docs/readme.md

Include this header file to start using the Arduino RS485 library for communication.

```c++
#include <ArduinoRS485.h>
```

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

### begin(unsigned long baudrate)

Source: https://github.com/arduino-libraries/arduinors485/blob/master/_autodocs/api-reference/rs485-class.md

Initializes RS-485 communication with specified baud rate using default configuration (8N1) and default timing delays. This is the most common way to start RS-485 communication.

```APIDOC
## begin(unsigned long baudrate)

### Description
Initializes RS-485 communication with specified baud rate using default configuration (8N1) and default timing delays.

### Method
void

### Parameters
#### Query Parameters
- **baudrate** (unsigned long) - Communication speed in bits per second (9600, 19200, 115200, etc.)

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

void setup() {
  RS485.begin(9600);  // Initialize at 9600 baud
}

void loop() {
  RS485.beginTransmission();
  RS485.print("Hello RS485");
  RS485.endTransmission();
  delay(1000);
}
```
```

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

### Custom RS485 Pin Override Definitions

Source: https://github.com/arduino-libraries/arduinors485/blob/master/_autodocs/types-and-constants.md

Demonstrates how to override the default DE and RE pins for the RS485 library by defining CUSTOM_RS485_DEFAULT_DE_PIN and CUSTOM_RS485_DEFAULT_RE_PIN before including the library. Includes a basic setup example.

```cpp
#define CUSTOM_RS485_DEFAULT_DE_PIN 3   // Override DE pin
#define CUSTOM_RS485_DEFAULT_RE_PIN 4   // Override RE pin
#include <ArduinoRS485.h>

void setup() {
  RS485.begin(9600);  // Uses custom pins 3 and 4
}

```

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

### Typical Usage on AVR Boards

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

Example of initializing RS485 communication on AVR-based boards like Arduino Uno. It uses default pins and enables the receiver manually.

```cpp
#include <ArduinoRS485.h>

void setup() {
  RS485.begin(9600);  // Uses pins 1 (TX), 2 (DE)
  RS485.receive();    // Enable receiver manually
}
```

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

### Boolean Context Usage Example

Source: https://github.com/arduino-libraries/arduinors485/blob/master/_autodocs/types-and-constants.md

An example demonstrating the usage of the RS485 object in a boolean context, leveraging the overloaded operator bool(). Since it always returns true, the code inside the if block will always execute if the object is valid.

```cpp
if (RS485) {
  // Always true - object exists
  RS485.begin(9600);
}

```

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

### Initialize RS485 with Custom Hardware Serial

Source: https://github.com/arduino-libraries/arduinors485/blob/master/_autodocs/architecture.md

Configure the RS485 library to use a non-standard hardware serial port. This example demonstrates initializing the RS485Class with a specific serial port instance and pins, then beginning communication at a specified baud rate.

```cpp
// Use with non-standard serial port
RS485Class custom(Serial2, 10, 11, 12);
custom.begin(9600);
```

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

### Initialize RS485 Communication

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

Initializes the RS485 communication with a specified baud rate. This is typically called once in the setup() function.

```arduino
RS485.begin(9600);
```

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

### Initialize RS485 with Default Settings

Source: https://github.com/arduino-libraries/arduinors485/blob/master/_autodocs/usage-patterns.md

Initializes the RS485 communication with default settings: 9600 baud, 8 data bits, no parity, 1 stop bit, and 50µs delays. This is the simplest way to start.

```cpp
#include <ArduinoRS485.h>

void setup() {
  RS485.begin(9600);  // Initialize with default config (8N1), 50µs delays
}

void loop() {
  // Ready for transmission/reception
}
```

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

### Send Data over RS485

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

This example demonstrates how to send data over RS485 using beginTransmission() and endTransmission(). It sends a counter value every second.

```arduino
#include <ArduinoRS485.h>

int counter = 0;

void setup() {
  RS485.begin(9600);
}

void loop() {
  RS485.beginTransmission();
  RS485.print("Counter: ");
  RS485.println(counter);
  RS485.endTransmission();

  counter++;

  delay(1000);
}
```

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

### Enable Receiver

Source: https://github.com/arduino-libraries/arduinors485/blob/master/_autodocs/INDEX.md

Enables the RS485 receiver to start listening for incoming data.

```cpp
RS485.receive();
```

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

### Full-Duplex Communication Setup

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

Initializes RS-485 communication for full-duplex mode, where both transmission and reception are enabled simultaneously. Includes periodic data transmission and continuous listening.

```cpp
#include <ArduinoRS485.h>

void setup() {
  RS485.begin(9600);
  RS485.receive();    // Both transmit and receive enabled
}

void loop() {
  // Send periodically
  if (millis() % 1000 < 100) {
    RS485.beginTransmission();
    RS485.print("DATA");
    RS485.endTransmission();
  }
  
  // Always listening
  if (RS485.available()) {
    Serial.write(RS485.read());
  }
}
```

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

### Simple Full-Duplex RS485 Example

Source: https://github.com/arduino-libraries/arduinors485/blob/master/_autodocs/usage-patterns.md

Demonstrates basic full-duplex RS485 communication. The Arduino sends a heartbeat message periodically and also listens for and prints any incoming data to the Serial monitor.

```cpp
#include <ArduinoRS485.h>

void setup() {
  Serial.begin(9600);
  RS485.begin(9600);
  RS485.receive();             // Enable reception
}

void loop() {
  // Send data periodically
  if (millis() % 1000 < 100) {  // Once per second
    RS485.beginTransmission();
    RS485.print("HEARTBEAT");
    RS485.endTransmission();
  }
  
  // Receive data anytime
  if (RS485.available()) {
    byte incomingByte = RS485.read();
    Serial.write(incomingByte);
  }
}
```

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

### RS485 Write Error Handling

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

Example demonstrating how to handle write errors by checking the return value of RS485.write(). A return value of 0 indicates that the transmission was not begun.

```cpp
RS485.beginTransmission();
size_t written = RS485.write(0xFF);
if (written == 0) {
  // Write failed - transmission not begun
}
RS485.endTransmission();
```

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

### Initialize RS-485 with Baud Rate

Source: https://github.com/arduino-libraries/arduinors485/blob/master/_autodocs/api-reference/rs485-class.md

Initializes RS-485 communication with the specified baud rate using default serial configuration and timing delays. This is a common starting point for basic RS-485 communication.

```cpp
void begin(unsigned long baudrate)
```

```cpp
#include <ArduinoRS485.h>

void setup() {
  RS485.begin(9600);  // Initialize at 9600 baud
}

void loop() {
  RS485.beginTransmission();
  RS485.print("Hello RS485");
  RS485.endTransmission();
  delay(1000);
}
```

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

### Implement Thread-Safe RS485 Wrapper

Source: https://github.com/arduino-libraries/arduinors485/blob/master/_autodocs/architecture.md

Create a thread-safe wrapper class for the RS485 library to manage concurrent access. This example shows a basic wrapper that uses a mutex to lock and unlock critical sections for `beginTransmission` and `endTransmission`.

```cpp
class ThreadSafeRS485 {
private:
  RS485Class& rs485;
  Mutex mtx;
public:
  void beginTransmission() {
    mtx.lock();
    rs485.beginTransmission();
  }
  void endTransmission() {
    rs485.endTransmission();
    mtx.unlock();
  }
};
```

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

### Override Default DE Pin

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

Customize the Drive Enable (DE) pin by defining CUSTOM_RS485_DEFAULT_DE_PIN before including the library. This example sets the DE pin to 3.

```cpp
#define CUSTOM_RS485_DEFAULT_DE_PIN 3

#include <ArduinoRS485.h>

void setup() {
  RS485.begin(9600);  // Uses pin 3 for DE
}
```

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

### receive()

Source: https://github.com/arduino-libraries/arduinors485/blob/master/_autodocs/api-reference/rs485-class.md

Enables reception mode by setting the Receiver Output Enable (RE) pin low. This allows incoming data to reach the serial input buffer and should be called during setup or after `noReceive()`.

```APIDOC
## receive()

### Description
Enables reception mode by setting the Receiver Output Enable (RE) pin low. This allows incoming data to reach the serial input buffer.

### Method
```cpp
void receive()
```

### Parameters
None

### Details
- Sets RE (Receiver Enable) pin LOW, enabling the receiver.
- Only executes if RE pin is configured (not -1).
- Allows incoming data to reach the serial input buffer.
- Should be called during setup or after `noReceive()`.

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

void setup() {
  RS485.begin(9600);
  RS485.receive();  // Enable reception at startup
}

void loop() {
  if (RS485.available()) {
    Serial.write(RS485.read());
  }
}
```
```

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

### RS485.available()

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

Gets the number of bytes available for reading from the RS485 port. This indicates how much data has arrived and is stored in the serial receive buffer.

```APIDOC
## RS485.available()

### Description
Get the number of bytes (characters) available for reading from the RS485 port. This is data that already arrived and is stored in the serial receive buffer.

### Syntax
```
RS485.available()
```

### Parameters
None.

### Returns
The number of bytes available to read.

### See also
* [begin()](#begin)
* [end()](#end)
* [peek()](#peek)
* [read()](#read)
* [write()](#write)
* [flush()](#flush)
* [beginTransmission()](#begintransmission)
* [endTransmission()](#endtransmission)
* [receive()](#receive)
* [noReceive()](#noreceive)
* [sendBreak()](#sendbreak)
* [sendBreakMicroseconds()](#sendbreakmicroseconds)
* [setPins()](#setpins)
```

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

### RS485 Configuration for Long Cable Runs

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

Adjust RS485 communication for long cable runs by increasing pre and post transmission delays. This example sets delays to 150 microseconds.

```cpp
// Increase delays to 100-200 microseconds
RS485.begin(9600, 150, 150);  // 150µs pre and post delays
```

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

### Override Both DE and RE Pins

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

Simultaneously override both the Drive Enable (DE) and Receiver Enable (RE) pins by defining CUSTOM_RS485_DEFAULT_DE_PIN and CUSTOM_RS485_DEFAULT_RE_PIN before including the library. This example sets DE to 5 and RE to 6.

```cpp
#define CUSTOM_RS485_DEFAULT_DE_PIN 5
#define CUSTOM_RS485_DEFAULT_RE_PIN 6
#include <ArduinoRS485.h>

void setup() {
  // Automatically uses pins 5 and 6 for DE and RE
  RS485.begin(9600);
}
```

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

### Protect RS485 Transmission with Mutex

Source: https://github.com/arduino-libraries/arduinors485/blob/master/_autodocs/architecture.md

When using the RS485 library with an RTOS, protect shared resources like transmissions with a mutex to ensure thread safety. This example demonstrates how to acquire and release a semaphore before and after a transmission.

```cpp
static SemaphoreHandle_t rs485Mutex;

void rs485_protected_transmission() {
  if (xSemaphoreTake(rs485Mutex, portMAX_DELAY)) {
    RS485.beginTransmission();
    RS485.print("Safe");
    RS485.endTransmission();
    xSemaphoreGive(rs485Mutex);
  }
}
```

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

### Write Operation Flow

Source: https://github.com/arduino-libraries/arduinors485/blob/master/_autodocs/architecture.md

Details the method resolution order for write operations, starting from `RS485.print()` and delegating to `RS485Class::write()`, which performs a transmission check before calling `HardwareSerial::write()`.

```text
RS485.print("Hello")
    ↓ (inherited from Print)
RS485.write('H')
    ↓
RS485Class::write(uint8_t)
    ├─ Check _transmisionBegun
    ├─ If false: setWriteError(), return 0
    └─ If true: _serial->write(byte)
    ↓ (delegated)
HardwareSerial::write(uint8_t)
    ↓
UART Hardware
```

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

### Create Custom RS485 Subclass for Modbus

Source: https://github.com/arduino-libraries/arduinors485/blob/master/_autodocs/architecture.md

Extend the RS485Class to create a custom subclass, such as for Modbus communication. This example shows how to implement a `sendRequest` method that handles the transmission of a byte array.

```cpp
class ModbusRS485 : public RS485Class {
public:
  void sendRequest(byte* request, int length) {
    beginTransmission();
    for (int i = 0; i < length; i++) {
      write(request[i]);
    }
    endTransmission();
  }
};
```

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

### RS485Class begin() Method Implementation

Source: https://github.com/arduino-libraries/arduinors485/blob/master/_autodocs/architecture.md

The main implementation of the begin() method configures the DE and RE pins, sets transmission delays, and initializes the underlying hardware serial port. It defaults to receive mode and disabled receiver.

```cpp
void RS485Class::begin(unsigned long baudrate, uint16_t config, int predelay, int postdelay)
{
  _baudrate = baudrate;
  _config = config;

  // Only set if not already set by setDelays()
  _predelay = _predelay == 0 ? predelay : _predelay;
  _postdelay = _postdelay == 0 ? postdelay : _postdelay;

  // Configure DE pin
  if (_dePin > -1) {
    pinMode(_dePin, OUTPUT);
    digitalWrite(_dePin, LOW);      // Start in receive mode
  }

  // Configure RE pin
  if (_rePin > -1) {
    pinMode(_rePin, OUTPUT);
    digitalWrite(_rePin, HIGH);     // Receiver disabled initially
  }

  _transmisionBegun = false;

  // Initialize hardware serial
  _serial->begin(baudrate, config);
}
```

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

### begin(unsigned long baudrate, uint16_t config)

Source: https://github.com/arduino-libraries/arduinors485/blob/master/_autodocs/api-reference/rs485-class.md

Initializes RS-485 communication with specified baud rate and serial configuration using default timing delays. This method allows for custom serial configurations like parity and stop bits.

```APIDOC
## begin(unsigned long baudrate, uint16_t config)

### Description
Initializes RS-485 communication with specified baud rate and serial configuration using default timing delays.

### Method
void

### Parameters
#### Query Parameters
- **baudrate** (unsigned long) - Communication speed in bits per second
- **config** (uint16_t) - Serial configuration (SERIAL_8N1, SERIAL_8E1, SERIAL_8O1, SERIAL_9N1, etc.)

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

void setup() {
  // Configure for 8 data bits, even parity, 1 stop bit
  RS485.begin(9600, SERIAL_8E1);
}

void loop() {
  if (RS485.available()) {
    int data = RS485.read();
    // Process received data
  }
}
```
```

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

### RS485.begin()

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

Initializes the RS485 object communication speed. This method sets the baud rate for RS485 communication.

```APIDOC
## RS485.begin()

### Description
Initializes the RS485 object communication speed.

### Syntax
```
RS485.begin(baudrate)
```

### Parameters
* `baudrate` (int) - communication speed in bits per second (baud).

### Returns
None.

### See also
* [end()](#end)
* [available()](#available)
* [peek()](#peek)
* [read()](#read)
* [write()](#write)
* [flush()](#flush)
* [beginTransmission()](#begintransmission)
* [endTransmission()](#endtransmission)
* [receive()](#receive)
* [noReceive()](#noreceive)
* [sendBreak()](#sendbreak)
* [sendBreakMicroseconds()](#sendbreakmicroseconds)
* [setPins()](#setpins)
```

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

### Initialization with Configuration

Source: https://github.com/arduino-libraries/arduinors485/blob/master/_autodocs/INDEX.md

Initializes the RS485 communication with a specified baud rate and serial communication format (e.g., SERIAL_8E1).

```cpp
RS485.begin(9600, SERIAL_8E1);
```

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

### Override Default RE Pin

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

Customize the Receiver Enable (RE) pin by defining CUSTOM_RS485_DEFAULT_RE_PIN before including the library. This example sets the RE pin to 4.

```cpp
#define CUSTOM_RS485_DEFAULT_RE_PIN 4

#include <ArduinoRS485.h>

void setup() {
  RS485.begin(9600);  // Uses pin 4 for RE
}
```

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

### Initialize RS485 for Debugging

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

Initialize RS485 with a high baud rate for fast debugging purposes.

```cpp
RS485.begin(115200, SERIAL_8N1);
```

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

### Initialize RS485 with Full Configuration

Source: https://github.com/arduino-libraries/arduinors485/blob/master/_autodocs/usage-patterns.md

Initializes RS485 communication with a full set of parameters: baud rate, serial format, pre-delay, and post-delay. Provides complete control over communication parameters.

```cpp
#include <ArduinoRS485.h>

void setup() {
  // 19200 baud, even parity, 150µs pre-delay, 150µs post-delay
  RS485.begin(19200, SERIAL_8E1, 150, 150);
}
```

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

### RS485 Write Function Logic

Source: https://github.com/arduino-libraries/arduinors485/blob/master/_autodocs/architecture.md

The write function ensures that data is only sent when a transmission has been explicitly started. This prevents accidental transmissions outside of a beginTransmission() block.

```cpp
size_t RS485Class::write(uint8_t b)
{
  if (!_transmisionBegun) {
    setWriteError();
    return 0;  // Write failed
  }
  return _serial->write(b);
}
```

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

### RS485 Initialization with Full Configuration

Source: https://github.com/arduino-libraries/arduinors485/blob/master/_autodocs/api-reference/rs485-class.md

Initializes RS-485 communication with a specified baud rate, serial configuration, and custom timing delays. This is the most flexible initialization method.

```APIDOC
## `begin(unsigned long baudrate, uint16_t config, int predelay, int postdelay)`

### Description
Initializes RS-485 communication with specified baud rate, serial configuration, and custom timing delays.

### Method
`void begin(unsigned long baudrate, uint16_t config, int predelay, int postdelay)`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
- **baudrate** (unsigned long) - Required - Communication speed in bits per second
- **config** (uint16_t) - Required - Serial configuration (SERIAL_8N1, SERIAL_8E1, SERIAL_8O1, etc.)
- **predelay** (int) - Required - Delay in microseconds before transmission begins after enabling TX
- **postdelay** (int) - Required - Delay in microseconds after transmission completes before disabling TX

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

void setup() {
  // 19200 baud, even parity, 75µs pre-delay, 75µs post-delay
  RS485.begin(19200, SERIAL_8E1, 75, 75);
}
```

### Response
#### Success Response (void)
void

#### Response Example
None
```

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

### Initialize RS485 with Baud Rate, Configuration, and Custom Delays

Source: https://github.com/arduino-libraries/arduinors485/blob/master/_autodocs/api-reference/rs485-class.md

This method provides the most flexible initialization for RS-485 communication, allowing specification of baud rate, serial configuration (like parity and data bits), and custom timing delays. It configures DE and RE pins for RS-485 operation.

```cpp
#include <ArduinoRS485.h>

void setup() {
  // 19200 baud, even parity, 75µs pre-delay, 75µs post-delay
  RS485.begin(19200, SERIAL_8E1, 75, 75);
}
```

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

### Enable RS485 Reception

Source: https://github.com/arduino-libraries/arduinors485/blob/master/_autodocs/api-reference/rs485-class.md

Enables the RS485 receiver by setting the Receiver Enable (RE) pin low. Call this during setup or after disabling reception to listen for incoming data.

```cpp
#include <ArduinoRS485.h>

void setup() {
  RS485.begin(9600);
  RS485.receive();  // Enable reception at startup
}

void loop() {
  if (RS485.available()) {
    Serial.write(RS485.read());
  }
}
```

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

### Modbus RTU Implementation

Source: https://github.com/arduino-libraries/arduinors485/blob/master/_autodocs/usage-patterns.md

A standard Modbus RTU implementation over RS-485. It includes setup for communication parameters and a loop for receiving, processing, and responding to Modbus requests.

```cpp
#include <ArduinoRS485.h>

void setup() {
  Serial.begin(9600);
  
  // Standard Modbus RTU settings
  // 19200 baud, 8 data bits, even parity, 1 stop bit
  RS485.begin(19200, SERIAL_8E1);
  RS485.receive();  // Listen for requests
}

void loop() {
  // Receive Modbus request
  if (RS485.available()) {
    byte request[8];
    int bytesRead = 0;
    
    while (RS485.available() && bytesRead < 8) {
      request[bytesRead++] = RS485.read();
    }
    
    // Process request and build response
    byte response[8];
    processModbusRequest(request, bytesRead, response);
    
    // Send Modbus response
    delay(3);  // Modbus inter-frame delay
    RS485.beginTransmission();
    for (int i = 0; i < 8; i++) {
      RS485.write(response[i]);
    }
    RS485.endTransmission();
  }
}

void processModbusRequest(byte* req, int len, byte* res) {
  // Modbus processing logic here
  memcpy(res, req, len);  // Echo for demo
}
```

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

### Use Inherited Print Methods for RS485 Output

Source: https://github.com/arduino-libraries/arduinors485/blob/master/_autodocs/api-reference/rs485-class.md

Demonstrates using inherited `print` and `println` methods for sending formatted data over RS485. Ensure `begin()` is called before transmission.

```cpp
#include <ArduinoRS485.h>

void setup() {
  RS485.begin(9600);
}

void loop() {
  RS485.beginTransmission();
  RS485.print("Counter: ");
  RS485.println(42);           // Inherited from Print
  RS485.print(3.14159, 2);     // Print double with 2 decimals
  RS485.endTransmission();
  delay(1000);
}
```

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

### Initialize RS485 for Industrial Control

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

Use longer delays for settling when initializing RS485 for industrial control applications.

```cpp
RS485.begin(9600, 150, 150);
RS485.receive();
```

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

### Initialization Methods

Source: https://github.com/arduino-libraries/arduinors485/blob/master/_autodocs/INDEX.md

Methods for initializing and shutting down the RS485 communication interface.

```APIDOC
## Initialization

### `RS485.begin(baudRate)`

Initializes the RS485 communication with the specified baud rate.

### `RS485.begin(baudRate, config)`

Initializes the RS485 communication with the specified baud rate and serial configuration.

### `RS485.begin(baudRate, preTransmissionDelay, postTransmissionDelay)`

Initializes the RS485 communication with the specified baud rate and custom delays.

### `RS485.begin(baudRate, config, preTransmissionDelay, postTransmissionDelay)`

Initializes the RS485 communication with full control over baud rate, serial configuration, and custom delays.

### `RS485.end()`

Shuts down the RS485 communication interface.
```

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

### Multi-Device Network Communication

Source: https://github.com/arduino-libraries/arduinors485/blob/master/_autodocs/usage-patterns.md

Example of coordinating multiple RS-485 devices on a network. It includes periodic broadcasting of device status and processing of incoming messages, identifying messages from other devices.

```cpp
#include <ArduinoRS485.h>

#define DEVICE_ID 1
#define NUM_DEVICES 4

unsigned long lastBroadcast = 0;
const unsigned long BROADCAST_INTERVAL = 5000;

void setup() {
  Serial.begin(9600);
  RS485.begin(9600);
  RS485.receive();  // Always listening
}

void loop() {
  unsigned long now = millis();
  
  // Periodically broadcast status
  if (now - lastBroadcast >= BROADCAST_INTERVAL) {
    lastBroadcast = now;
    
    RS485.beginTransmission();
    RS485.print("DEVICE_");
    RS485.print(DEVICE_ID);
    RS485.print(":ALIVE:");
    RS485.println(analogRead(A0));
    RS485.endTransmission();
  }
  
  // Process incoming messages
  if (RS485.available()) {
    processMessage();
  }
}

void processMessage() {
  char header[16] = "";
  int headerIndex = 0;
  
  while (RS485.available()) {
    int ch = RS485.read();
    if (ch == ':' || headerIndex >= 15) {
      header[headerIndex] = '\0';
      break;
    }
    header[headerIndex++] = ch;
  }
  
  if (strstr(header, "DEVICE_")) {
    Serial.print("Message from: ");
    Serial.println(header);
  }
}
```

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

### Initialization with Delays

Source: https://github.com/arduino-libraries/arduinors485/blob/master/_autodocs/INDEX.md

Initializes the RS485 communication with a specified baud rate and custom pre-transmission and post-transmission delays in milliseconds.

```cpp
RS485.begin(9600, 100, 100);
```

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

### RS485.beginTransmission()

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

Enables RS-485 transmission. This method prepares the library to send data over RS485.

```APIDOC
## RS485.beginTransmission()

### Description
Enables RS-485 transmission.

### Syntax
```
RS485.beginTransmission()
```

### Parameters
None.

### Returns
None.

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

int counter = 0;

void setup() {
  RS485.begin(9600);
}

void loop() {
  RS485.beginTransmission();
  RS485.print("Counter: ");
  RS485.println(counter);
  RS485.endTransmission();

  counter++;

  delay(1000);
}
```
```

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

### Initialize RS-485 with Baud Rate and Configuration

Source: https://github.com/arduino-libraries/arduinors485/blob/master/_autodocs/api-reference/rs485-class.md

Initializes RS-485 communication with a specified baud rate and serial configuration (e.g., parity, data bits, stop bits) using default timing delays. This allows for custom serial protocols.

```cpp
void begin(unsigned long baudrate, uint16_t config)
```

```cpp
#include <ArduinoRS485.h>

void setup() {
  // Configure for 8 data bits, even parity, 1 stop bit
  RS485.begin(9600, SERIAL_8E1);
}

void loop() {
  if (RS485.available()) {
    int data = RS485.read();
    // Process received data
  }
}
```

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

### Initialize RS485 with Custom Timing Delays

Source: https://github.com/arduino-libraries/arduinors485/blob/master/_autodocs/usage-patterns.md

Initializes RS485 communication with a specified baud rate and custom pre-delay and post-delay timings in microseconds. Useful for fine-tuning bus timing.

```cpp
#include <ArduinoRS485.h>

void setup() {
  // 9600 baud with 100µs pre-delay and 100µs post-delay
  RS485.begin(9600, 100, 100);
}
```

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

### Configuration Methods

Source: https://github.com/arduino-libraries/arduinors485/blob/master/_autodocs/INDEX.md

Methods for configuring the RS485 pins and transmission delays.

```APIDOC
## Configuration

### `RS485.setPins(txPin, dePin, rePin)`

Sets the pins for Transmit (TX), Driver Enable (DE), and Receiver Enable (RE).

### `RS485.setDelays(preTransmissionDelayUs, postTransmissionDelayUs)`

Sets the pre- and post-transmission delays in microseconds for fine-tuning communication timing.
```

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

### Initialize RS485 with Baud Rate and Custom Delays

Source: https://github.com/arduino-libraries/arduinors485/blob/master/_autodocs/api-reference/rs485-class.md

Use this to initialize RS-485 communication with a specific baud rate and custom pre-transmission and post-transmission delays. This is useful for networks with slow transceivers that require settling time.

```cpp
#include <ArduinoRS485.h>

void setup() {
  // Initialize with custom timing: 100µs pre-delay, 100µs post-delay
  RS485.begin(9600, 100, 100);
}

void loop() {
  RS485.beginTransmission();
  RS485.write(0xFF);
  RS485.endTransmission();
  delay(100);
}
```

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

### Full Control Initialization

Source: https://github.com/arduino-libraries/arduinors485/blob/master/_autodocs/INDEX.md

Initializes the RS485 communication with full control over baud rate, serial format, and pre/post transmission delays.

```cpp
RS485.begin(9600, SERIAL_8E1, 100, 100);
```

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

### RS485Class Initialization

Source: https://github.com/arduino-libraries/arduinors485/blob/master/_autodocs/types-and-constants.md

Configures the RS485 communication parameters, including baud rate and optional settings.

```APIDOC
## RS485Class Initialization

### Description
Initializes the RS485 communication with the specified baud rate and optional configuration parameters. This function must be called before using the RS485 library for communication.

### Methods
- `void begin(unsigned long baudrate)`
- `void begin(unsigned long baudrate, uint16_t config)`
- `void begin(unsigned long baudrate, int predelay, int postdelay)`
- `void begin(unsigned long baudrate, uint16_t config, int predelay, int postdelay)`

### Parameters
- **baudrate** (unsigned long) - The desired communication speed in bits per second.
- **config** (uint16_t) - Optional serial communication configuration flags (e.g., parity, stop bits).
- **predelay** (int) - Optional delay in microseconds before transmission starts.
- **postdelay** (int) - Optional delay in microseconds after transmission ends.
```

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

### Check Write Operation Success with size_t

Source: https://github.com/arduino-libraries/arduinors485/blob/master/_autodocs/types-and-constants.md

The return type for write operations is size_t, indicating success (1) or failure (0). A return value of 0 typically means transmission was not started and beginTransmission() should be called first.

```cpp
size_t bytesWritten = RS485.write(0xFF);
if (bytesWritten == 1) {
  // Success
} else {
  // Failed - call beginTransmission() first
}
```

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

### Initialize RS485 for Long Cables

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

Use extra settling time when initializing RS485 for applications with long cables.

```cpp
RS485.begin(9600, 200, 200);
```

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

### Initialize RS485 with Custom Baud Rate and Parity

Source: https://github.com/arduino-libraries/arduinors485/blob/master/_autodocs/usage-patterns.md

Initializes RS485 communication with a specified baud rate and serial configuration (e.g., 8 data bits, even parity, 1 stop bit).

```cpp
#include <ArduinoRS485.h>

void setup() {
  // 19200 baud, 8 data bits, even parity, 1 stop bit
  RS485.begin(19200, SERIAL_8E1);
}
```

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

### beginTransmission()

Source: https://github.com/arduino-libraries/arduinors485/blob/master/_autodocs/api-reference/rs485-class.md

Enables transmission mode by setting the Drive Output Enable (DE) pin high.

```APIDOC
## beginTransmission()

### Description
Enables transmission mode by setting the Drive Output Enable (DE) pin high.

### Method
```cpp
void beginTransmission()
```

### Parameters
None

### Returns
void

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

void setup() {
  RS485.begin(9600);
}

void loop() {
  RS485.beginTransmission();
  RS485.print("Hello");
  RS485.println(42);
  RS485.endTransmission();
  delay(1000);
}
```
```

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

### RS485 Initialization with Custom Delays

Source: https://github.com/arduino-libraries/arduinors485/blob/master/_autodocs/api-reference/rs485-class.md

Initializes RS-485 communication with a specified baud rate and custom pre-transmission and post-transmission delays. This method uses the default 8N1 serial configuration.

```APIDOC
## `begin(unsigned long baudrate, int predelay, int postdelay)`

### Description
Initializes RS-485 communication with specified baud rate and custom timing delays using default configuration (8N1).

### Method
`void begin(unsigned long baudrate, int predelay, int postdelay)`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
- **baudrate** (unsigned long) - Required - Communication speed in bits per second
- **predelay** (int) - Required - Delay in microseconds before transmission begins after enabling TX mode
- **postdelay** (int) - Required - Delay in microseconds after transmission completes before disabling TX mode

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

void setup() {
  // Initialize with custom timing: 100µs pre-delay, 100µs post-delay
  RS485.begin(9600, 100, 100);
}
```

### Response
#### Success Response (void)
void

#### Response Example
None
```

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

### Set Delays Before Initialization

Source: https://github.com/arduino-libraries/arduinors485/blob/master/_autodocs/usage-patterns.md

Configure transmission delays before calling RS485.begin(). The set delays are preserved across initialization.

```cpp
#include <ArduinoRS485.h>

void setup() {
  RS485.setDelays(100, 150);
  RS485.begin(9600, SERIAL_8E1);  // Delays are preserved
}
```

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

### receive()

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

Enables reception of data over RS-485. This function should be called to prepare the module to listen for incoming messages.

```APIDOC
## receive()

### Description
Enables reception.

### Method
`RS485.receive()`

### Parameters
None.

### Returns
None.

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

void setup() {
  Serial.begin(9600);
  while (!Serial);

  RS485.begin(9600);

  // Enable data reception
  RS485.receive();
}

void loop() {
  if (RS485.available()) {
    Serial.write(RS485.read());
  }
}
```
```

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

### Read and Peek Data with int

Source: https://github.com/arduino-libraries/arduinors485/blob/master/_autodocs/types-and-constants.md

The read(), peek(), and available() functions return an int. A return value of -1 indicates no data is available for read() or peek(). available() returns 0 if no data is present, or the byte count otherwise. Data values are in the range 0-255.

```cpp
// Check for available data
if (RS485.available()) {
  // At least one byte available
  int data = RS485.read();  // Returns 0-255 or -1
  
  if (data != -1) {
    // Successfully read a byte
    byte byteData = (byte)data;
  }
}

// Peek at next byte
int nextByte = RS485.peek();  // Returns 0-255 or -1 if no data
if (nextByte == 0xFF) {
  // Next byte is 0xFF
  RS485.read();  // Now consume it
}
```

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

### Error Handling: Return Values

Source: https://github.com/arduino-libraries/arduinors485/blob/master/_autodocs/architecture.md

Demonstrates how to check for errors using return values from common methods like `write()`, `read()`, and `available()`. A return value of 0 for `write()` indicates transmission failure, while -1 for `read()`/`peek()` signifies no data.

```cpp
// write() returns 0 on failure
size_t result = RS485.write(0xFF);
if (result == 0) {
  // Transmission not active
}

// read()/peek() return -1 on no data
int data = RS485.read();
if (data == -1) {
  // No data available
}

// available() returns 0 on empty buffer
int count = RS485.available();
if (count == 0) {
  // No data waiting
}
```

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

### RS485Class Constructor

Source: https://github.com/arduino-libraries/arduinors485/blob/master/_autodocs/types-and-constants.md

Initializes an RS485Class object with the specified hardware serial port and control pins.

```APIDOC
## RS485Class Constructor

### Description
Constructs an RS485 object, setting up the necessary hardware serial port and control pins for RS485 communication.

### Method
Constructor

### Parameters
- **hwSerial** (HardwareSerial&) - Reference to the hardware serial port to use.
- **txPin** (int) - The digital pin number for transmitting data.
- **dePin** (int) - The digital pin number for the Driver Enable (DE) control.
- **rePin** (int) - The digital pin number for the Receiver Enable (RE) control.
```

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

### Create Custom RS485 Instance with Serial2

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

Instantiate a custom RS485 object using a specific hardware serial port (Serial2) and custom pins for DE, RE, and TX. This allows using a different serial interface than the default.

```cpp
#include <ArduinoRS485.h>

// Create custom instance using Serial2
RS485Class customRS485(Serial2, 10, 11, 12);

void setup() {
  customRS485.begin(9600);  // Use custom instance
}

void loop() {
  customRS485.beginTransmission();
  customRS485.print("Data");
  customRS485.endTransmission();
}
```

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

### RS485Class Constructor

Source: https://github.com/arduino-libraries/arduinors485/blob/master/_autodocs/architecture.md

Initializes the RS485Class object by storing references to the hardware serial port and control pin numbers. It sets the transmission state to false and does not configure pins, deferring that to the begin() method.

```cpp
RS485Class::RS485Class(HardwareSerial& hwSerial, int txPin, int dePin, int rePin)
  : _serial(&hwSerial),
    _txPin(txPin),
    _dePin(dePin),
    _rePin(rePin),
    _transmisionBegun(false)
{
}
```

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

### RS485Class API Reference

Source: https://github.com/arduino-libraries/arduinors485/blob/master/_autodocs/INDEX.md

Detailed documentation of every public method and constructor for the RS485Class.

```APIDOC
## RS485Class API Reference

### Description
This section details all public methods and constructors available in the RS485Class, providing comprehensive information for library users.

### Initialization Methods
- **`begin()`**
  - Four overloaded versions are available, each with complete parameter documentation.
  - Used to initialize the RS485 communication.
- **`end()`**
  - Shuts down the RS485 communication and releases resources.

### Data Reception Methods
- **`available()`**
  - Checks if there is buffered data available for reading.
- **`peek()`**
  - Reads the next byte from the buffer without consuming it.
- **`read()`**
  - Reads and consumes the next byte from the buffer.

### Data Transmission Methods
- **`write()`**
  - Transmits a byte. Includes transmission state checking.
- **`flush()`**
  - Waits until all buffered data has been transmitted.

### Transmission Control
- **`beginTransmission()`**
  - Enables transmitter mode.
- **`endTransmission()`**
  - Disables transmitter mode.

### Reception Control
- **`receive()`**
  - Enables receiver mode.
- **`noReceive()`**
  - Disables receiver mode.

### Signal Control
- **`sendBreak(milliseconds)`**
  - Sends a break signal for a specified duration in milliseconds.
- **`sendBreakMicroseconds(microseconds)`**
  - Sends a break signal for a specified duration in microseconds.

### Configuration
- **`setPins(tx_pin, de_pin, re_pin)`**
  - Configures the control pins for the RS485 transceiver.
- **`setDelays(pre_delay_us, post_delay_us)`**
  - Configures the pre-transmission and post-transmission timing delays in microseconds.

### For Each Method:
- Complete signature with parameter types.
- Parameters table (name, type, default, description).
- Return type and meaning.
- Usage examples with realistic code.
- Implementation notes and behavior details.
- Source file references with line numbers.

### Inherited Methods:
- **Print class methods**: `print()`, `println()`
- **Stream class methods**: Inherited stream functionalities.
- **Operator overloads**: Supported operator overloads.

### Best for:
API reference, method signatures, parameter details, usage examples.
```

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

### RS485Class Constructor

Source: https://github.com/arduino-libraries/arduinors485/blob/master/_autodocs/types-and-constants.md

Initializes the RS485Class object with a hardware serial port and pin assignments.

```cpp
// Constructor
RS485Class(HardwareSerial& hwSerial, int txPin, int dePin, int rePin);
```

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

### Enable RS-485 Reception

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

Use receive() to enable data reception. This snippet demonstrates how to set up reception and read incoming data, printing it to the Serial monitor.

```C++
#include <ArduinoRS485.h>

void setup() {
  Serial.begin(9600);
  while (!Serial);

  RS485.begin(9600);

  // Enable data reception
  RS485.receive();
}

void loop() {
  if (RS485.available()) {
    Serial.write(RS485.read());
  }
}
```

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

### Set Baud Rate for RS485 Communication

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

Initialize the RS485 communication with a specified baud rate. Common rates include 9600 for general use and 115200 for faster communication on compatible boards.

```cpp
#include <ArduinoRS485.h>

void setup() {
  RS485.begin(9600);       // Standard
  RS485.begin(115200);     // Fast
  RS485.begin(19200);      // Industrial/Modbus
}
```

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

### Global RS485 Instance Declaration

Source: https://github.com/arduino-libraries/arduinors485/blob/master/_autodocs/api-reference/rs485-class.md

Declares the global `RS485` instance, which is pre-initialized and ready for use after including the header.

```cpp
extern RS485Class RS485;
```

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

### Conditional Compilation for MBED Platforms

Source: https://github.com/arduino-libraries/arduinors485/blob/master/_autodocs/architecture.md

Uses preprocessor directives to conditionally compile code for MBED-based platforms like Portenta and Opta. This allows for platform-specific initialization, such as enabling RS485 mode on Opta's UART.

```cpp
#ifdef __MBED__
  // MBED-based platforms (Portenta, Opta, Nano)
  RS485Class::RS485Class(HardwareSerial& hwSerial, PinName txPin, PinName dePin, PinName rePin)
#endif

#ifdef ARDUINO_OPTA
  // Special handling for Opta: UART with RS485 mode
  _opta_uart->begin(baudrate, config, true);  // true = RS485 mode
#else
  _serial->begin(baudrate, config);
#endif
```

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

### Peek at Next Incoming Byte

Source: https://github.com/arduino-libraries/arduinors485/blob/master/_autodocs/api-reference/rs485-class.md

The `peek()` function allows you to view the next byte in the receive buffer without removing it. This is useful for inspecting incoming data before deciding whether to read it.

```cpp
#include <ArduinoRS485.h>

void setup() {
  RS485.begin(9600);
  RS485.receive();
}

void loop() {
  if (RS485.available()) {
    int nextByte = RS485.peek();
    // Check the byte without consuming it
    if (nextByte == 0xFF) {
      RS485.read();  // Now consume the byte
    }
  }
}
```

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

### Configure Pins

Source: https://github.com/arduino-libraries/arduinors485/blob/master/_autodocs/INDEX.md

Sets the specific pins used for Transmit (TX), Driver Enable (DE), and Receiver Enable (RE).

```cpp
RS485.setPins(1, 2, 3);
```

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

### Set Delays with int

Source: https://github.com/arduino-libraries/arduinors485/blob/master/_autodocs/types-and-constants.md

Pre-delay and post-delay parameters, measured in microseconds, are set using integers. A common default value is 50µs, with practical ranges up to 10,000µs.

```cpp
RS485.begin(9600, 50, 50);     // 50µs delays
RS485.begin(9600, 100, 100);   // 100µs delays
RS485.setDelays(150, 150);     // 150µs delays
```

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

### Configure RS485 Transmission Delays

Source: https://github.com/arduino-libraries/arduinors485/blob/master/_autodocs/api-reference/rs485-class.md

Sets the pre-delay and post-delay in microseconds for RS485 transmissions. Call this before `begin()` to override default timings.

```cpp
#include <ArduinoRS485.h>

void setup() {
  RS485.setDelays(100, 100);  // Set before calling begin()
  RS485.begin(9600);
}

void loop() {
  RS485.beginTransmission();
  RS485.print("Data");
  RS485.endTransmission();  // Post-delay applied here
  delay(100);
}
```

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

### Custom Pins Configuration

Source: https://github.com/arduino-libraries/arduinors485/blob/master/_autodocs/usage-patterns.md

Configure custom pins for TX, DE, and RE lines before initializing the RS485 library. This provides flexibility in hardware connections.

```cpp
#include <ArduinoRS485.h>

void setup() {
  // Before begin(), configure custom pins
  RS485.setPins(10, 11, 12);  // TX=10, DE=11, RE=12
  RS485.begin(9600);
}

void loop() {
  RS485.beginTransmission();
  RS485.print("Using custom pins");
  RS485.endTransmission();
  delay(100);
}
```

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

### Instantiate ArduinoRS485 with HardwareSerial Reference

Source: https://github.com/arduino-libraries/arduinors485/blob/master/_autodocs/types-and-constants.md

The ArduinoRS485 class can be instantiated with a reference to a HardwareSerial object, allowing the use of different serial ports available on the board. The global RS485 instance defaults to the primary serial port.

```cpp
// Using global RS485 instance (default serial)
#include <ArduinoRS485.h>

void setup() {
  RS485.begin(9600);
}

// Creating custom instance with different serial port
RS485Class customRS485(Serial2, 10, 11, 12);

void setup() {
  customRS485.begin(9600);
}
```

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

### Check Available Bytes for Reading

Source: https://github.com/arduino-libraries/arduinors485/blob/master/_autodocs/api-reference/rs485-class.md

Use `available()` to check if there are any bytes waiting in the receive buffer. This is a non-blocking check and returns the number of bytes ready to be read.

```cpp
#include <ArduinoRS485.h>

void setup() {
  RS485.begin(9600);
  RS485.receive();  // Enable reception
}

void loop() {
  if (RS485.available()) {
    byte data = RS485.read();
    Serial.write(data);
  }
}
```

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

### RS485Class Configuration Methods

Source: https://github.com/arduino-libraries/arduinors485/blob/master/_autodocs/types-and-constants.md

Allows modification of the RS485 transceiver pins and transmission delays.

```cpp
// Configuration
void setPins(int txPin, int dePin, int rePin);
void setDelays(int predelay, int postdelay);
```