In this post I’d like to describe you a project I’m working on that consists of connecting an Android touch screen to one (or more) Arduino slave(s) using modbus and rs485.
Even though the idea of this project could be applied in many fields, I chose to contextualize it in a typical smart home context: a touch display that dims lights, shows temperatures and bulbs statuses.

The nice feature of this touch screen is that it has many interfaces such as Ethernet, rs485, rs232 and i2c as well.
I expressly selected rs485 because Arduino-based microcontrollers are not ready for Ethernet yet (even though some examples still exist but without great success). Indeed, rs485 is a well known standard that has been widely used in the indus­trial con­text and in building automa­tion appli­ca­tions. It is a half-duplex, 2-wires, low noise bus that allows high speeds and remote devices connection (up to 1200 meters).
Furthermore, modbus is a serial communication protocol, developed for industrial applications, open and easy to deploy and maintain. I used modbus RTU, but other variations of the protocol still exist though.

I divided the project into two core parts, namely:

Electrical parts, Circuit diagram and Arduino Sketch:

The key ingredients for this project are the following:

Android Arduino Modbus over rs485

The picture on the right shows an overview of the circuit diagram of the project (some parts of the picture made with Fritzing). More than one Arduino board could be connected to the bus though.

Arduino sketch essentially uses SimpleSlaveModbus library. I personally suggest you to take a look at documentation in order to have a better idea on how this library works.

After including the modbus library header at the beginning of the source code, I declared an integer array (named holdingRegs) that stores the modbus registers. Function code 16 writes into them whereas function code 3 read them. The first two registers are reserved for analog values such as those gathered from A0 and A1 Arduino’s pins. INDIG0 to INDIG4 are served for digital inputs, OUTD0 to OUTD4 to digital outputs and AOUT0 for PWM.
In the setup section of the sketch, I call the modbus_configure function in order to configure the modbus with the following parameters: the baud rate, the ID of the slave (address), the transmit enable pin and the number of registers. Subsequently, I basically configure the digital Arduino pins with pinMode.

In the loop of the sketch, I inserted a call to modbus_update specifying, as a first parameter, the reference to the array that stores the modbus registers. This function will take care of the received modbus commands and will modify the registers accordingly in case of writing or reading requests.
The remaining part of the sketch reads the analog values from pin A0 and A1, reads the digital values (remember we set those digital pin to INPUT_PULLUP) and finally writes the digital values of the switches.

Finally, in order to have an insight on the status of the communication channel, I used a red led that indicates when a modbus message is received and processed. This is accomplished by modifying the modbus slave library and inserting a couple of digitalWrites (set to HIGH or LOW whenever necessary).

[sourcecode language=”cpp”]
#include

#define pinDig 3
#define pinDigOut 6

//////////////// registers of the slave ///////////////////
enum
{
// The first register starts at address 0
ADC0,
ADC1,
INDIG0,
INDIG1,
INDIG2,
INDIG3,
OUTD0,
OUTD1,
OUTD2,
OUTD3,
AOUT0,
TOTAL_ERRORS,
TOTAL_REGS_SIZE
// total number of registers for function 3 and 16 share the same register array
};

unsigned int holdingRegs[TOTAL_REGS_SIZE]; // function 3 and 16 register array

void setup()
{

modbus_configure(38400, 1, 2, TOTAL_REGS_SIZE);

//digital input configuration
for(int i=10; i pinMode(i, INPUT_PULLUP);
}

//digital output
pinMode(3, OUTPUT);
pinMode(4, OUTPUT);
pinMode(5, OUTPUT);
pinMode(6, OUTPUT);

//modbus led
pinMode(8, OUTPUT);

//PWM
pinMode(9, OUTPUT);

//modbus register initialization
for (int i=0; i < 10; i++){
holdingRegs[i] = 0;
}
}

void loop()
{
// modbus_update() is the only method used in loop(). It returns the total error
// count since the slave started. You don’t have to use it but it’s useful
// for fault finding by the modbus master.

holdingRegs[TOTAL_ERRORS] = modbus_update(holdingRegs);

holdingRegs[0]=analogRead(0);
holdingRegs[1]=analogRead(1);

//digital input
for (int i=0; i < 4; i++){
holdingRegs[i+2]=digitalRead(10+i);
}

for(int i=0; i < 4; i++){
digitalWrite(pinDig+i,holdingRegs[pinDigOut+i]);
}

//PWM
analogWrite(12, holdingRegs[9]);

}
[/sourcecode]

In the next week’s post I’ll continue to describe the project and in particular, the part about the Android app that connects to Arduino.
Stay tuned!

Lascia un commento