wn/ModbusThermometer
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

add modbus stuff

Browse Source
This commit is contained in:
hg
2014-11-07 18:40:19 +01:00
parent 747ffbf6ad
commit cebf295a8b
5 changed files with 731 additions and 75 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
ModbusThermometer.cpp
View File

@ -1,6 +1,6 @@
#include "Arduino.h"
#include "Streaming.h"
// #include "Streaming.h"
#include "Metro.h"
#include "ads1210.h"
@ -18,7 +18,7 @@ Metro secondTick = Metro(1000);
void setup() {
Serial.begin(9600);
// Serial.begin(9600);
delay(1000);
led.begin(LED_PIN);
@ -31,6 +31,6 @@ void loop() {
if (secondTick.check() == 1) {
led.toggle();
Serial << "AdcValue: " << _HEX(ads1210.value) << endl;
// Serial << "AdcValue: " << _HEX(ads1210.value) << endl;
}
}

515
SimpleModbusMaster.cpp Normal file
View File

@ -0,0 +1,515 @@
#include "SimpleModbusMaster.h"
#include "HardwareSerial.h"
// state machine states
#define IDLE 1
#define WAITING_FOR_REPLY 2
#define WAITING_FOR_TURNAROUND 3
#define BUFFER_SIZE 128
unsigned char state;
unsigned char retry_count;
unsigned char TxEnablePin;
// frame[] is used to receive and transmit packages.
// The maximum number of bytes in a modbus packet is 256 bytes
// This is limited to the serial buffer of 128 bytes
unsigned char frame[BUFFER_SIZE];
unsigned char buffer;
unsigned int timeout; // timeout interval
unsigned int polling; // turnaround delay interval
unsigned int T1_5; // inter character time out in microseconds
unsigned long delayStart; // init variable for turnaround and timeout delay
unsigned int total_no_of_packets;
Packet* packetArray; // packet starting address
Packet* packet; // current packet
HardwareSerial* ModbusPort;
// function definitions
void idle();
void constructPacket();
unsigned char construct_F15();
unsigned char construct_F16();
void waiting_for_reply();
void processReply();
void waiting_for_turnaround();
void process_F1_F2();
void process_F3_F4();
void process_F15_F16();
void processError();
void processSuccess();
unsigned int calculateCRC(unsigned char bufferSize);
void sendPacket(unsigned char bufferSize);
// Modbus Master State Machine
void modbus_update()
{
switch (state)
{
case IDLE:
idle();
break;
case WAITING_FOR_REPLY:
waiting_for_reply();
break;
case WAITING_FOR_TURNAROUND:
waiting_for_turnaround();
break;
}
}
void idle()
{
static unsigned int packet_index;
unsigned int failed_connections = 0;
unsigned char current_connection;
do
{
if (packet_index == total_no_of_packets) // wrap around to the beginning
packet_index = 0;
// proceed to the next packet
packet = &packetArray[packet_index];
// get the current connection status
current_connection = packet->connection;
if (!current_connection)
{
// If all the connection attributes are false return
// immediately to the main sketch
if (++failed_connections == total_no_of_packets)
return;
}
packet_index++;
// if a packet has no connection get the next one
}while (!current_connection);
constructPacket();
}
void constructPacket()
{
packet->requests++;
frame[0] = packet->id;
frame[1] = packet->function;
frame[2] = packet->address >> 8; // address Hi
frame[3] = packet->address & 0xFF; // address Lo
// For functions 1 & 2 data is the number of points
// For functions 3, 4 & 16 data is the number of registers
// For function 15 data is the number of coils
frame[4] = packet->data >> 8; // MSB
frame[5] = packet->data & 0xFF; // LSB
unsigned char frameSize;
// construct the frame according to the modbus function
if (packet->function == PRESET_MULTIPLE_REGISTERS)
frameSize = construct_F16();
else if (packet->function == FORCE_MULTIPLE_COILS)
frameSize = construct_F15();
else // else functions 1,2,3 & 4 is assumed. They all share the exact same request format.
frameSize = 8; // the request is always 8 bytes in size for the above mentioned functions.
unsigned int crc16 = calculateCRC(frameSize - 2);
frame[frameSize - 2] = crc16 >> 8; // split crc into 2 bytes
frame[frameSize - 1] = crc16 & 0xFF;
sendPacket(frameSize);
state = WAITING_FOR_REPLY; // state change
// if broadcast is requested (id == 0) for function 15 or 16 then override
// the previous state and force a success since the slave wont respond
if (packet->id == 0)
processSuccess();
}
unsigned char construct_F15()
{
// function 15 coil information is packed LSB first until the first 16 bits are completed
// It is received the same way..
unsigned char no_of_registers = packet->data / 16;
unsigned char no_of_bytes = no_of_registers * 2;
// if the number of points dont fit in even 2byte amounts (one register) then use another register and pad
if (packet->data % 16 > 0)
{
no_of_registers++;
no_of_bytes++;
}
frame[6] = no_of_bytes;
unsigned char bytes_processed = 0;
unsigned char index = 7; // user data starts at index 7
unsigned int temp;
for (unsigned char i = 0; i < no_of_registers; i++)
{
temp = packet->register_array[i]; // get the data
frame[index] = temp & 0xFF;
bytes_processed++;
if (bytes_processed < no_of_bytes)
{
frame[index + 1] = temp >> 8;
bytes_processed++;
index += 2;
}
}
unsigned char frameSize = (9 + no_of_bytes); // first 7 bytes of the array + 2 bytes CRC + noOfBytes
return frameSize;
}
unsigned char construct_F16()
{
unsigned char no_of_bytes = packet->data * 2;
// first 6 bytes of the array + no_of_bytes + 2 bytes CRC
frame[6] = no_of_bytes; // number of bytes
unsigned char index = 7; // user data starts at index 7
unsigned char no_of_registers = packet->data;
unsigned int temp;
for (unsigned char i = 0; i < no_of_registers; i++)
{
temp = packet->register_array[i]; // get the data
frame[index] = temp >> 8;
index++;
frame[index] = temp & 0xFF;
index++;
}
unsigned char frameSize = (9 + no_of_bytes); // first 7 bytes of the array + 2 bytes CRC + noOfBytes
return frameSize;
}
void waiting_for_turnaround()
{
if ((millis() - delayStart) > polling)
state = IDLE;
}
// get the serial data from the buffer
void waiting_for_reply()
{
if ((*ModbusPort).available()) // is there something to check?
{
unsigned char overflowFlag = 0;
buffer = 0;
while ((*ModbusPort).available())
{
// The maximum number of bytes is limited to the serial buffer size
// of BUFFER_SIZE. If more bytes is received than the BUFFER_SIZE the
// overflow flag will be set and the serial buffer will be read until
// all the data is cleared from the receive buffer, while the slave is
// still responding.
if (overflowFlag)
(*ModbusPort).read();
else
{
if (buffer == BUFFER_SIZE)
overflowFlag = 1;
frame[buffer] = (*ModbusPort).read();
// Serial.print("R: "); Serial.println(frame[buffer], 16);
buffer++;
}
// This is not 100% correct but it will suffice.
// worst case scenario is if more than one character time expires
// while reading from the buffer then the buffer is most likely empty
// If there are more bytes after such a delay it is not supposed to
// be received and thus will force a frame_error.
delayMicroseconds(T1_5); // inter character time out
}
// The minimum buffer size from a slave can be an exception response of
// 5 bytes. If the buffer was partially filled set a frame_error.
// The maximum number of bytes in a modbus packet is 256 bytes.
// The serial buffer limits this to 128 bytes.
if ((buffer < 5) || overflowFlag)
processError();
// Modbus over serial line datasheet states that if an unexpected slave
// responded the master must do nothing and continue with the time out.
// This seems silly cause if an incorrect slave responded you would want to
// have a quick turnaround and poll the right one again. If an unexpected
// slave responded it will most likely be a frame error in any event
else if (frame[0] != packet->id) // check id returned
processError();
else
processReply();
}
else if ((millis() - delayStart) > timeout) // check timeout
{
processError();
state = IDLE; //state change, override processError() state
}
}
void processReply()
{
// combine the crc Low & High bytes
unsigned int received_crc = ((frame[buffer - 2] << 8) | frame[buffer - 1]);
unsigned int calculated_crc = calculateCRC(buffer - 2);
if (calculated_crc == received_crc) // verify checksum
{
// To indicate an exception response a slave will 'OR'
// the requested function with 0x80
if ((frame[1] & 0x80) == 0x80) // extract 0x80
{
packet->exception_errors++;
processError();
}
else
{
switch (frame[1]) // check function returned
{
case READ_COIL_STATUS:
case READ_INPUT_STATUS:
process_F1_F2();
break;
case READ_INPUT_REGISTERS:
case READ_HOLDING_REGISTERS:
process_F3_F4();
break;
case FORCE_MULTIPLE_COILS:
case PRESET_MULTIPLE_REGISTERS:
process_F15_F16();
break;
default: // illegal function returned
processError();
break;
}
}
}
else // checksum failed
{
processError();
}
}
void process_F1_F2()
{
// packet->data for function 1 & 2 is actually the number of boolean points
unsigned char no_of_registers = packet->data / 16;
unsigned char number_of_bytes = no_of_registers * 2;
// if the number of points dont fit in even 2byte amounts (one register) then use another register and pad
if (packet->data % 16 > 0)
{
no_of_registers++;
number_of_bytes++;
}
if (frame[2] == number_of_bytes) // check number of bytes returned
{
unsigned char bytes_processed = 0;
unsigned char index = 3; // start at the 4th element in the frame and combine the Lo byte
unsigned int temp;
for (unsigned char i = 0; i < no_of_registers; i++)
{
temp = frame[index];
bytes_processed++;
if (bytes_processed < number_of_bytes)
{
temp = (frame[index + 1] << 8) | temp;
bytes_processed++;
index += 2;
}
packet->register_array[i] = temp;
}
processSuccess();
}
else // incorrect number of bytes returned
processError();
}
void process_F3_F4()
{
// check number of bytes returned - unsigned int == 2 bytes
// data for function 3 & 4 is the number of registers
if (frame[2] == (packet->data * 2))
{
unsigned char index = 3;
for (unsigned char i = 0; i < packet->data; i++)
{
// start at the 4th element in the frame and combine the Lo byte
packet->register_array[i] = (frame[index] << 8) | frame[index + 1];
index += 2;
}
processSuccess();
}
else // incorrect number of bytes returned
processError();
}
void process_F15_F16()
{
// Functions 15 & 16 is just an echo of the query
unsigned int recieved_address = ((frame[2] << 8) | frame[3]);
unsigned int recieved_data = ((frame[4] << 8) | frame[5]);
if ((recieved_address == packet->address) && (recieved_data == packet->data))
processSuccess();
else
processError();
}
void processError()
{
packet->retries++;
packet->failed_requests++;
if (packet->valueValid != NULL) {
*(packet->valueValid) = false;
}
// if the number of retries have reached the max number of retries
// allowable, stop requesting the specific packet
if (packet->retries == retry_count)
{
packet->connection = 0;
packet->retries = 0;
if (packet->connectionValid != NULL) {
*(packet->connectionValid) = false;
}
}
state = WAITING_FOR_TURNAROUND;
delayStart = millis(); // start the turnaround delay
}
void processSuccess()
{
packet->successful_requests++; // transaction sent successfully
packet->retries = 0; // if a request was successful reset the retry counter
state = WAITING_FOR_TURNAROUND;
delayStart = millis(); // start the turnaround delay
if (packet->valueValid != NULL) {
*(packet->valueValid) = true;
}
if (packet->connectionValid != NULL) {
*(packet->connectionValid) = true;
}
}
void modbus_configure(HardwareSerial* SerialPort,
long baud,
unsigned char byteFormat,
unsigned int _timeout,
unsigned int _polling,
unsigned char _retry_count,
unsigned char _TxEnablePin,
Packet* _packets,
unsigned int _total_no_of_packets)
{
// Modbus states that a baud rate higher than 19200 must use a fixed 750 us
// for inter character time out and 1.75 ms for a frame delay for baud rates
// below 19200 the timing is more critical and has to be calculated.
// E.g. 9600 baud in a 11 bit packet is 9600/11 = 872 characters per second
// In milliseconds this will be 872 characters per 1000ms. So for 1 character
// 1000ms/872 characters is 1.14583ms per character and finally modbus states
// an inter-character must be 1.5T or 1.5 times longer than a character. Thus
// 1.5T = 1.14583ms * 1.5 = 1.71875ms. A frame delay is 3.5T.
// Thus the formula is T1.5(us) = (1000ms * 1000(us) * 1.5 * 11bits)/baud
// 1000ms * 1000(us) * 1.5 * 11bits = 16500000 can be calculated as a constant
if (baud > 19200)
T1_5 = 750;
else
T1_5 = 16500000/baud; // 1T * 1.5 = T1.5
// initialize
state = IDLE;
timeout = _timeout;
polling = _polling;
retry_count = _retry_count;
TxEnablePin = _TxEnablePin;
total_no_of_packets = _total_no_of_packets;
packetArray = _packets;
// initialize connection status of each packet
/*for (unsigned char i = 0; i < total_no_of_packets; i++)
{
_packets->connection = 1;
_packets++;
}*/
ModbusPort = SerialPort;
(*ModbusPort).begin(baud, byteFormat);
pinMode(TxEnablePin, OUTPUT);
digitalWrite(TxEnablePin, LOW);
}
void modbus_construct(Packet *_packet,
unsigned char id,
unsigned char function,
unsigned int address,
unsigned int data,
unsigned int* register_array)
{
_packet->id = id;
_packet->function = function;
_packet->address = address;
_packet->data = data;
_packet->register_array = register_array;
_packet->connection = 1;
_packet->connectionValid = NULL;
_packet->valueValid = NULL;
}
unsigned int calculateCRC(unsigned char bufferSize)
{
unsigned int temp, temp2, flag;
temp = 0xFFFF;
for (unsigned char i = 0; i < bufferSize; i++)
{
temp = temp ^ frame[i];
for (unsigned char j = 1; j <= 8; j++)
{
flag = temp & 0x0001;
temp >>= 1;
if (flag)
temp ^= 0xA001;
}
}
// Reverse byte order.
temp2 = temp >> 8;
temp = (temp << 8) | temp2;
temp &= 0xFFFF;
// the returned value is already swapped
// crcLo byte is first & crcHi byte is last
return temp;
}
void sendPacket(unsigned char bufferSize)
{
digitalWrite(TxEnablePin, HIGH);
for (unsigned char i = 0; i < bufferSize; i++) {
// Serial.print("S: "); Serial.println(frame[i],16);
(*ModbusPort).write(frame[i]);
}
(*ModbusPort).flush();
// It may be necessary to add a another character delay T1_5 here to
// avoid truncating the message on slow and long distance connections
digitalWrite(TxEnablePin, LOW);
delayStart = millis(); // start the timeout delay
}

139
SimpleModbusMaster.h Normal file
View File

@ -0,0 +1,139 @@
#ifndef SIMPLE_MODBUS_MASTER_H
#define SIMPLE_MODBUS_MASTER_H
// SimpleModbusMasterV10
/*
SimpleModbusMaster allows you to communicate
to any slave using the Modbus RTU protocol.
To communicate with a slave you need to create a packet that will contain
all the information required to communicate to the slave.
Information counters are implemented for further diagnostic.
These are variables already implemented in a packet.
You can set and clear these variables as needed.
The following modbus information counters are implemented:
requests - contains the total requests to a slave
successful_requests - contains the total successful requests
failed_requests - general frame errors, checksum failures and buffer failures
retries - contains the number of retries
exception_errors - contains the specific modbus exception response count
These are normally illegal function, illegal address, illegal data value
or a miscellaneous error response.
And finally there is a variable called "connection" that
at any given moment contains the current connection
status of the packet. If true then the connection is
active. If false then communication will be stopped
on this packet until the programmer sets the connection
variable to true explicitly. The reason for this is
because of the time out involved in modbus communication.
Each faulty slave that's not communicating will slow down
communication on the line with the time out value. E.g.
Using a time out of 1500ms, if you have 10 slaves and 9 of them
stops communicating the latency burden placed on communication
will be 1500ms * 9 = 13,5 seconds!
Communication will automatically be stopped after the retry count expires
on each specific packet.
All the error checking, updating and communication multitasking
takes place in the background.
In general to communicate with to a slave using modbus
RTU you will request information using the specific
slave id, the function request, the starting address
and lastly the data to request.
Function 1, 2, 3, 4, 15 & 16 are supported. In addition to
this broadcasting (id = 0) is supported for function 15 & 16.
Constants are provided for:
Function 1 - READ_COIL_STATUS
Function 2 - READ_INPUT_STATUS
Function 3 - READ_HOLDING_REGISTERS
Function 4 - READ_INPUT_REGISTERS
Function 15 - FORCE_MULTIPLE_COILS
Function 16 - PRESET_MULTIPLE_REGISTERS
Note:
The Arduino serial ring buffer is 128 bytes or 64 registers.
Most of the time you will connect the Arduino using a MAX485 or similar.
In a function 3 or 4 request the master will attempt to read from a
slave and since 5 bytes is already used for ID, FUNCTION, NO OF BYTES
and two BYTES CRC the master can only request 122 bytes or 61 registers.
In a function 16 request the master will attempt to write to a
slave and since 9 bytes is already used for ID, FUNCTION, ADDRESS,
NO OF REGISTERS, NO OF BYTES and two BYTES CRC the master can only write
118 bytes or 59 registers.
Note:
Using a USB to Serial converter the maximum bytes you can send is
limited to its internal buffer which differs between manufactures.
Since it is assumed that you will mostly use the Arduino to connect without
using a USB to Serial converter the internal buffer is set the same as the
Arduino Serial ring buffer which is 128 bytes.
*/
#include "Arduino.h"
#define READ_COIL_STATUS 1 // Reads the ON/OFF status of discrete outputs (0X references, coils) in the slave.
#define READ_INPUT_STATUS 2 // Reads the ON/OFF status of discrete inputs (1X references) in the slave.
#define READ_HOLDING_REGISTERS 3 // Reads the binary contents of holding registers (4X references) in the slave.
#define READ_INPUT_REGISTERS 4 // Reads the binary contents of input registers (3X references) in the slave. Not writable.
#define FORCE_MULTIPLE_COILS 15 // Forces each coil (0X reference) in a sequence of coils to either ON or OFF.
#define PRESET_MULTIPLE_REGISTERS 16 // Presets values into a sequence of holding registers (4X references).
typedef struct
{
// specific packet info
unsigned char id;
unsigned char function;
unsigned int address;
// For functions 1 & 2 data is the number of points
// For functions 3, 4 & 16 data is the number of registers
// For function 15 data is the number of coils
unsigned int data;
unsigned int* register_array;
// modbus information counters
unsigned int requests;
unsigned int successful_requests;
unsigned int failed_requests;
unsigned int exception_errors;
unsigned int retries;
// connection status of packet
unsigned char connection;
bool *connectionValid;
bool *valueValid;
}Packet;
typedef Packet* packetPointer;
// function definitions
void modbus_update();
void modbus_construct(Packet *_packet,
unsigned char id,
unsigned char function,
unsigned int address,
unsigned int data,
unsigned int* register_array);
void modbus_configure(HardwareSerial* SerialPort,
long baud,
unsigned char byteFormat,
unsigned int _timeout,
unsigned int _polling,
unsigned char _retry_count,
unsigned char _TxEnablePin,
Packet* _packets,
unsigned int _total_no_of_packets);
#endif

20
ads1210.cpp
View File

@ -7,7 +7,7 @@
// #include <Arduino.h>
#include <SPI.h>
#include "Streaming.h"
// #include "Streaming.h"
#include "ads1210.h"
#include "fatal.h"
@ -102,31 +102,31 @@ void ADS1210::begin(uint8_t csPin, uint8_t drdyPin) {
m_drdyPin = drdyPin;
// initialization of SPI
Serial << "Start SPI initialization ... ";
// Serial << "Start SPI initialization ... ";
pinMode(m_csPin, OUTPUT);
digitalWrite(m_csPin, HIGH);
SPI.begin();
SPI.setBitOrder(MSBFIRST);
SPI.setClockDivider(SPI_CLOCK_DIV8);
SPI.setDataMode(SPI_MODE1);
Serial << "done." << endl;
// Serial << "done." << endl;
// initialization of ADS1210
Serial << "Start ADS1210 initialization ... ";
// Serial << "Start ADS1210 initialization ... ";
pinMode(m_drdyPin, INPUT);
writeRegister(ADDR_CMR3, CMR_SDL | CMR_UB | CMR_REFO);
writeRegister(ADDR_CMR1, 0x1b); // data rate
writeRegister(ADDR_CMR0, 0x58);
Serial << "done." << endl;
// Serial << "done." << endl;
// Serial << "Set gain ... ";
// setGain(CMR_Gain_2);
// Serial << "done." << endl;
// Serial << "Set gain ... ";
// setGain(CMR_Gain_2);
// Serial << "done." << endl;
Serial << "SelfCalibration ... ";
// Serial << "SelfCalibration ... ";
setMode(CMR_MD_SelfCalibration);
waitForDRdy();
Serial << "done." << endl;
// Serial << "done." << endl;
}

6
fatal.cpp
View File

@ -1,9 +1,11 @@
#include "Streaming.h"
// #include "Streaming.h"
#include <Arduino.h>
#include <stdint.h>
#include "fatal.h"
void fatal(uint8_t code) {
Serial << "Fatal: " << code << endl;
// Serial << "Fatal: " << code << endl;
delay(1000);
while (true) ;
}