dani/CommandStation-EX
1
0
Fork 0
mirror of https://github.com/DCC-EX/CommandStation-EX.git synced 2025-04-21 12:31:19 +02:00
Code Releases Activity
CommandStation-EX/IO_Modbus.h
travis-farmer 77f1c3c99f
first prototype EX-MB-ioexpander, CS side
2024-12-11 14:21:04 -05:00

620 lines
21 KiB
C++
Raw Blame History

/*
* © 2024, Travis Farmer. All rights reserved.
* © 2024, Chris Bulliner. All rights reserved. https://github.com/CMB27
*
* This file is part of DCC++EX API
*
* This 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 3 of the License, or
* (at your option) any later version.
*
* It 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 CommandStation. If not, see <https://www.gnu.org/licenses/>.
*/
/*
* Modbus
* =======
* To define a Modbus, example syntax:
* Modbus::create(bus, serial, baud[, cycletime[, pin]]);
*
* bus = 0-255
* serial = serial port to be used (e.g. Serial3)
* baud = baud rate (9600, 19200, 28800, 57600 or 115200)
* cycletime = minimum time between successive updates/reads of a node in millisecs (default 500ms)
* pin = pin number connected to RS485 module's DE and !RE terminals for half-duplex operation (default VPIN_NONE)
*
* Each bus must use a different serial port.
*
* ModbusNode
* ========
* To define a CMRI node and associate it with a CMRI bus,
* CMRInode::create(firstVPIN, numVPINs, bus, nodeID, type [, inputs, outputs]);
*
* firstVPIN = first vpin in block allocated to this device
* numVPINs = number of vpins (e.g. 72 for an SMINI node)
* bus = 0-255
* nodeID = 0-127
* numDiscreteInputs = number of discrete inputs
* numCoils = number of coils
*
* Reference: "LCS-9.10.1
* Layout Control Specification: CMRInet Protocol
* Version 1.1 December 2014."
*/
#ifndef IO_MODBUS_H
#define IO_MODBUS_H
#include "IODevice.h"
class ModbusADU {
public:
uint8_t *rtu = _adu + 6;
uint8_t *tcp = _adu;
uint8_t *pdu = _adu + 7;
uint8_t *data = _adu + 8;
void setTransactionId(uint16_t transactionId);
void setProtocolId(uint16_t protocolId);
void setLength(uint16_t length);
void setUnitId(uint8_t unitId);
void setFunctionCode(uint8_t functionCode);
void setDataRegister(uint8_t index, uint16_t value);
void setRtuLen(uint16_t rtuLen);
void setTcpLen(uint16_t tcpLen);
void setPduLen(uint16_t pduLen);
void setDataLen(uint16_t dataLen);
uint16_t getTransactionId();
uint16_t getProtocolId();
uint16_t getLength();
uint8_t getUnitId();
uint8_t getFunctionCode();
uint16_t getDataRegister(uint8_t index);
uint16_t getRtuLen();
uint16_t getTcpLen();
uint16_t getPduLen();
uint16_t getDataLen();
void updateCrc();
bool crcGood();
void prepareExceptionResponse(uint8_t exceptionCode);
private:
uint8_t _adu[262];
void _setRegister(uint8_t *buf, uint16_t index, uint16_t value);
uint16_t _getRegister(uint8_t *buf, uint16_t index);
uint16_t _calculateCrc(uint16_t len);
};
uint16_t div8RndUp(uint16_t value);
enum ModbusRTUCommError : uint8_t {
MODBUS_RTU_COMM_SUCCESS = 0,
MODBUS_RTU_COMM_TIMEOUT = 1,
MODBUS_RTU_COMM_FRAME_ERROR = 2,
MODBUS_RTU_COMM_CRC_ERROR = 3,
MODBUS_RTU_COMM_WAITING = 4
};
class ModbusRTUComm {
public:
ModbusRTUComm(Stream& serial, VPIN dePin = VPIN_NONE, VPIN rePin = VPIN_NONE);
void begin(unsigned long baud, uint32_t config = SERIAL_8N1);
void setTimeout(unsigned long timeout);
ModbusRTUCommError readAdu(ModbusADU& adu);
bool _waiting_for_read = false;
void writeAdu(ModbusADU& adu);
void clearRxBuffer();
Stream& _serial;
VPIN _dePin;
VPIN _rePin;
private:
unsigned long _charTimeout;
unsigned long _frameTimeout;
unsigned long _postDelay = 0UL;
unsigned long _readTimeout = 0UL;
unsigned long _startTimeout = 0UL;
};
enum ModbusRTUMasterError : uint8_t {
MODBUS_RTU_MASTER_SUCCESS = 0,
MODBUS_RTU_MASTER_INVALID_ID = 1,
MODBUS_RTU_MASTER_INVALID_BUFFER = 2,
MODBUS_RTU_MASTER_INVALID_QUANTITY = 3,
MODBUS_RTU_MASTER_RESPONSE_TIMEOUT = 4,
MODBUS_RTU_MASTER_FRAME_ERROR = 5,
MODBUS_RTU_MASTER_CRC_ERROR = 6,
MODBUS_RTU_MASTER_UNKNOWN_COMM_ERROR = 7,
MODBUS_RTU_MASTER_UNEXPECTED_ID = 8,
MODBUS_RTU_MASTER_EXCEPTION_RESPONSE = 9,
MODBUS_RTU_MASTER_UNEXPECTED_FUNCTION_CODE = 10,
MODBUS_RTU_MASTER_UNEXPECTED_LENGTH = 11,
MODBUS_RTU_MASTER_UNEXPECTED_BYTE_COUNT = 12,
MODBUS_RTU_MASTER_UNEXPECTED_ADDRESS = 13,
MODBUS_RTU_MASTER_UNEXPECTED_VALUE = 14,
MODBUS_RTU_MASTER_UNEXPECTED_QUANTITY = 15,
MODBUS_RTU_MASTER_WAITING = 16
};
/**********************************************************************
* Modbusnode class
*
* This encapsulates the state associated with a single Modbus node,
* which includes the nodeID, number of discrete inputs and coils, and
* the states of the discrete inputs and coils.
**********************************************************************/
class Modbusnode : public IODevice {
private:
uint8_t _busNo;
uint8_t _nodeID;
char _type;
Modbusnode *_next = NULL;
bool _initialised = false;
static const uint8_t _numCoils=100;
static const uint8_t _numDiscreteInputs=100;
static const uint8_t _numHoldingRegisters=100;
static const uint8_t _numInputRegisters=100;
uint8_t _numBO=0;
uint8_t _numBI=0;
uint8_t _numAO=0;
uint8_t _numAI=0;
int dataBO[16];
int dataBI[16];
int dataAO[84];
int dataAI[84];
int capePinsBI[16];
int capePinsBO[16];
int capePinsPU[16];
int capePinsAO[16];
int capePinsAI[16];
int configBPinsO[16];
int configBPinsI[16];
int configBPinsPU[16];
int configAPinsO[16];
int configAPinsI[16];
void resetInit() {
for (int i = 0; i < 16; i++) {
capePinsBI[i] = 0;
capePinsBO[i] = 0;
capePinsPU[i] = 0;
capePinsAO[i] = 0;
capePinsAI[i] = 0;
configBPinsO[i] = 0;
configBPinsI[i] = 0;
configBPinsPU[i] = 0;
configAPinsO[i] = 0;
configAPinsI[i] = 0;
}
}
void spitError(int pin) {
bool isBI = false;
bool isBO = false;
bool isPU = false;
bool isAI = false;
bool isAO = false;
int configPinNum = pin / 16;
int configPinBit = pin % 16;
if (bitRead(configBPinsI[configPinNum],configPinBit) == true) isBI = true;
if (bitRead(configBPinsO[configPinNum],configPinBit) == true) isBO = true;
if (bitRead(configBPinsPU[configPinNum],configPinBit) == true) isPU = true;
if (bitRead(configAPinsI[configPinNum],configPinBit) == true) isAI = true;
if (bitRead(configAPinsO[configPinNum],configPinBit) == true) isAO = true;
if (isBI && isPU) DIAG(F("IO_Modbus config eror: Bool Input with pull-up, pin: %d"),pin);
if (isBI && !isPU) DIAG(F("IO_Modbus config eror: Bool Input without pull-up, pin: %d"),pin);
if (isBO) DIAG(F("IO_Modbus config eror: Bool Output, pin: %d"),pin);
if (isAI) DIAG(F("IO_Modbus config eror: Analog Input, pin: %d"),pin);
if (isAO) DIAG(F("IO_Modbus config eror: Analog Output, pin: %d"),pin);
}
public:
static void create(VPIN firstVpin, int nPins, uint8_t busNo, uint8_t nodeID) {
if (checkNoOverlap(firstVpin, nPins)) new Modbusnode(firstVpin, nPins, busNo, nodeID);
}
Modbusnode(VPIN firstVpin, int nPins, uint8_t busNo, uint8_t nodeID);
int *coils[_numCoils];
int *discreteInputs[_numDiscreteInputs];
uint16_t *holdingRegisters[_numHoldingRegisters];
uint16_t *inputRegisters[_numInputRegisters];
uint8_t getNodeID() {
return _nodeID;
}
uint8_t getNumCoils() {
return _numCoils;
}
uint8_t getNumDiscreteInputs() {
return _numDiscreteInputs;
}
uint8_t getNumHoldingRegisters() {
return _numHoldingRegisters;
}
uint8_t getNumInputRegisters() {
return _numInputRegisters;
}
Modbusnode *getNext() {
return _next;
}
void setNext(Modbusnode *node) {
_next = node;
}
bool isInitialised() {
return _initialised;
}
void setInitialised() {
_initialised = true;
}
bool addPinBI(VPIN vpin, bool inputPullup) {
int configPinNum = vpin / 16;
int configPinBit = vpin % 16;
bitSet(configBPinsI[configPinNum],configPinBit); // input
bitWrite(configBPinsPU[configPinNum],configPinBit,inputPullup);
if (_numBI + _numBO + _numAI + _numAO > _nPins) {
DIAG(F("IO_Modbus config error: Too many I/O pins vs VPINs: %d"),_numBI + _numBO + _numAI + _numAO);
return true;
}
_numBI++;
return false;
}
bool addPinBO(VPIN vpin) {
int configPinNum = vpin / 16;
int configPinBit = vpin % 16;
bitSet(configBPinsO[configPinNum],configPinBit); // input
if (_numBI + _numBO + _numAI + _numAO > _nPins) {
DIAG(F("IO_Modbus config error: Too many I/O pins vs VPINs: %d"),_numBI + _numBO + _numAI + _numAO);
return true;
}
_numBO++;
return false;
}
bool addPinAI(VPIN vpin) {
int configPinNum = vpin / 6;
int configPinBit = vpin % 16;
bitSet(configAPinsI[configPinNum],configPinBit); // input
if (_numBI + _numBO + _numAI + _numAO > _nPins) {
DIAG(F("IO_Modbus config error: Too many I/O pins vs VPINs: %d"),_numBI + _numBO + _numAI + _numAO);
return true;
}
_numAI++;
return false;
}
bool addPinAO(VPIN vpin) {
int configPinNum = vpin / 6;
int configPinBit = vpin % 16;
bitSet(configAPinsO[configPinNum],configPinBit); // input
if (_numBI + _numBO + _numAI + _numAO > _nPins) {
DIAG(F("IO_Modbus config error: Too many I/O pins vs VPINs: %d"),_numBI + _numBO + _numAI + _numAO);
return true;
}
_numBI++;
return false;
}
bool _configure(VPIN vpin, ConfigTypeEnum configType, int paramCount, int params[]) override {
byte arduinoPin = params[1];
if (paramCount != 1) return false;
int pin = vpin - _firstVpin;
if (configType == CONFIGURE_INPUT) {
bool inputPullup = false;
if (params[2] == 1) inputPullup = true;
bool status = addPinBI(vpin,inputPullup);
if (status == false) {
return true;
} else
DIAG(F("IO_Modbus Vpin %u, Arduino Pin %d, cannot be used as a digital input pin"), (int)vpin, arduinoPin);
} else if (configType == CONFIGURE_OUTPUT) {
bool status = addPinBO(vpin);
if (status == false) {
return true;
} else
DIAG(F("IO_Modbus Vpin %u, Arduino Pin %d, cannot be used as a digital Output pin"), (int)vpin, arduinoPin);
} else if (configType == CONFIGURE_SERVO) {
//blah
} else if (configType == CONFIGURE_ANALOGOUTPUT) {
bool status = addPinAO(vpin);
if (status == false) {
return true;
} else
DIAG(F("IO_Modbus Vpin %u, Arduino Pin %d, cannot be used as a analog Output pin"), (int)vpin, arduinoPin);
} else if (configType == CONFIGURE_ANALOGINPUT) {
bool status = addPinAI(vpin);
if (status == false) {
return true;
} else
DIAG(F("IO_Modbus Vpin %u, Arduino Pin %d, cannot be used as a analog Input pin"), (int)vpin, arduinoPin);
}
return false;
}
void _begin() override {
resetInit();
coils[0] = (int*) 1; // set config mode
coils[1] = (int*) 1; // set pull capabilities
_initialised = false;
}
void procData() {
if (isInitialised()) { // read/write data
for (int i = 0; i < 16; i++) {
holdingRegisters[i] = (uint16_t*) dataBO[i];
dataBI[i] = (int) inputRegisters[i];
}
for (int i = 16; i < 84; i++) {
holdingRegisters[i] = (uint16_t*) dataAO[i];
dataAI[i] = (int) inputRegisters[i];
}
} else { // read/write config
if (discreteInputs[0] == (int*) 1 && discreteInputs[1] == (int*) 1){ // get capabilities
for (int i = 0; i < 16; i++) { // read capabilities params
capePinsBI[i] = (int) inputRegisters[i];
capePinsBO[i] = (int) inputRegisters[i+16];
capePinsPU[i] = (int) inputRegisters[i+32];
capePinsAI[i] = (int) inputRegisters[i+48];
capePinsAO[i] = (int) inputRegisters[i+64];
}
coils[0] = (int*) 1; // config mode
coils[1] = (int*) 0; // exit cape mode
for (int i = 0; i < 16; i++) { // load config params
holdingRegisters[i] = (uint16_t*) configBPinsI[i];
holdingRegisters[i+16] = (uint16_t*) configBPinsO[i];
holdingRegisters[i+32] = (uint16_t*) configBPinsPU[i];
holdingRegisters[i+48] = (uint16_t*) configAPinsI[i];
holdingRegisters[i+64] = (uint16_t*) configAPinsO[i];
}
} else if (discreteInputs[0] == (int*) 1 && discreteInputs[1] == (int*) 0) {
for (int i = 0; i < 16; i++) {
if (configBPinsI[i] != (int) inputRegisters[i]) spitError(i);
if (configBPinsO[i] != (int) inputRegisters[i+16]) spitError(i+16);
if (configBPinsPU[i] != (int) inputRegisters[i+32]) spitError(i+32);
if (configAPinsI[i] != (int) inputRegisters[i+48]) spitError(i+48);
if (configAPinsO[i] != (int) inputRegisters[i+64]) spitError(i+64);
}
// todo error checking and set failure mode
// for now, assume everything is fine, sort this out later if needed
coils[0] = (int*) 0; // exit config mode
coils[1] = (int*) 0; // not in cape mode
setInitialised();
}
}
}
int _read(VPIN vpin) override {
// Return current state from this device
uint16_t pin = vpin - _firstVpin;
int PinNum = pin / 16;
int PinBit = pin % 16;
if (bitRead(configAPinsI[PinNum],PinBit) == true) return bitRead(dataBI[PinNum],PinBit)? 1:0;
else return 0;
}
void _write(VPIN vpin, int value) override {
// Update current state for this device, in preparation the bus transmission
uint16_t pin = vpin - _firstVpin;
int PinNum = pin / 16;
int PinBit = pin % 16;
if (bitRead(configAPinsO[PinNum], PinBit) == true) {
if (value == 1) bitSet(dataBO[PinNum], PinBit);
else bitClear(dataBO[PinNum], PinBit);
}
}
int _readAnalogue(VPIN vpin) {
// Return acquired data value, e.g.
uint16_t pin = vpin - _firstVpin;
int PinNum = pin / 16;
int PinBit = pin % 16;
if (bitRead(configAPinsI[PinNum],PinBit) == true) return dataAI[pin];
else return 0;
}
void _writeAnalogue(VPIN vpin, int value) {
uint16_t pin = vpin - _firstVpin;
int PinNum = pin / 16;
int PinBit = pin % 16;
if (bitRead(configAPinsI[PinNum],PinBit) == true) dataAO[pin] = value;
}
uint8_t getBusNumber() {
return _busNo;
}
uint8_t getNumBinaryInputsVPINsMin() {
if (_numDiscreteInputs > 0) return _firstVpin;
else return 0;
}
uint8_t getNumBinaryInputsVPINsMax() {
if (_numDiscreteInputs > 0) return _firstVpin+_numDiscreteInputs-1;
else return 0;
}
uint8_t getNumBinaryOutputsVPINsMin() {
if (_numCoils > 0) return _firstVpin+_numDiscreteInputs;
else return 0;
}
uint8_t getNumBinaryOutputsVPINsMax() {
if (_numCoils > 0) return _firstVpin+_numDiscreteInputs+_numCoils-1;
else return 0;
}
uint8_t getNumAnalogInputsVPINsMin() {
if (_numInputRegisters > 0) return _firstVpin+_numDiscreteInputs+_numCoils;
else return 0;
}
uint8_t getNumAnalogInputsVPINsMax() {
if (_numInputRegisters > 0) return _firstVpin+_numDiscreteInputs+_numCoils+_numInputRegisters-1;
else return 0;
}
uint8_t getNumAnalogOutputsVPINsMin() {
if (_numHoldingRegisters > 0) return _firstVpin+_numDiscreteInputs+_numCoils+_numInputRegisters;
else return 0;
}
uint8_t getNumAnalogOutputsVPINsMax() {
if (_numHoldingRegisters > 0) return _firstVpin+_numDiscreteInputs+_numCoils+_numInputRegisters+_numHoldingRegisters-1;
else return 0;
}
void _display() override {
DIAG(F("Modbusnode configured on bus:%d nodeID:%d VPINs:%u-%u (B In) %u-%u (B Out) %u-%u (A In) %u-%u (A Out)"),
_busNo, _nodeID, getNumBinaryInputsVPINsMin(), getNumBinaryInputsVPINsMax(),
getNumBinaryOutputsVPINsMin(), getNumBinaryOutputsVPINsMax(),
getNumAnalogInputsVPINsMin(), getNumAnalogInputsVPINsMax(),
getNumAnalogOutputsVPINsMin(), getNumAnalogOutputsVPINsMax());
}
};
/**********************************************************************
* Modbus class
*
* This encapsulates the properties state of the bus and the
* transmission and reception of data across that bus. Each Modbus
* object owns a set of Modbusnode objects which represent the nodes
* attached to that bus.
**********************************************************************/
class Modbus : public IODevice {
private:
// Here we define the device-specific variables.
uint8_t _busNo;
unsigned long _baud;
int8_t _txPin;
Modbusnode *_nodeListStart = NULL, *_nodeListEnd = NULL;
Modbusnode *_currentNode = NULL;
uint8_t _exceptionResponse = 0;
uint8_t getExceptionResponse();
uint16_t _receiveDataIndex = 0; // Index of next data byte to be received.
Modbus *_nextBus = NULL; // Pointer to next bus instance in list.
void setTimeout(unsigned long timeout);
unsigned long _cycleStartTime = 0;
unsigned long _timeoutStart = 0;
unsigned long _cycleTime; // target time between successive read/write cycles, microseconds
unsigned long _timeoutPeriod; // timeout on read responses, in microseconds.
unsigned long _currentMicros; // last value of micros() from _loop function.
unsigned long _postDelay; // delay time after transmission before switching off transmitter (in us)
unsigned long _byteTransmitTime; // time in us for transmission of one byte
int _operationCount = 0;
static Modbus *_busList; // linked list of defined bus instances
ModbusRTUMasterError _readValues(uint8_t id, uint8_t functionCode, uint16_t startAddress, int buf[], uint16_t quantity);
ModbusRTUMasterError _readValues(uint8_t id, uint8_t functionCode, uint16_t startAddress, uint16_t buf[], uint16_t quantity);
ModbusRTUMasterError _writeSingleValue(uint8_t id, uint8_t functionCode, uint16_t address, uint16_t value);
int _waitCounter = 0;
int _waitCounterB = 0;
int _waitA;
int _waitB;
void _resetWaiting() {
_rtuComm._waiting_for_read = false;
}
public:
static void create(uint8_t busNo, HardwareSerial& serial, unsigned long baud, uint16_t cycleTimeMS=500, int8_t txPin=-1, int waitA=10, int waitB=10) {
new Modbus(busNo, serial, baud, cycleTimeMS, txPin, waitA, waitB);
}
HardwareSerial *_serialD;
ModbusRTUComm _rtuComm;
// Device-specific initialisation
void _begin() override {
_serialD->begin(_baud, SERIAL_8N1);
_rtuComm.begin(_baud, SERIAL_8N1);
#if defined(MODBUS_STM_OK)
pinMode(MODBUS_STM_OK, OUTPUT);
ArduinoPins::fastWriteDigital(MODBUS_STM_OK,LOW);
#endif
#if defined(MODBUS_STM_FAIL)
pinMode(MODBUS_STM_FAIL, OUTPUT);
ArduinoPins::fastWriteDigital(MODBUS_STM_FAIL,LOW);
#endif
#if defined(MODBUS_STM_COMM)
pinMode(MODBUS_STM_COMM, OUTPUT);
ArduinoPins::fastWriteDigital(MODBUS_STM_COMM,LOW);
#endif
#if defined(DIAG_IO)
_display();
#endif
}
ModbusRTUMasterError _translateCommError(ModbusRTUCommError commError);
ModbusRTUMasterError readCoils(uint8_t id, uint16_t startAddress, int buf[], uint16_t quantity);
ModbusRTUMasterError readDiscreteInputs(uint8_t id, uint16_t startAddress, int buf[], uint16_t quantity);
ModbusRTUMasterError readHoldingRegisters(uint8_t id, uint16_t startAddress, uint16_t buf[], uint16_t quantity);
ModbusRTUMasterError readInputRegisters(uint8_t id, uint16_t startAddress, uint16_t buf[], uint16_t quantity);
ModbusRTUMasterError writeSingleCoil(uint8_t id, uint16_t address, int value);
ModbusRTUMasterError writeSingleHoldingRegister(uint8_t id, uint16_t address, uint16_t value);
ModbusRTUMasterError writeMultipleCoils(uint8_t id, uint16_t startAddress, int buf[], uint16_t quantity);
ModbusRTUMasterError writeMultipleHoldingRegisters(uint8_t id, uint16_t startAddress, uint16_t buf[], uint16_t quantity);
// Loop function (overriding IODevice::_loop(unsigned long))
void _loop(unsigned long currentMicros) override;
// Display information about the device
void _display() override {
DIAG(F("Modbus Configured on Vpins:%d-%d %S"), _firstVpin, _firstVpin+_nPins-1,
_deviceState == DEVSTATE_FAILED ? F("OFFLINE") : F("OK"));
}
// Locate Modbusnode object with specified nodeID.
Modbusnode *findNode(uint8_t nodeID) {
for (Modbusnode *node = _nodeListStart; node != NULL; node = node->getNext()) {
if (node->getNodeID() == nodeID)
return node;
}
return NULL;
}
// Add new Modbusnode to the list of nodes for this bus.
void addNode(Modbusnode *newNode) {
if (!_nodeListStart)
_nodeListStart = newNode;
if (!_nodeListEnd)
_nodeListEnd = newNode;
else
_nodeListEnd->setNext(newNode);
//DIAG(F("Modbus: 260h nodeID:%d _nodeListStart:%d _nodeListEnd:%d"), newNode, _nodeListStart, _nodeListEnd);
}
protected:
Modbus(uint8_t busNo, HardwareSerial &serial, unsigned long baud, uint16_t cycleTimeMS, int8_t txPin, int waitA, int waitB);
public:
uint8_t getBusNumber() {
return _busNo;
}
static Modbus *findBus(uint8_t busNo) {
for (Modbus *bus=_busList; bus!=NULL; bus=bus->_nextBus) {
if (bus->_busNo == busNo) return bus;
}
return NULL;
}
};
#endif // IO_MODBUS_H
View Git Blame Copy Permalink