How to use Modbus RTU with ESP32 to read Sensor Data

Overview

In this tutorial, we’ll dive into the Modbus RTU protocol and learn how to implement it with an ESP32 to read sensor data from a slave device using RS485. We’ll focus on using a humidity and temperature sensor that operates under the Modbus RTU protocol to simplify and enhance our understanding. The ESP32 will be programmed to retrieve sensor data using RS-485, providing a hands-on approach to understanding this communication method.

Modbus is a communication protocol initially developed in 1979 for use with programmable logic controllers (PLCs). Over the years, it has evolved into a standard protocol widely adopted in the industry for connecting a variety of industrial electronic devices.

Modbus RTU (Remote Terminal Unit) is a specific variant of the Modbus protocol that employs binary coding and serial communication for fast data transmission. It is particularly prevalent in industrial settings where it links sensors, instruments, and actuaries to controllers and computers, primarily through RS-485 serial interfaces. This makes it ideal for applications requiring robust and reliable data exchange over longer distances or in electrically noisy environments.

Components Required

To learn, how to implement Modbus RTU protocol with ESP32, we need the following components.

S.N.	Components Name	Quantity	Purchase Link
1	ESP32 Board	1	Amazon \| AliExpress
2	MAX485 Modbus Module	1	Amazon \| AliExpress
3	RS485 Temperature Humidity Sensor	1	AliExpress
4	Connecting Wires	10	Amazon \| AliExpress
5	Breadboard	2	Amazon \| AliExpress

What is Modbus?

Modbus is a serial communication protocol developed by Modicon in 1979, initially designed for Modicon programmable logic controllers (PLCs) for industrial applications. Over time, it has become a standard protocol used widely across various automation products to connect industrial electronic devices. Modbus is particularly useful for monitoring and communicating between intelligent devices, sensors, or instruments, and for managing field devices using computers and Human Machine Interfaces (HMIs). It is also well-suited for Remote Terminal Unit (RTU) applications that require wireless communication, making it ideal for gas and oil substation applications due to its openness, simplicity, low-cost development, and minimal hardware requirements.

In a typical Modbus network, there is one master device and up to 247 slave devices, each with a unique address. The master device orchestrates the data management and writes data to the slaves. Data transfer in Modbus is in the form of binary bits—zeroes and ones—which represent positive and negative voltages respectively. These bits are transmitted rapidly between devices due to their small size.

There are three main variations of the Modbus protocol:

Modbus ASCII
Modbus RTU
Modbus TCP/IP

These variations accommodate different types of networks and data transmission requirements.

What is Modbus RTU?

Modbus RTU (Remote Terminal Unit) is a widely utilized serial communication protocol in building management and industrial automation systems.

It facilitates the connection and communication between various devices, such as controllers, sensors, and actuators, often in environments where the devices may be spread over distances up to 15 meters. This protocol operates on a point-to-point basis, featuring a single master device that communicates with one or more slave devices in a network.

Technically, Modbus RTU employs binary data encoding for efficient data transmission and includes CRC (Cyclic Redundancy Check) error checking to ensure the integrity of data during transmission. This robust error-checking mechanism helps prevent data corruption across the physical network.

Modbus RTU is strictly confined to its specific communication standards, meaning devices configured for different modes (e.g., ASCII versus RTU) cannot interact. For instance, a device set up for ASCII communication will not be able to interpret data from a device sending data in RTU binary format.

The physical layer of Modbus RTU typically uses one of three types of electrical interfaces:

RS-232: Suitable for short-distance communications and often used for connections between a device and a PC.
RS-485: The most common interface for Modbus RTU, allowing for longer distances and the connection of multiple devices on a single bus network.
RS-422: Similar to RS-485 but with greater resistance to electrical noise, suitable for industrial environments.

