MAX485 TTL to RS485 Modbus Module Interfacing with ESP32

Here we have implemented Modbus to read data from a Modbus RTU device over RS485 using an ESP32.

Connect ESP32 and MAX485 TTL to RS485:

• TX (transmit) pin of ESP32 to MAX485 DI (data in).
• RX (receive) pin of ESP32 to MAX485 RO (receive out).
• ESP32 GPIO pin 16 to MAX485 DE (driver enable) and RE (receiver enable) pins.
• Connect the MAX485 VCC pin to a 5V power source and GND pin to GND.
• Connect MAX485 to the RS485 network.

Install Libraries:

You’ll need to install the ESP32 core for Arduino IDE and SoftwareSerial library.

#include <SoftwareSerial.h>

#define TX_PIN 19
#define RX_PIN 18
#define DE_RE_PIN 4
#define LED_PIN 2

SoftwareSerial Soft_Serial(RX_PIN, TX_PIN);

byte incomingByte[9] = {0};
byte no_Byte = 0;

// Modbus Request Bytes
byte sendBuffer[] = {0x01, 0x03, 0x00, 0x01, 0x00, 0x01, 0xD5, 0xCA}; // Single Read for Temperature
// Modify this array to change the request

float humidity, temperature;

void setup() {
Serial.begin(115200);
Soft_Serial.begin(9600);

pinMode(DE_RE_PIN, OUTPUT); // DE/RE Control pin of RS-485
pinMode(LED_PIN, OUTPUT);
digitalWrite(LED_PIN, HIGH);

Serial.println("\n\nWelcome to JP Learning\n");
}

void loop() {
read_Modbus();

if (no_Byte >= 7) {
if (parseData()) {
if (no_Byte == 9 && incomingByte[1] == 3) {
humidity = parseTemperatureHumidity(3);
Serial.println("\nHumidity = " + String(humidity, 2) + " %\n\n");
} else if (no_Byte == 9 && incomingByte[1] == 4) {
temperature = parseTemperatureHumidity(3);
Serial.println("\nTemperature = " + String(temperature, 2) + " °C\n\n");
}
}
no_Byte = 0;
}
delay(5000);
}

void read_Modbus() {
digitalWrite(DE_RE_PIN, HIGH); // DE/RE=HIGH Transmit Enabled

Soft_Serial.write(sendBuffer, sizeof(sendBuffer));

digitalWrite(DE_RE_PIN, LOW); // DE/RE=LOW Receive Enabled

while (Soft_Serial.available() > 0 && no_Byte < 9) {
incomingByte[no_Byte++] = Soft_Serial.read();
}
}

bool parseData() {
return no_Byte >= 7 && incomingByte[0] == 0x01; // Check minimum data length and slave address
}

float parseTemperatureHumidity(int start) {
int value = incomingByte[start] << 8 | incomingByte[start + 1];
return float(value) / 10;
}

Explanation of how the code is working. Let’s break down how the code works:

• The ESP32 is connected to the RS485 transceiver (MAX485) via Software Serial.
• GPIO pin 4 is used to control the DE (Driver Enable) and RE (Receiver Enable) pins of the RS485 transceiver.
• Another GPIO pin is used to control an LED, which could indicate various statuses of the system.

• The code begins by including necessary libraries and defining pin assignments.

• Inside the setup() function, serial communication is initiated for debugging purposes.
• SoftwareSerial is configured with the specified pins and baud rate.
• DE/RE and LED pins are set as outputs, and the LED is turned on.

• The loop() function continuously reads data from the Modbus RTU device in intervals of 5 seconds.

• The read_Modbus() function is responsible for initiating the Modbus request, receiving the response, and storing it in the incomingByte array.
• It enables transmission by setting DE/RE pin to HIGH, sends the Modbus request, then switches to receive mode by setting DE/RE pin to LOW.
• While data is available on the SoftwareSerial buffer, it’s read byte by byte and stored in the incomingByte array until a complete response is received.

• The parseData() function checks if the received data is valid and interpretable. It verifies the slave address and minimum data length.
• The parseTemperatureHumidity() function extracts temperature or humidity values from the Modbus response, depending on the function’s parameter start.

• Once a valid Modbus response is received and parsed, the temperature or humidity value is displayed on the Serial monitor.
• If the Modbus function code is 3 (read holding registers), it interprets the data as humidity.
• If the function code is 4 (read input registers), it interprets the data as temperature.

• The sendBuffer array contains the Modbus request bytes.
• The request is sent out to the Modbus RTU device to request data.
• It specifies the device address, function code, register address, and number of registers to read.

• The Modbus response is received in a byte-wise manner.
• The response includes the slave address, function code, and data.
• The data section contains the requested information (temperature or humidity).

• The LED is used as an indicator. It’s turned on initially and can be used for various purposes such as indicating system activity or status.

• After each data reading and processing cycle, there’s a delay of 5 seconds (delay(5000)) before the next cycle begins.

That’s the breakdown of how the code works! It essentially sends a Modbus request to the slave device, receives the response, parses the data, and then displays it.

• Upload the code to your ESP32.
• Connect your ESP32 to the Modbus network and verify connections.
• Monitor the serial output to see if the communication is successful.