Using Modbus RTU and RS485 with Arduino and ESP32 (Part 1/3)

This article will demonstrate how to use an Arduino Mega and ESP32 to read Modbus485 sensors data using a MAX485 and MAX13487E module. The first example is an Arduino Mega with MAX485 to read a ten-in-one sensor. And the second example is using a ESP32 and MAX13487E module to read a temperature and humidity sensor.

This MAX 485 module is cheap and has a simple circuit diagram. However the MAX485 does not offer an automatic direction control and hot swap protection. The need of controlling the flow direction pin makes the module a bit unstable and less easy to use. This module operates at 5V.

Let’s take a look at the sensor’s manual. And we will use function 0x03-Read Holding Registers, to read all the 11 type of data.

The command in hexadecimal is as follow:

Device address	Function Code	Starting Address High	Starting Address Low	Quantity High	Quantity low	CRC High	CRC low
0x01	0x03	0x00	0x00	0x00	0x0B	0x04	0x0D

Device address	Function Code	Number of Bytes	eCO2_H	eCO2_L	TVOC_H	TVOC_L
0x01	0x03	0x16	0x02	0x4A	0x00	0xC4

……	……	MCU_TEMP_H	MCU_TEMP_L	dB_H	dB_L	CRC_H	CRC_L
……	……	0x00	0xC8	0x00	0x42	0x53	0x25

There are one logic zero start bit and one logic one stop bit, the 8-bit data are in between. This communication has a baud rate of 9600.

/*

  RS485_HalfDuplex.pde - example using ModbusMaster library to communicate
  with EPSolar LS2024B controller using a half-duplex RS485 transceiver.

  This example is tested against an EPSolar LS2024B solar charge controller.
  See here for protocol specs:
  http://www.solar-elektro.cz/data/dokumenty/1733_modbus_protocol.pdf

  Library:: ModbusMaster
  Author:: Marius Kintel <marius at kintel dot net>

  Copyright:: 2009-2016 Doc Walker

  Licensed under the Apache License, Version 2.0 (the "License");
  you may not use this file except in compliance with the License.
  You may obtain a copy of the License at

      http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.

*/

#include <ModbusMaster.h>

/*!
  We're using a MAX485-compatible RS485 Transceiver.
  Rx/Tx is hooked up to the hardware serial port at 'Serial'.
  The Data Enable and Receiver Enable pins are hooked up as follows:
*/
#define MAX485_DE      3 //Driver output Enable pin DE Active HIGH
#define MAX485_RE_NEG  2 //receiver output Enable pin RE Active LOW
/////////////////////////In many cases you may also shorting both pin together
// instantiate ModbusMaster object
ModbusMaster node;

void preTransmission()  //set up call back function
{
  digitalWrite(MAX485_RE_NEG, 1);
  digitalWrite(MAX485_DE, 1);
}

void postTransmission()   //set up call back function
{
  digitalWrite(MAX485_RE_NEG, 0);
  digitalWrite(MAX485_DE, 0);
}

void setup()
{
  pinMode(MAX485_RE_NEG, OUTPUT);
  pinMode(MAX485_DE, OUTPUT);
  // Init in receive mode
  digitalWrite(MAX485_RE_NEG, 0);
  digitalWrite(MAX485_DE, 0);

  // Modbus communication runs at 115200 baud
  Serial.begin(9600);
  Serial2.begin(9600); //serial 2: RX2 and TX2 in Arduino Mega
  // Modbus slave ID 1, numbers are in decimal format
  node.begin(1, Serial2);  //data from max 485 are communicating with serial2
  // Callbacks allow us to configure the RS485 transceiver correctly
  node.preTransmission(preTransmission);
  node.postTransmission(postTransmission);
}


void loop()
{
  uint8_t result;  

  // Read 16 registers starting at 0x00, read 11 register. Meaning that read 0x00, then read 0x01, so on and so forth. Until the eleventh resister 0x0A
  result = node.readHoldingRegisters(0x0000, 11);
  if (result == node.ku8MBSuccess)
  {
    Serial.println("------------");
    Serial.print("eCO2: ");
    Serial.println(node.getResponseBuffer(0x00));
    Serial.print("TVOC: ");
    Serial.println(node.getResponseBuffer(0x01));
    Serial.print("CH2O: ");
    Serial.println(node.getResponseBuffer(0x02));
    Serial.print("PM2.5: ");
    Serial.println(node.getResponseBuffer(0x03));
    Serial.print("HUMI: ");
    Serial.println(node.getResponseBuffer(0x04)/100.0f);
    Serial.print("TEMP: ");
    Serial.println(node.getResponseBuffer(0x05)/100.0f);
    Serial.print("PM10: ");
    Serial.println(node.getResponseBuffer(0x06));
    Serial.print("PM1.0: ");
    Serial.println(node.getResponseBuffer(0x07));
    Serial.print("Lux: ");
    Serial.println(node.getResponseBuffer(0x08));
    Serial.print("MCU TEMP: ");
    Serial.println(node.getResponseBuffer(0x09)/100.0f);
    Serial.print("NOISE (dB）: ");
    Serial.println(node.getResponseBuffer(0x0A));
  }
  delay(5000);


}

For ESP32, I switched to another 485 to TTL module, MAX13487E. The MAX13487E supports TTL-side hot swapping and auto direction control, which make this chip much easier to use then MAX485. From the datasheet, the MAX13487E also requires a 5v power . But this module works in my set up, so please take your own risk when powering with 3.3v.

The hexadecimal code ESP32 is sending to the sensor is:

Device address	Function Code	Starting Address High	Starting Address Low	Quantity High	Quantity low	CRC High	CRC low
0x49	0x03	0x00	0x20	0x00	0x02	0xCA	0x49

#include <ModbusMaster.h>
int errorcnt =0;
int cycle =0;

#define RXD2 16
#define TXD2 17

ModbusMaster node;

void setup() {
  Serial.begin(9600);
  Serial2.begin(9600, SERIAL_8N1, RXD2, TXD2); //using serial 2 to read the signal from MAX13487E
  node.begin(73, Serial2);
}

void loop()
{
  uint8_t result;  

  // Read 16 registers starting at 0x3100)
  result = node.readHoldingRegisters(0x20, 2);
  if (result == node.ku8MBSuccess)
  {
    Serial.println("------------");
    Serial.print("Temp: ");
    Serial.println(node.getResponseBuffer(0x00)/10.0f);
    Serial.print("Humi: ");
    Serial.println(node.getResponseBuffer(0x01)/10.0f);

    Serial.print("ERROR count: ");
    Serial.println(errorcnt);    
    Serial.print("cycle: ");
    Serial.println(cycle);  
    cycle++;
  }
  else {
    errorcnt++;
    cycle++;
    Serial.print("ERROR count: ");
    Serial.println(errorcnt);
  }
  delay(5000);

}

There is another common 485 to TTL module using SP3485E. This chip operates with 3.3V and is 5V logic tolerant. The SP3485 does not support auto direction control but uses hardware to latch the enable pin. Please note that the TXD pin is connecting to the TX pin of the MCU, and RXD to RX.

In part 2, we will discuss a few common RS485 to TTL modules and check out which one is more power efficient.