A little more advanced Modbus Master

Advanced Modbus Master code

 This is a little more advanced Modbus Master:

/**
 *  Modbus master example 2:
 *  The purpose of this example is to query several sets of data
 *  from an external Modbus slave device. 
 *  The link media can be USB or RS232.
 *
 *  Recommended Modbus slave: 
 *  diagslave http://www.modbusdriver.com/diagslave.html
 *
 *  In a Linux box, run 
 *  "./diagslave /dev/ttyUSB0 -b 19200 -d 8 -s 1 -p none -m rtu -a 1"
 *  This is:
 *   serial port /dev/ttyUSB0 at 19200 baud 8N1
 *  RTU mode and address @1
 */

#include <ModbusRtu.h>

uint16_t au16data[16]; //!< data array for modbus network sharing
uint8_t u8state; //!< machine state
uint8_t u8query; //!< pointer to message query

/**
 *  Modbus object declaration
 *  u8id : node id = 0 for master, = 1..247 for slave
 *  u8serno : serial port (use 0 for Serial)
 *  u8txenpin : 0 for RS-232 and USB-FTDI 
 *               or any pin number > 1 for RS-485
 */
Modbus master(0,0,0); // this is master and RS-232 or USB-FTDI

/**
 * This is an structe which contains a query to an slave device
 */
modbus_t telegram[2];

unsigned long u32wait;

void setup() {
  // telegram 0: read registers
  telegram[0].u8id = 1; // slave address
  telegram[0].u8fct = 3; // function code (this one is registers read)
  telegram[0].u16RegAdd = 0; // start address in slave
  telegram[0].u16CoilsNo = 4; // number of elements (coils or registers) to read
  telegram[0].au16reg = au16data; // pointer to a memory array in the Arduino

  // telegram 1: write a single register
  telegram[1].u8id = 1; // slave address
  telegram[1].u8fct = 6; // function code (this one is write a single register)
  telegram[1].u16RegAdd = 4; // start address in slave
  telegram[1].u16CoilsNo = 1; // number of elements (coils or registers) to read
  telegram[1].au16reg = au16data+4; // pointer to a memory array in the Arduino
 
  master.begin( 19200 ); // baud-rate at 19200
  master.setTimeOut( 5000 ); // if there is no answer in 5000 ms, roll over
  u32wait = millis() + 1000;
  u8state = u8query = 0; 
}

void loop() {
  switch( u8state ) {
  case 0: 
    if (millis() > u32wait) u8state++; // wait state
    break;
  case 1: 
    master.query( telegram[u8query] ); // send query (only once)
    u8state++;
 u8query++;
 if (u8query > 2) u8query = 0;
    break;
  case 2:
    master.poll(); // check incoming messages
    if (master.getState() == COM_IDLE) {
      u8state = 0;
      u32wait = millis() + 1000; 
    }
    break;
  }
  au16data[4] = analogRead( 0 );
} 

This code is already included in the last release of my Library, available at Github.

Now there are two queries: 0 and 1. 0 makes the same as before, while 1 adds a single-register write. This is done through the state-machine implemented in loop, which sends both queries through u8query.

Modbus RTU is not an IP-based protocol. Serial protocols require to send messages one after another and wait for their answer before sending a new message. This is done here.

Only for debug purposes, the u32wait time has been set to 1000 ms.

Understanding the code

In setup(), the master is initialised:

• a set of queries through telegram are written;
• the serial port is started with master.begin(19200) at 19200 baud;
• the u8query index is reset;
• the u8state machine state register is reset.

Modbus_t variables

telegram is an structure array based on modbus_t type. It contains the queries to the Modbus slaves. Things to define here:

• slave id and register to access
• what to do (read or write) and how many fields
• where is this information linked

The .au16reg field contains a pointer to an integer array. It allows to link the Modbus protocol to the rest of the Arduino program. It could be an LCD or digital I/O or a set of devices plugged to I2C.

The loop section runs the machine state and links any process data to the integer array au16data.

The machine state

This library need that a machine state to be implemented in software in the loop section. This is for flexibility of the code.

The machine state is driven by u8state byte. It consists on 3 states:

• 0: it is a wait phase;
• 1: a query is sent through master.query( telegram[ u8query ] );
• 2: the poll section waits for an answer or just gets out if there is a time-out event.

The time-out event is defined by master.setTimeOut( 5000 ) in setup(). This means that the application allows up to 5 s to wait for an answer.

Debugging the code

Debugging with Multiway

Multiway is a worthy protocol analiser written by Omron Corporation in France. It supports several industrial protocols and Modbus is between them.

Multiway has been set as

COM4
8-bit, 1-bit stop, none
Modbus slave number 1

The Master is reading registers from 0 to 3 and writes on register 4.

Link to the library upgrade

Google Drive
GitHub