Additionally, the technical implementation of Modbus RTU includes defining slave IDs, function codes, and the structure of data packets, which consist of addresses, data values, and checksums to validate the communication. This meticulous organization enables precise control and monitoring of networked devices in complex systems.

MAX485 Module for RS-485 communication

The MAX485 IC is a low-power transceiver designed for RS-485 communication. It is widely used in industrial and commercial applications for robust, long-distance data transmission.

There are a few types of MAX485 modules available in the market. One of them is a basic MAX485 circuit board with input and output pins for direct interfacing. In addition to the TX and RX signals, you also need to control the RE and DE pins.

Another type is one that comes along with a CD4069 hex-inverter IC. The CD4069 on the module automatically drives the DE and RE pins of the MAX485 IC when you transmit or receive messages. This simplifies the operation and programming.

This IC supports half-duplex communication, allowing data to be transmitted and received over a single pair of wires, though not simultaneously. It includes driver enable and receiver enable pins, which can be controlled to switch between transmitting and receiving modes. It is a half-duplex driver with a Unit Load (UL) rating of 1 and therefore you can have up to 32 MAX485s on a single RS-485 bus.

You can learn more about RS-485 communication using the following tutorials:

RS485 Temperature and Humidity Sensor

This is one of the temperature humidity sensors that work on the Standard Modbus RTU protocol.

We will be using this sensor in this guide. We will interface the temperature humidity sensor with Arduino & using the RS-485 we can use standard Modbus RTU to read the sensor data.

Product Specifications

Power Supply: 5-30V DC
Maximum Power Consumption: ≤ 5W
Humidity Range: 0-100% RH
Temperature Range: -40° to 80° C
Accuracy: Temperature ± 0.3 °C; Humidity ± 0.3% RH
Communication Protocol: Standard Modbus RTU
Communication Mode: 485 communication
Baud Rate: 9600 (default), 1200, 2400, 4800, 9600, 19200 (can be set by software)
Default Address of Equipment: Default 1 (1~254 can be modified by software)
Register: Humidity address 0, temperature address 1 (software modifiable)
Wiring Mode: Red+, black GND, Yellow A+, Green B-

Communication Protocol Details

Basic Communication Parameters

Parameter	Specification
Coding	8 bit binary
Data Bits	8bit
Parity Bit	None
Stop Bit	1bit
Error Checking	CRC (redundant cyclic code)
Baud Rate	1200bit/s, 2400bit/s, 4800bit/s, 9600 bit/s, 14400 bit/s, 19200 bit/s (Factory default is 9600bit/s)

Data Frame Format Definition

Component	Specification
Initial Structure	≥ 4 bytes of time
Address Code	1 byte
Function Code	1 byte
Data Area	N bytes
Error Check	16-bit CRC code
Time to End Structure	≥ 4 bytes

Address code: the address of the transmitter, which is unique in the communication network (factory default 0x01).

Function code: the function instruction of the command sent by the host, this transmitter only uses the function code 0x03 (read register data).

Data area: The data area is the specific communication data, pay attention to the high byte of the 16 bits data first!

CRC code: two-byte check code.

Host Query Frame Structure:

Component	Address Code	Function Code	Register Start Address	Register Length	Check Code Low	Check Code High
Size	1 byte	1 byte	2 bytes	2 bytes	1 byte	1 byte

Slave Acknowledgment Frame Structure:

Component	Address Code	Function Code	Number of Valid Bytes	Data Area	Second Data Area	Check Code
Size	1 byte	1 byte	1 byte	2 bytes	2 bytes	2 bytes

Register Address

Register Address (Hex)	PLC or Configuration Address	Content	Operate	Support Function Code
0000 H	40001	Humidity (10 times the actual value)	Read only	03
0001 H	40002	Temperature (10 times the actual value)	Read only	03
0100H	40257	Baud rate address	Read and write	03, 06
0102 H	40259	Humidity address	Read and write	03, 06
0104H	40260	Temperature correction value	Read and write	03, 06
0105H	40261	Humidity correction value	Read and write	03, 06

