alexsandro scheeren
01
Diff: ModbusSlave232.cpp
- Revision:
- 0:6262fc7582a9
- Child:
- 1:35fdc7056f66
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ModbusSlave232.cpp Thu Jul 21 19:48:35 2016 +0000
@@ -0,0 +1,656 @@
+/*
+ Modbus over serial line - RTU Slave Arduino Sketch
+
+ By Juan Pablo Zometa : jpmzometa@gmail.com
+ http://sites.google.com/site/jpmzometa/
+ Samuel Marco: sammarcoarmengol@gmail.com
+ and Andras Tucsni.
+
+ These functions implement functions 3, 6, and 16 (read holding registers,
+ preset single register and preset multiple registers) of the
+ Modbus RTU Protocol, to be used over the Arduino serial connection.
+
+ This implementation DOES NOT fully comply with the Modbus specifications.
+
+ This Arduino adaptation is derived from the work
+ By P.Costigan email: phil@pcscada.com.au http://pcscada.com.au
+
+ These library of functions are designed to enable a program send and
+ receive data from a device that communicates using the Modbus protocol.
+
+ Copyright (C) 2000 Philip Costigan P.C. SCADA LINK PTY. LTD.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+ The functions included here have been derived from the
+ Modicon Modbus Protocol Reference Guide
+ which can be obtained from Schneider at www.schneiderautomation.com.
+
+ This code has its origins with
+ paul@pmcrae.freeserve.co.uk (http://www.pmcrae.freeserve.co.uk)
+ who wrote a small program to read 100 registers from a modbus slave.
+
+ I have used his code as a catalist to produce this more functional set
+ of functions. Thanks paul.
+ */
+
+
+//#include "Arduino.h" //afdhal
+#include "millis.h"
+#include "MODSERIAL.h" //afdhal
+MODSERIAL pc(USBTX, USBRX); // tx, rx //afdhal
+
+#ifndef ModbusSlave232_h
+ #include "ModbusSlave232.h"
+#endif
+
+
+/****************************************************************************
+ * BEGIN MODBUS RTU SLAVE FUNCTIONS
+ ****************************************************************************/
+
+/* constants */
+enum {
+ MAX_READ_REGS = 0x7D,
+ MAX_WRITE_REGS = 0x7B,
+ MAX_MESSAGE_LENGTH = 256
+};
+
+
+enum {
+ RESPONSE_SIZE = 6,
+ EXCEPTION_SIZE = 3,
+ CHECKSUM_SIZE = 2
+};
+
+/* exceptions code */
+enum {
+ NO_REPLY = -1,
+ EXC_FUNC_CODE = 1,
+ EXC_ADDR_RANGE = 2,
+ EXC_REGS_QUANT = 3,
+ EXC_EXECUTE = 4
+};
+
+/* positions inside the query/response array */
+enum {
+ SLAVE = 0,
+ FUNC,
+ START_H,
+ START_L,
+ REGS_H,
+ REGS_L,
+ BYTE_CNT
+};
+
+
+/* enum of supported modbus function codes. If you implement a new one, put its function code here ! */
+enum {
+ FC_READ_REGS = 0x03, //Read contiguous block of holding register
+ FC_WRITE_REG = 0x06, //Write single holding register
+ FC_WRITE_REGS = 0x10 //Write block of contiguous registers
+};
+
+/* supported functions. If you implement a new one, put its function code into this array! */
+const unsigned char fsupported[] = { FC_READ_REGS, FC_WRITE_REG, FC_WRITE_REGS };
+
+
+/*
+CRC
+
+ INPUTS:
+ buf -> Array containing message to be sent to controller.
+ start -> Start of loop in crc counter, usually 0.
+ cnt -> Amount of bytes in message being sent to controller/
+ OUTPUTS:
+ temp -> Returns crc byte for message.
+ COMMENTS:
+ This routine calculates the crc high and low byte of a message.
+ Note that this crc is only used for Modbus, not Modbus+ etc.
+ ****************************************************************************/
+
+unsigned int ModbusSlave232::crc(unsigned char *buf, unsigned char start,
+unsigned char cnt)
+{
+ unsigned char i, j;
+ unsigned temp, temp2, flag;
+
+ temp = 0xFFFF;
+
+ for (i = start; i < cnt; i++) {
+ temp = temp ^ buf[i];
+
+ for (j = 1; j <= 8; j++) {
+ flag = temp & 0x0001;
+ temp = temp >> 1;
+ if (flag)
+ temp = temp ^ 0xA001;
+ }
+ }
+
+ /* Reverse byte order. */
+ temp2 = temp >> 8;
+ temp = (temp << 8) | temp2;
+ temp &= 0xFFFF;
+
+ return (temp);
+}
+
+
+
+
+/***********************************************************************
+ *
+ * The following functions construct the required query into
+ * a modbus query packet.
+ *
+ ***********************************************************************/
+
+/*
+ * Start of the packet of a read_holding_register response
+ */
+void ModbusSlave232::build_read_packet(unsigned char function,
+unsigned char count, unsigned char *packet)
+{
+ packet[SLAVE] = slave;
+ packet[FUNC] = function;
+ packet[2] = count * 2;
+}
+
+/*
+ * Start of the packet of a preset_multiple_register response
+ */
+void ModbusSlave232::build_write_packet(unsigned char function,
+unsigned int start_addr,
+unsigned char count,
+unsigned char *packet)
+{
+ packet[SLAVE] = slave;
+ packet[FUNC] = function;
+ packet[START_H] = start_addr >> 8;
+ packet[START_L] = start_addr & 0x00ff;
+ packet[REGS_H] = 0x00;
+ packet[REGS_L] = count;
+}
+
+/*
+ * Start of the packet of a write_single_register response
+ */
+void ModbusSlave232::build_write_single_packet(unsigned char function,
+ unsigned int write_addr, unsigned int reg_val, unsigned char* packet)
+{
+ packet[SLAVE] = slave;
+ packet[FUNC] = function;
+ packet[START_H] = write_addr >> 8;
+ packet[START_L] = write_addr & 0x00ff;
+ packet[REGS_H] = reg_val >> 8;
+ packet[REGS_L] = reg_val & 0x00ff;
+}
+
+
+/*
+ * Start of the packet of an exception response
+ */
+void ModbusSlave232::build_error_packet( unsigned char function,
+unsigned char exception, unsigned char *packet)
+{
+ packet[SLAVE] = slave;
+ packet[FUNC] = function + 0x80;
+ packet[2] = exception;
+}
+
+
+/*************************************************************************
+ *
+ * modbus_query( packet, length)
+ *
+ * Function to add a checksum to the end of a packet.
+ * Please note that the packet array must be at least 2 fields longer than
+ * string_length.
+ **************************************************************************/
+
+void ModbusSlave232::modbus_reply(unsigned char *packet, unsigned char string_length)
+{
+ int temp_crc;
+
+ temp_crc = crc(packet, 0, string_length);
+ packet[string_length] = temp_crc >> 8;
+ string_length++;
+ packet[string_length] = temp_crc & 0x00FF;
+}
+
+
+
+/***********************************************************************
+ *
+ * send_reply( query_string, query_length )
+ *
+ * Function to send a reply to a modbus master.
+ * Returns: total number of characters sent
+ ************************************************************************/
+
+int ModbusSlave232::send_reply(unsigned char *query, unsigned char string_length)
+{
+ unsigned char i;
+
+ /*if (txenpin > 1) { // set MAX485 to speak mode //afdhal
+ UCSR0A=UCSR0A |(1 << TXC0);
+ digitalWrite( txenpin, HIGH);
+ delay(1);
+ }*/
+
+ modbus_reply(query, string_length);
+ string_length += 2;
+
+ for (i = 0; i < string_length; i++) {
+ //Serial.print(char(query[i])); //afdhal
+ pc.putc(char(query[i])); //afdhal
+
+ }
+
+ return i; /* it does not mean that the write was succesful, though */
+}
+
+/***********************************************************************
+ *
+ * receive_request( array_for_data )
+ *
+ * Function to monitor for a request from the modbus master.
+ *
+ * Returns: Total number of characters received if OK
+ * 0 if there is no request
+ * A negative error code on failure
+ ***********************************************************************/
+
+int ModbusSlave232::receive_request(unsigned char *received_string)
+{
+ int bytes_received = 0;
+
+ /* FIXME: does Serial.available wait 1.5T or 3.5T before exiting the loop? */
+ //while (Serial.available()) { //afdhal
+ while (pc.readable()) { //afdhal
+ received_string[bytes_received] = pc.getc(); //Serial.read(); //afdhal
+ //Serial.print(received_string[bytes_received], DEC);
+ bytes_received++;
+ if (bytes_received >= MAX_MESSAGE_LENGTH)
+ return NO_REPLY; /* port error */
+ }
+
+ return (bytes_received);
+}
+
+
+/*********************************************************************
+ *
+ * modbus_request(request_data_array)
+ *
+ * Function to the correct request is returned and that the checksum
+ * is correct.
+ *
+ * Returns: string_length if OK
+ * 0 if failed
+ * Less than 0 for exception errors
+ *
+ * Note: All functions used for sending or receiving data via
+ * modbus return these return values.
+ *
+ **********************************************************************/
+
+int ModbusSlave232::modbus_request(unsigned char *data)
+{
+ int response_length;
+ unsigned int crc_calc = 0;
+ unsigned int crc_received = 0;
+ unsigned char recv_crc_hi;
+ unsigned char recv_crc_lo;
+
+ response_length = receive_request(data);
+
+ if (response_length > 0) {
+ crc_calc = crc(data, 0, response_length - 2);
+ recv_crc_hi = (unsigned) data[response_length - 2];
+ recv_crc_lo = (unsigned) data[response_length - 1];
+ crc_received = data[response_length - 2];
+ crc_received = (unsigned) crc_received << 8;
+ crc_received =
+ crc_received | (unsigned) data[response_length - 1];
+
+ /*********** check CRC of response ************/
+ if (crc_calc != crc_received) {
+ return NO_REPLY;
+ }
+
+ /* check for slave id */
+ if (slave != data[SLAVE]) {
+ return NO_REPLY;
+ }
+ }
+ return (response_length);
+}
+
+/*********************************************************************
+ *
+ * validate_request(request_data_array, request_length, available_regs)
+ *
+ * Function to check that the request can be processed by the slave.
+ *
+ * Returns: 0 if OK
+ * A negative exception code on error
+ *
+ **********************************************************************/
+
+int ModbusSlave232::validate_request(unsigned char *data, unsigned char length,
+unsigned int regs_size)
+{
+ int i, fcnt = 0;
+ unsigned int regs_num = 0;
+ unsigned int start_addr = 0;
+ unsigned char max_regs_num;
+
+ /* check function code */
+ for (i = 0; i < sizeof(fsupported); i++) {
+ if (fsupported[i] == data[FUNC]) {
+ fcnt = 1;
+ break;
+ }
+ }
+ if (0 == fcnt)
+ return EXC_FUNC_CODE;
+
+ if (FC_WRITE_REG == data[FUNC]) {
+ /* For function write single reg, this is the target reg.*/
+ regs_num = ((int) data[START_H] << 8) + (int) data[START_L];
+ if (regs_num >= regs_size)
+ return EXC_ADDR_RANGE;
+ return 0;
+ }
+
+ /* For functions read/write regs, this is the range. */
+ regs_num = ((int) data[REGS_H] << 8) + (int) data[REGS_L];
+
+ /* check quantity of registers */
+ if (FC_READ_REGS == data[FUNC])
+ max_regs_num = MAX_READ_REGS;
+ else if (FC_WRITE_REGS == data[FUNC])
+ max_regs_num = MAX_WRITE_REGS;
+
+ if ((regs_num < 1) || (regs_num > max_regs_num))
+ return EXC_REGS_QUANT;
+
+ /* check registers range, start address is 0 */
+ start_addr = ((int) data[START_H] << 8) + (int) data[START_L];
+ if ((start_addr + regs_num) > regs_size)
+ return EXC_ADDR_RANGE;
+
+ return 0; /* OK, no exception */
+}
+
+
+
+/************************************************************************
+ *
+ * write_regs(first_register, data_array, registers_array)
+ *
+ * writes into the slave's holding registers the data in query,
+ * starting at start_addr.
+ *
+ * Returns: the number of registers written
+ ************************************************************************/
+
+int ModbusSlave232::write_regs(unsigned int start_addr, unsigned char *query, int *regs)
+{
+ int temp;
+ unsigned int i;
+
+ for (i = 0; i < query[REGS_L]; i++) {
+ /* shift reg hi_byte to temp */
+ temp = (int) query[(BYTE_CNT + 1) + i * 2] << 8;
+ /* OR with lo_byte */
+ temp = temp | (int) query[(BYTE_CNT + 2) + i * 2];
+
+ regs[start_addr + i] = temp;
+ }
+ return i;
+}
+
+/************************************************************************
+ *
+ * preset_multiple_registers(first_register, number_of_registers,
+ * data_array, registers_array)
+ *
+ * Write the data from an array into the holding registers of the slave.
+ *
+ *************************************************************************/
+
+int ModbusSlave232::preset_multiple_registers(unsigned int start_addr,
+unsigned char count,
+unsigned char *query,
+int *regs)
+{
+ unsigned char function = FC_WRITE_REGS; /* Preset Multiple Registers */
+ int status = 0;
+ unsigned char packet[RESPONSE_SIZE + CHECKSUM_SIZE];
+
+ build_write_packet(function, start_addr, count, packet);
+
+ if (write_regs(start_addr, query, regs)) {
+ status = send_reply(packet, RESPONSE_SIZE);
+ }
+
+ return (status);
+}
+
+/************************************************************************
+ *
+ * write_single_register(slave_id, write_addr, data_array, registers_array)
+ *
+ * Write a single int val into a single holding register of the slave.
+ *
+ *************************************************************************/
+
+int ModbusSlave232::write_single_register(unsigned int write_addr, unsigned char *query, int *regs)
+{
+ unsigned char function = FC_WRITE_REG; /* Function: Write Single Register */
+ int status = 0;
+ unsigned int reg_val;
+ unsigned char packet[RESPONSE_SIZE + CHECKSUM_SIZE];
+
+ reg_val = query[REGS_H] << 8 | query[REGS_L];
+ build_write_single_packet(function, write_addr, reg_val, packet);
+ regs[write_addr] = (int) reg_val;
+/*
+ written.start_addr=write_addr;
+ written.num_regs=1;
+*/
+ status = send_reply(packet, RESPONSE_SIZE);
+
+ return (status);
+}
+
+/************************************************************************
+ *
+ * read_holding_registers(first_register, number_of_registers,
+ * registers_array)
+ *
+ * reads the slave's holdings registers and sends them to the Modbus master
+ *
+ *************************************************************************/
+
+int ModbusSlave232::read_holding_registers( unsigned int start_addr,
+
+unsigned char reg_count, int *regs)
+{
+ unsigned char function = FC_READ_REGS; /* Read Holding Registers */
+ int packet_size = 3;
+ int status;
+ unsigned int i;
+ unsigned char packet[MAX_MESSAGE_LENGTH];
+
+ build_read_packet(function, reg_count, packet);
+
+ for (i = start_addr; i < (start_addr + (unsigned int) reg_count);
+ i++) {
+ packet[packet_size] = regs[i] >> 8;
+ packet_size++;
+ packet[packet_size] = regs[i] & 0x00FF;
+ packet_size++;
+ }
+
+ status = send_reply(packet, packet_size);
+
+ return (status);
+}
+
+/*
+ * configure(slave, baud, parity, txenpin)
+ *
+ * sets the communication parameters for of the serial line.
+ *
+ * slave: identification number of the slave in the Modbus network (1 to 127)
+ * baud: baudrate in bps (typical values 9600, 19200... 115200)
+ * parity: a single character sets the parity mode (character frame format):
+ * 'n' no parity (8N1); 'e' even parity (8E1), 'o' for odd parity (8O1).
+ * txenpin: arduino pin number that controls transmision/reception
+ * of an external half-duplex device (e.g. a RS485 interface chip).
+ * 0 or 1 disables this function (for a two-device network)
+ * >2 for point-to-multipoint topology (e.g. several arduinos)
+ */
+
+void ModbusSlave232::configure(unsigned char slave, long baud, char parity)
+{
+ this->slave = slave;
+ //this->txenpin = 2; //afdhal
+
+
+
+ //Serial.begin(baud); //afdhal
+ pc.baud(baud);
+
+ switch (parity) {
+ case 'e': // 8E1
+ //UCSR0C |= ((1<<UPM01) | (1<<UCSZ01) | (1<<UCSZ00)); //afdhal
+ pc.format(8, SerialBase::Even, 1); //afdhal
+ // UCSR0C &= ~((1<<UPM00) | (1<<UCSZ02) | (1<<USBS0));
+ break;
+ case 'o': // 8O1
+ //UCSR0C |= ((1<<UPM01) | (1<<UPM00) | (1<<UCSZ01) | (1<<UCSZ00)); //afdhal
+ pc.format(8, SerialBase::Odd, 1); //afdhal
+ // UCSR0C &= ~((1<<UCSZ02) | (1<<USBS0));
+ break;
+ case 'n': // 8N1
+ //UCSR0C |= ((1<<UCSZ01) | (1<<UCSZ00)); //afdhal
+ pc.format(8, SerialBase::None, 1); //afdhal
+ // UCSR0C &= ~((1<<UPM01) | (1<<UPM00) | (1<<UCSZ02) | (1<<USBS0));
+ break;
+ default:
+ break;
+ }
+
+ /*
+ if (txenpin > 1) { // pin 0 & pin 1 are reserved for RX/TX
+ pinMode(txenpin, OUTPUT);
+ digitalWrite(txenpin, LOW);
+ }*/
+
+ return;
+}
+
+
+/*
+ * update(regs, regs_size)
+ *
+ * checks if there is any valid request from the modbus master. If there is,
+ * performs the requested action
+ *
+ * regs: an array with the holding registers. They start at address 1 (master point of view)
+ * regs_size: total number of holding registers.
+ * returns: 0 if no request from master,
+ * NO_REPLY (-1) if no reply is sent to the master
+ * an exception code (1 to 4) in case of a modbus exceptions
+ * the number of bytes sent as reply ( > 4) if OK.
+ */
+unsigned long Nowdt = 0;
+unsigned int lastBytesReceived;
+const unsigned long T35 = 5;
+
+int ModbusSlave232::update(int *regs,
+unsigned int regs_size)
+{
+ unsigned char query[MAX_MESSAGE_LENGTH];
+ unsigned char errpacket[EXCEPTION_SIZE + CHECKSUM_SIZE];
+ unsigned int start_addr;
+ int exception;
+ int length = pc.rxBufferGetCount(); //Serial.available(); //afdhal
+ unsigned long now = millis();
+
+
+
+ if (length == 0) {
+ lastBytesReceived = 0;
+ return 0;
+ }
+
+ if (lastBytesReceived != length) {
+ lastBytesReceived = length;
+ Nowdt = now + T35;
+ return 0;
+ }
+ if (now < Nowdt)
+ return 0;
+
+ lastBytesReceived = 0;
+
+ length = modbus_request(query);
+ if (length < 1)
+ return length;
+
+ exception = validate_request(query, length, regs_size);
+ if (exception) {
+ build_error_packet( query[FUNC], exception,
+ errpacket);
+ send_reply(errpacket, EXCEPTION_SIZE);
+ return (exception);
+ }
+
+ start_addr =
+ ((int) query[START_H] << 8) +
+ (int) query[START_L];
+
+ switch (query[FUNC]) {
+ case FC_READ_REGS:
+ return read_holding_registers(
+ start_addr,
+ query[REGS_L],
+ regs);
+ break;
+ case FC_WRITE_REGS:
+ return preset_multiple_registers(
+ start_addr,
+ query[REGS_L],
+ query,
+ regs);
+ break;
+ case FC_WRITE_REG:
+ write_single_register(
+ start_addr,
+ query,
+ regs);
+ break;
+ }
+
+}
+
+
+