Example application with hardware #112
Replies: 6 comments 10 replies
-
Sample modbus serverMy sample modbus server consists of an Arduino Uno, connected to a RS485-to-TTL converter half-duplex with auto-direction. firmwareThe modbus server listens on // Copyright 2020 Michael Harwerth
#include <Arduino.h>
// Built-in LED
#define LED 13
// MODBUS memory
#define MEMSIZE 256
uint8_t data[MEMSIZE];
// MODBUS request buffer
// normal size is 8 (ID, FC, address 16bit, words 16bit)
// but we may catch packets for other purposes in future
#define INPACKETSIZE 32
uint8_t inPacket[INPACKETSIZE];
uint16_t inPacketLen;
// MODBUS response buffer
// maximum size is 3 (ID,FC,Byte count) + 255 (payload bytes) + 2 (CRC) = 260
#define OUTPACKETSIZE 260
uint8_t outPacket[OUTPACKETSIZE];
uint16_t outPacketLen(0);
// Own MODBUS slave ID
uint8_t ownID(3);
// State machine states
enum STATES : uint8_t { INIT=0, IDLE, PAUSE, IN_PACKET, PROCESS };
STATES state = INIT;
const char *statenames[] = { "INIT", "IDLE", "PAUSE", "IN_PACKET", "PROCESS" };
const uint32_t BAUDRATE(19200);
// CRC16 tables and calculation function
const uint8_t crcHiTable[] PROGMEM = {
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81,
0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01,
0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81,
0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0,
0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01,
0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81,
0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01,
0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81,
0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01,
0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81,
0x40
};
const uint8_t crcLoTable[] PROGMEM = {
0x00, 0xC0, 0xC1, 0x01, 0xC3, 0x03, 0x02, 0xC2, 0xC6, 0x06, 0x07, 0xC7, 0x05, 0xC5, 0xC4,
0x04, 0xCC, 0x0C, 0x0D, 0xCD, 0x0F, 0xCF, 0xCE, 0x0E, 0x0A, 0xCA, 0xCB, 0x0B, 0xC9, 0x09,
0x08, 0xC8, 0xD8, 0x18, 0x19, 0xD9, 0x1B, 0xDB, 0xDA, 0x1A, 0x1E, 0xDE, 0xDF, 0x1F, 0xDD,
0x1D, 0x1C, 0xDC, 0x14, 0xD4, 0xD5, 0x15, 0xD7, 0x17, 0x16, 0xD6, 0xD2, 0x12, 0x13, 0xD3,
0x11, 0xD1, 0xD0, 0x10, 0xF0, 0x30, 0x31, 0xF1, 0x33, 0xF3, 0xF2, 0x32, 0x36, 0xF6, 0xF7,
0x37, 0xF5, 0x35, 0x34, 0xF4, 0x3C, 0xFC, 0xFD, 0x3D, 0xFF, 0x3F, 0x3E, 0xFE, 0xFA, 0x3A,
0x3B, 0xFB, 0x39, 0xF9, 0xF8, 0x38, 0x28, 0xE8, 0xE9, 0x29, 0xEB, 0x2B, 0x2A, 0xEA, 0xEE,
0x2E, 0x2F, 0xEF, 0x2D, 0xED, 0xEC, 0x2C, 0xE4, 0x24, 0x25, 0xE5, 0x27, 0xE7, 0xE6, 0x26,
0x22, 0xE2, 0xE3, 0x23, 0xE1, 0x21, 0x20, 0xE0, 0xA0, 0x60, 0x61, 0xA1, 0x63, 0xA3, 0xA2,
0x62, 0x66, 0xA6, 0xA7, 0x67, 0xA5, 0x65, 0x64, 0xA4, 0x6C, 0xAC, 0xAD, 0x6D, 0xAF, 0x6F,
0x6E, 0xAE, 0xAA, 0x6A, 0x6B, 0xAB, 0x69, 0xA9, 0xA8, 0x68, 0x78, 0xB8, 0xB9, 0x79, 0xBB,
0x7B, 0x7A, 0xBA, 0xBE, 0x7E, 0x7F, 0xBF, 0x7D, 0xBD, 0xBC, 0x7C, 0xB4, 0x74, 0x75, 0xB5,
0x77, 0xB7, 0xB6, 0x76, 0x72, 0xB2, 0xB3, 0x73, 0xB1, 0x71, 0x70, 0xB0, 0x50, 0x90, 0x91,
0x51, 0x93, 0x53, 0x52, 0x92, 0x96, 0x56, 0x57, 0x97, 0x55, 0x95, 0x94, 0x54, 0x9C, 0x5C,
0x5D, 0x9D, 0x5F, 0x9F, 0x9E, 0x5E, 0x5A, 0x9A, 0x9B, 0x5B, 0x99, 0x59, 0x58, 0x98, 0x88,
0x48, 0x49, 0x89, 0x4B, 0x8B, 0x8A, 0x4A, 0x4E, 0x8E, 0x8F, 0x4F, 0x8D, 0x4D, 0x4C, 0x8C,
0x44, 0x84, 0x85, 0x45, 0x87, 0x47, 0x46, 0x86, 0x82, 0x42, 0x43, 0x83, 0x41, 0x81, 0x80,
0x40
};
inline uint16_t CRC16(uint8_t* msg, size_t len)
{
register uint8_t crcHi = 0xFF;
register uint8_t crcLo = 0xFF;
register uint8_t index;
while (len--) {
index = crcLo ^ *msg++;
crcLo = crcHi ^ pgm_read_byte(&crcHiTable[index]);
crcHi = pgm_read_byte(&crcLoTable[index]);
}
return (crcHi << 8 | crcLo);
}
// Return MODBUS error packet
void error(uint8_t code, uint8_t err)
{
outPacketLen = 0;
outPacket[outPacketLen++] = ownID;
outPacket[outPacketLen++] = code|0x80;
outPacket[outPacketLen++] = err;
uint16_t crc = CRC16(outPacket, outPacketLen);
outPacket[outPacketLen++] = crc&0xFF;
outPacket[outPacketLen++] = (crc>>8)&0xFF;
Serial.write(outPacket, outPacketLen);
Serial.flush();
}
void setup()
{
// Init LED
pinMode(LED, OUTPUT);
digitalWrite(LED, LOW);
// Start MODBUS
Serial.begin(BAUDRATE);
// Fill memory with test data
uint8_t c = 0x20;
for (uint16_t i= 0; i<MEMSIZE; i++)
{
data[i] = c++;
if (c>127) c = 0x20;
}
}
void loop()
{
static uint8_t readByte = 0;
// PAUSETIME gives the required silence time on the bus to detect a new packet.
// With 19200/s, a byte takes about 0.52 ms, so we are waiting for a pause of
// approx. 1822us here!
// (The MODBUS standard is requiring >3.5)
const uint32_t PAUSETIME = 35000000UL/BAUDRATE;
static uint32_t starttime = micros();
switch (state)
{
case INIT: // Init means skip to pause, so next data will be a packet most probably
// Read all available bytes into the bin
while (Serial.available()) readByte = Serial.read();
state = PAUSE;
starttime = micros();
// No break; - Fallthrough intended!
case PAUSE: // Discard all bytes, then wait for a PAUSETIME gap
// PAUSETIME passed without a byte?
if (micros()-starttime>=PAUSETIME)
{
// Yes. Rewind timer to open I²C writing with a delay
starttime = micros();
// Go look for a packet
state = IDLE;
}
// No, but is a byte available?
else if (Serial.available())
{
// Yes, there is one. Pause was interrupted - skip to next pause
state = INIT;
}
break;
case IDLE: // Waiting for a packet after the pause
// Do we have a byte? It will be the first of a packet = Slave ID
if (Serial.available())
{
// Yes. Is it our own slave ID?
readByte = Serial.read();
if (readByte!=ownID)
{
// No. Skip packet and wait for the next
state = INIT;
}
else
{
// This is for us - go collect the packet
inPacketLen = 0;
inPacket[inPacketLen++] = readByte;
// Signal to D0 processor to stop sending data
state = IN_PACKET;
starttime = micros();
}
}
break;
case IN_PACKET: // We caught a byte of a packet addressed to us
// If a byte is available...
if (Serial.available())
{
while (Serial.available())
{
// Catch it.
readByte = Serial.read();
if (inPacketLen<INPACKETSIZE)
{
inPacket[inPacketLen++] = readByte;
}
else
{
// Overflow... Discard all data
state = INIT;
break;
}
}
starttime = micros();
}
// Did we encounter a gap time again?
if (micros() - starttime >= PAUSETIME)
{
// Yes. Process data
state = PROCESS;
}
break;
case PROCESS: // we seem to have caught a packet.
{
digitalWrite(LED, HIGH);
uint8_t fc = inPacket[1];
// Is the function code right?
switch (fc) {
case 0x03:
case 0x04:
// Sufficcient data for FC 0x03/0x04?
if (inPacketLen==8)
{
// Yes, fc is okay, get address to read
uint16_t addr = (inPacket[2]<<8)|inPacket[3];
// Is it out of bounds?
if (addr<1 || addr>(MEMSIZE/2))
{
// Yes, return error
error(fc, 0x02);
} else {
// No, address is okay. get number of words requested
uint16_t wrds = (inPacket[4]<<8)|inPacket[5];
uint16_t byts = wrds * 2;
// Words out of bounds?
if (!wrds || byts>255 || byts>(OUTPACKETSIZE-5) || addr-1+wrds>(MEMSIZE/2))
{
// Yes, return error
error(fc, 0x02);
} else {
// No, words will fit in memory.
// Check if packet is intact
if (CRC16(inPacket, inPacketLen-2)!=(uint16_t)((inPacket[7]<<8)|inPacket[6]))
{
// No, seems to be corrupt
error(fc, 0xE3);
} else {
// Packet is intact. Build response packet and return it
outPacketLen = 0;
outPacket[outPacketLen++] = ownID;
outPacket[outPacketLen++] = fc;
outPacket[outPacketLen++] = byts;
// We should have the complete response now - move it to the response packet
memcpy(outPacket+outPacketLen, data + (addr-1)*2, byts);
outPacketLen += byts;
// Calculate CRC for the response packet
uint16_t crc = CRC16(outPacket, outPacketLen);
outPacket[outPacketLen++] = crc&0xFF;
outPacket[outPacketLen++] = (crc>>8)&0xFF;
// Write response to MODBUS requester
Serial.write(outPacket, outPacketLen);
Serial.flush();
}
}
}
} else {
// Return packet length mismatch
error(fc, 0xE5);
}
break;
case 0x06:
// Sufficcient data for FC 0x06?
if (inPacketLen==8)
{
// Yes, fc is okay, get address to read
uint16_t addr = (inPacket[2]<<8)|inPacket[3];
// Is it out of bounds?
if (addr<1 || addr>(MEMSIZE/2))
{
// Yes, return error
error(fc, 0x02);
} else {
// No, address is okay. get data to be written
uint16_t dword = (inPacket[5]<<8)|inPacket[4];
// Check if packet is intact
if (CRC16(inPacket, inPacketLen-2)!=(uint16_t)((inPacket[7]<<8)|inPacket[6]))
{
// No, seems to be corrupt
error(fc, 0xE3);
} else {
// Packet is intact. Write data, Build response packet and return it
memcpy(data + (addr - 1) * 2, &dword, 2);
outPacketLen = 8;
memcpy(outPacket, inPacket, 8);
// Write response to MODBUS requester
Serial.write(outPacket, outPacketLen);
Serial.flush();
}
}
}
break;
case 0x10:
// Sufficcient data for FC 0x10?
if (inPacketLen > 9 && inPacketLen == ((uint8_t)9 + inPacket[6]))
{
// Yes, fc is okay, get address to read
uint16_t addr = (inPacket[2]<<8)|inPacket[3];
// Is it out of bounds?
if (addr<1 || addr>(MEMSIZE/2))
{
// Yes, return error
error(fc, 0x02);
} else {
// No, address is okay. Get data count to be written
uint8_t count = inPacket[6];
// Check if packet is intact
if (CRC16(inPacket, inPacketLen-2)!=(uint16_t)((inPacket[inPacketLen-1]<<8)|inPacket[inPacketLen-2]))
{
// No, seems to be corrupt
error(fc, 0xE3);
} else {
// Packet is intact. Write data, Build response packet and return it
memcpy(data + (addr - 1) * 2, inPacket+7, count);
outPacketLen = inPacketLen;
memcpy(outPacket, inPacket, inPacketLen);
// Write response to MODBUS requester
Serial.write(outPacket, outPacketLen);
Serial.flush();
}
}
}
break;
default:
error(fc, 0x01);
break;
}
digitalWrite(LED, LOW);
state = INIT;
}
break;
}
}
|
Beta Was this translation helpful? Give feedback.
-
Modbus client (esp32)This is where this library comes to play! To compile the firmware, I used Platformio but Arduino IDE will do as well. #include <Arduino.h>
// Include the header for the ModbusClient RTU style
#include "ModbusClientRTU.h"
#include "Logging.h"
// Definitions for this special case
#define RXPIN GPIO_NUM_5
#define TXPIN GPIO_NUM_18
#define REDEPIN GPIO_NUM_19
#define BAUDRATE 19200
#define FIRST_REGISTER 0x0001
#define NUM_VALUES 2
#define READ_INTERVAL 10000
bool data_ready = false;
float values[NUM_VALUES];
uint32_t request_time;
// Create a ModbusRTU client instance
// The RS485 module has no halfduplex, so the second parameter with the DE/RE pin is required!
ModbusClientRTU MB(Serial1, REDEPIN);
// Define an onData handler function to receive the regular responses
// Arguments are received response message and the request's token
void handleData(ModbusMessage response, uint32_t token)
{
// First value is on pos 3, after server ID, function code and length byte
uint16_t offs = 3;
// The device has values all as IEEE754 float32 in two consecutive registers
// Read the requested in a loop
for (uint8_t i = 0; i < NUM_VALUES; ++i) {
offs = response.get(offs, values[i]);
}
// Signal "data is complete"
request_time = token;
data_ready = true;
}
// Define an onError handler function to receive error responses
// Arguments are the error code returned and a user-supplied token to identify the causing request
void handleError(Error error, uint32_t token)
{
// ModbusError wraps the error code and provides a readable error message for it
ModbusError me(error);
LOG_E("Error response: %02X - %s\n", (int)me, (const char *)me);
}
// Setup() - initialization happens here
void setup() {
// Init Serial monitor
Serial.begin(115200);
while (!Serial) {}
Serial.println("__ OK __");
// Set up Serial2 connected to Modbus RTU
Serial1.begin(BAUDRATE, SERIAL_8N1, RXPIN, TXPIN);
// Set up ModbusRTU client.
// - provide onData handler function
MB.onDataHandler(&handleData);
// - provide onError handler function
MB.onErrorHandler(&handleError);
// Set message timeout to 2000ms
MB.setTimeout(2000);
// Start ModbusRTU background task
MB.begin();
}
// loop() - cyclically request the data
void loop() {
static uint32_t next_request = millis();
// Shall we do another request?
if (millis() - next_request > READ_INTERVAL) {
// Yes.
data_ready = false;
// Issue the request
Error err = MB.addRequest(millis(), 3, READ_INPUT_REGISTER, FIRST_REGISTER, NUM_VALUES * 2);
if (err!=SUCCESS) {
ModbusError e(err);
LOG_E("Error creating request: %02X - %s\n", (int)e, (const char *)e);
}
// Save current time to check for next cycle
next_request = millis();
} else {
// No, but we may have another response
if (data_ready) {
// We do. Print out the data
Serial.printf("Requested at %8.3fs:\n", request_time / 1000.0);
for (uint8_t i = 0; i < NUM_VALUES; ++i) {
Serial.printf(" %04X: %8.3f\n", i * 2 + FIRST_REGISTER, values[i]);
}
Serial.printf("----------\n\n");
data_ready = false;
}
}
}[platformio]
default_envs = esp32
[env]
framework = arduino
lib_extra_dirs =
../libraries
monitor_speed = 115200
[common]
build_flags=
-Wall
-DLOG_LEVEL=LOG_LEVEL_DEBUG
[env:esp32]
platform = espressif32
board = esp32dev
build_flags =
${common.build_flags}
;-D DEBUG_ESP_PORT=Serial
monitor_filters = esp32_exception_decoder |
Beta Was this translation helpful? Give feedback.
-
|
I'm trying to recreate your set-up and the following section of code will not compile: I checked the source ( Thank you for your work and example! |
Beta Was this translation helpful? Give feedback.
-
|
Use |
Beta Was this translation helpful? Give feedback.
-
|
Now the compiler is stating that there is not a "start" member. |
Beta Was this translation helpful? Give feedback.
-
|
Sorry, I was not fully awake when I posted the last answer 😊 In fact Have a look at the docs on RTU to see more detail. |
Beta Was this translation helpful? Give feedback.
-
|
No worries! The example in RTU04example/main.cpp compiled fine, so now I can read and learn. The reason that I liked this example was because it used both an Arduino UNO and an ESP32, which is what I have available. Now to figure out why the client (ESP32) isn't getting a response from the server (UNO). |
Beta Was this translation helpful? Give feedback.
-
OutputWith the above circuit and code, you should get these results: esp32 Serial monitor: Logic analyzer images:
Request: Response: |
Beta Was this translation helpful? Give feedback.
-
|
Wonderful work indeed. Thanks a lot for undergoing that! Do I understand that with the proper termination, everything runs fine without any changes? |
Beta Was this translation helpful? Give feedback.
-
|
Yes. |
Beta Was this translation helpful? Give feedback.
This comment has been hidden.
This comment has been hidden.
-
|
Willdo. I'm doing some tests with "troubleshooting" now. What happens if... |
Beta Was this translation helpful? Give feedback.
-
|
I'll be damned. I can't make it fail again. |
Beta Was this translation helpful? Give feedback.
-
|
Must be my sturdy Nano server 😁 |
Beta Was this translation helpful? Give feedback.
-
|
Got it. By removing the bias it generates the faulty start bit on the rx line, resulting in 0x00. |
Beta Was this translation helpful? Give feedback.
-
Troubleshooting:
By adding biasing, the max3485's On the Serial monitor of the esp32, the error message looks like this: |
Beta Was this translation helpful? Give feedback.
-
Circuit
This is an example circuit for the ESP32 side. Keep in mind that biasing resistors (the two 680Ohms resistors) need to be added only once on the entire bus. The terminating resistors have to be added on both ends of the bus and only there.
I use a MAX3485 which is similar to the MAX485 but can be powered by 3.3V. Some people have success with running a MAX485 on 3.3V but I like to operate within specification.
The A-line (non-inverting) is pulled up to 3.3V and line B (inverting) is pulled down to ground using 680Ohm resistors. A 120Ohm resistor is added to avoid communication errors on long wires. But even if you use short wires, add the resistor because it leaves the bus on 0.171V on the bus (measured). It should near or above 0.2V. This leaves the
DO-pin high during idling.Calculation:
3.3V --> 680Ohms --> 2x 120Ohms parallel --> 680Ohms --> 0V results in 2.32mA
Voltage over the two (!) 120Ohms resistors is 0.1392V
Breadboarded version:
on the left, an ESP32, on the right a max3485 with three resistors.
Beta Was this translation helpful? Give feedback.
All reactions