Read the Temperature and Humidity Value of Device Address 0x01

Query Frame (hexadecimal):

Address Code	Function Code	Initial Address	Data Length	Check Code Low	Check Code High
0x01	0x03	0x00 0x02	0x00 0x02	0xC4	0x08

Response Frame (hexadecimal): (For example, the temperature is -9.7°C and the humidity is 48.6%RH)

Address Code	Function Code	Number of Valid Bytes	Humidity Value	Temperature Value	Check Code Low	Check Code High
0x01	0x03	0x04	0x01 E6	0xFF 0x9F	0x1B	0xA0

Temperature Calculation: When the temperature is lower than 0 °C, the temperature data is uploaded in the form of complement code. Temperature: FF9F H (hex) = -97 => Temperature = -9.7°C

Humidity Calculation: Humidity: 1E6 H (Hex) = 486 => Humidity = 48.6%RH

How to use Modbus RTU with ESP32 to read Sensor Data

Now let’s dive into the practical aspects. In this section, we will learn how to connect a humidity and temperature sensor to an ESP32 using RS485 and program the ESP32 for communication using the Modbus RTU protocol.

First, we’ll establish the hardware connections using specified pins on the ESP32. After setting up the physical connections, we’ll move on to writing code specifically tailored for the ESP32, enabling Modbus RTU communication.

Hardware Setup & Connection

Here is the connection diagram between ESP32 RS485 and Modbus RTU based Sensor.

In this connection, we will use UART2 of ESP32 for Serial Communication with RS485. Connect the Tx and Rx of MAX485 with GPIO17 and GPIO16 of ESP32. Power the MAX485 Module with a 3.3V or 5V supply.

Similarly, for the Temperature and Humidity Sensor part, connect the A+ of MAX485 to the Yellow Wire (A+) of the Sensor. Connect the B- of MAX485 to the Green Wire (B-) of the Sensor. Power the sensor with 5V Power supply.

You may simply use a connecting wire and breadboard for this setup. The above image is the example how I set the connection. Finally connect the ESP32 to your computer using the USB Cable to power it on.

Source Code/Program

Lets move to the programming part of the Modbus RTU Communication using ESP32 & RS485 Module. The code doesn’t use any standard Modbus library. Rather the whole code is written for direct communication with serial interface.

This code sets up an ESP32 to communicate with a MAX485 module using the HardwareSerial library, targeting UART2 for transmission and reception. It configures the ESP32 to send and receive Modbus RTU frames to read data from a slave device.

The program constructs and sends Modbus requests, receives responses, checks their integrity with CRC validation, and processes the data to display humidity and temperature readings on a serial monitor.

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

#include <HardwareSerial.h>

// Create a HardwareSerial object to communicate with the MAX485 module

HardwareSerial mySerial(2); // Using UART2 (TX2, RX2)

// Define Modbus parameters

const byte slaveAddress = 0x01; // Address of the Modbus slave device

const byte functionCode = 0x03; // Function code to read holding registers

const byte startAddressHigh = 0x00; // High byte of the starting address

const byte startAddressLow = 0x00; // Low byte of the starting address

const byte registerCountHigh = 0x00; // High byte of the number of registers to read

const byte registerCountLow = 0x02; // Low byte of the number of registers to read

void setup() {

// Initialize serial communication for debugging

Serial.begin(115200);

// Initialize HardwareSerial for Modbus communication

mySerial.begin(9600, SERIAL_8N1, 16, 17); // RX=16, TX=17 for UART2

// Allow some time for initialization

delay(1000);

}

void loop() {

// Create a request frame for Modbus communication

byte requestFrame[8];

constructModbusRequest(requestFrame, slaveAddress, functionCode, startAddressHigh, startAddressLow, registerCountHigh, registerCountLow);

// Send the Modbus request frame

sendModbusRequest(requestFrame, 8);

// Read and process the Modbus response frame

if (mySerial.available()) {

// Create a buffer to store the response frame

byte responseFrame[9];

// Read the response frame from the slave device

readModbusResponse(responseFrame, 9);

// Verify the CRC of the received response frame

if (verifyCRC(responseFrame, 9)) {

// Process the response frame to extract data

processModbusResponse(responseFrame);

} else {

// Print an error message if CRC verification fails

Serial.println("CRC error.");

}

} else {

// Print an error message if no response is received

Serial.println("No response from slave.");

}

// Wait for 2 seconds before the next request

delay(2000);

}

// Function to construct a Modbus request frame

void constructModbusRequest(byte *frame, byte address, byte function, byte startHigh, byte startLow, byte countHigh, byte countLow) {

frame[0] = address; // Address of the slave device

frame[1] = function; // Function code

frame[2] = startHigh; // High byte of the starting address

frame[3] = startLow; // Low byte of the starting address

frame[4] = countHigh; // High byte of the number of registers to read

frame[5] = countLow; // Low byte of the number of registers to read

// Calculate and append the CRC to the request frame

uint16_t crc = calculateCRC(frame, 6);

frame[6] = crc & 0xFF; // CRC low byte

frame[7] = (crc >> 8) & 0xFF; // CRC high byte

}

// Function to send a Modbus request frame

void sendModbusRequest(byte *frame, byte length) {

for (byte i = 0; i < length; i++) {

mySerial.write(frame[i]); // Send each byte of the frame

}

// Function to read a Modbus response frame

void readModbusResponse(byte *frame, byte length) {

for (byte i = 0; i < length; i++) {

if (mySerial.available()) {

frame[i] = mySerial.read(); // Read each byte of the frame

}

// Function to verify the CRC of a Modbus frame

bool verifyCRC(byte *frame, byte length) {

uint16_t receivedCRC = (frame[length - 1] << 8) | frame[length - 2]; // Extract the received CRC

// Calculate the CRC of the received frame (excluding the received CRC bytes)

return calculateCRC(frame, length - 2) == receivedCRC;

}

// Function to process the Modbus response frame and extract data

void processModbusResponse(byte *frame) {

// Extract the humidity and temperature data from the response frame

uint16_t humidity = (frame[3] << 8) | frame[4];

uint16_t temperature = (frame[5] << 8) | frame[6];

// Convert the raw data to actual values

float humidityValue = humidity / 10.0;

float temperatureValue = temperature / 10.0;

// Print the humidity and temperature values to the Serial Monitor

Serial.print("Humidity: ");

Serial.print(humidityValue);

Serial.println(" %RH");

Serial.print("Temperature: ");

Serial.print(temperatureValue);

Serial.println(" °C");

}

// Function to calculate the CRC of a Modbus frame

uint16_t calculateCRC(byte *frame, byte length) {

uint16_t crc = 0xFFFF; // Initialize CRC to 0xFFFF

for (byte i = 0; i < length; i++) {

crc ^= frame[i]; // XOR the frame byte with the CRC

for (byte j = 0; j < 8; j++) {

if (crc & 0x0001) { // Check if the LSB of the CRC is 1

crc >>= 1; // Right shift the CRC

crc ^= 0xA001; // XOR the CRC with the polynomial 0xA001

} else {

crc >>= 1; // Right shift the CRC

}

return crc; // Return the calculated CRC

}

Copy the above code to the editor window of your Arduino IDE. Select the ESP32 Board from the board list. Select the correct COM port. The upload the code.

Once the code get uploaded, open the Serial Monitor. You will be see the temperature and humidity data displayed correctly.

This is how you can implement the Modbus protocol with ESP32 microcontroller to read the sensor register data.

This setup lets you successfully read data from sensors, making it a practical guide for anyone looking to integrate ESP32 with Modbus RTU based industrial systems for monitoring and controlling devices.