dani/CommandStation-EX
1
0
Fork 0
mirror of https://github.com/DCC-EX/CommandStation-EX.git synced 2024-11-27 01:56:14 +01:00
Code Releases Activity

Add HAL driver for CMRInet protocol

Browse Source
This commit is contained in:
Neil McKechnie 2023-03-20 17:23:50 +00:00
parent 337bd969a1
commit 757b212c81
2 changed files with 497 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

177
IO_CMRI.cpp Normal file
View File

@ -0,0 +1,177 @@
/*
* © 2023, Neil McKechnie. All rights reserved.
*
* 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/>.
*/
#include "IO_CMRI.h"
// Main loop function for CMRIbus.
// Work through list of nodes. For each node, in separate loop entries
// send initialisation message (once only); then send
// output message; then send prompt for input data, and
// process any response data received.
// When the slot time has finished, move on to the next device.
void CMRIbus::_loop(unsigned long currentMicros) {
_currentMicros = currentMicros;
while (_serial->available())
processIncoming();
// Send any data that needs sending.
processOutgoing();
}
void CMRIbus::processOutgoing() {
if (_currentNode == NULL) {
// If we're between read/write cycles then don't do anything else.
if (_currentMicros - _cycleStartTime < _cycleTime) return;
// ... otherwise start processing the first node in the list
_currentNode = _nodeListStart;
_transmitState = TD_INIT;
_cycleStartTime = _currentMicros;
}
if (_currentNode == NULL) return;
switch (_transmitState) {
case TD_IDLE:
case TD_INIT:
if (!_currentNode->isInitialised()) {
sendInitialisation(_currentNode);
_currentNode->setInitialised();
_transmitState = TD_TRANSMIT;
break;
}
/* fallthrough */
case TD_TRANSMIT:
sendData(_currentNode);
_transmitState = TD_PROMPT;
break;
case TD_PROMPT:
requestData(_currentNode);
_transmitState = TD_RECEIVE;
_timeoutStart = _currentMicros; // Start timeout on response
break;
case TD_RECEIVE: // Waiting for response / timeout
if (_currentMicros - _timeoutStart > _timeoutPeriod) {
// End of time slot allocated for responses.
_transmitState = TD_IDLE;
// Reset state of receiver
_receiveState = RD_SYN1;
// Move to next node
_currentNode = _currentNode->getNext();
}
break;
}
}
// Process any data bytes received from a CMRInode.
void CMRIbus::processIncoming() {
int data = _serial->read();
if (data < 0) return; // No characters to read
if (!_currentNode) return; // Not waiting for input, so ignore.
uint8_t nextState = RD_SYN1; // default to resetting state machine
switch(_receiveState) {
case RD_SYN1:
if (data == SYN) nextState = RD_SYN2;
break;
case RD_SYN2:
if (data == SYN) nextState = RD_STX;
break;
case RD_STX:
if (data == STX) nextState = RD_ADDR;
break;
case RD_ADDR:
// If address doesn't match, then ignore everything until next SYN-SYN-STX.
if (data == _currentNode->getAddress() + 65) nextState = RD_TYPE;
break;
case RD_TYPE:
_receiveDataIndex = 0; // Initialise data pointer
if (data == 'R') nextState = RD_DATA;
break;
case RD_DATA: // data body
if (data == DLE) // escape next character
nextState = RD_ESCDATA;
else if (data == ETX) { // end of data
// End of data message. Protocol has all data in one
// message, so we don't need to wait any more. Allow
// transmitter to proceed with next node in list.
_currentNode = _currentNode->getNext();
_transmitState = TD_IDLE;
} else {
// Not end yet, so save data byte
_currentNode->saveIncomingData(_receiveDataIndex++, data);
nextState = RD_DATA; // wait for more data
}
break;
case RD_ESCDATA: // escaped data byte
_currentNode->saveIncomingData(_receiveDataIndex++, data);
nextState = RD_DATA;
break;
}
_receiveState = nextState;
}
// Constructor for CMRInode object
CMRInode::CMRInode(VPIN firstVpin, int nPins, uint8_t busNo, uint8_t address, char type, uint16_t inputs, uint16_t outputs) {
_firstVpin = firstVpin;
_nPins = nPins;
_busNo = busNo;
_address = address;
_type = type;
switch (_type) {
case 'M': // SMINI, fixed 24 inputs and 48 outputs
_numInputs = 24;
_numOutputs = 48;
break;
case 'C': // CPNODE with 16 to 144 inputs/outputs using 8-bit cards
_numInputs = inputs;
_numOutputs = outputs;
break;
case 'N': // Classic USIC and SUSIC using 24 bit i/o cards
case 'X': // SUSIC using 32 bit i/o cards
default:
DIAG(F("CMRInode: bus:%d address:%d ERROR unsupported type %c"), _busNo, _address, _type);
return; // Don't register device.
}
if ((unsigned int)_nPins < _numInputs + _numOutputs)
DIAG(F("CMRInode: bus:%d address:%d WARNING number of Vpins does not cover all inputs and outputs"), _busNo, _address);
// Allocate memory for states
_inputStates = (uint8_t *)calloc((_numInputs+7)/8, 1);
_outputStates = (uint8_t *)calloc((_numOutputs+7)/8, 1);
if (!_inputStates || !_outputStates) {
DIAG(F("CMRInode: ERROR insufficient memory"));
return;
}
// Add this device to HAL device list
IODevice::addDevice(this);
// Add CMRInode to CMRIbus object.
CMRIbus *bus = CMRIbus::findBus(_busNo);
if (bus != NULL) {
bus->addNode(this);
return;
}
}
// Link to chain of CMRI bus instances
CMRIbus *CMRIbus::_busList = NULL;

320
IO_CMRI.h Normal file
View File

@ -0,0 +1,320 @@
/*
* © 2023, Neil McKechnie. All rights reserved.
*
* 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/>.
*/
/*
* To define a CMRI bus,
* CMRIbus::create(bus, Serial3, 19200, cycletime);
*
* bus = 0-255
* Serial3 = serial port to be used
* 19200 = baud rate (min 9600, max 115200)
* cycletime = minimum time between successive updates/reads of a node in millisecs
*
* Each bus must use a different serial port.
*
* To define a CMRI node and associate it with a CMRI bus,
* CMRInode:create(bus, address, type [, inputs, outputs]);
*
* bus = 0-255
* address = 0-127
* type = 'M' for SMINI (fixed 24 inputs and 48 outputs)
* 'C' for CPNODE (16 to 144 inputs/outputs in groups of 8)
* (other types are not supported at this time).
* inputs = number of inputs (CPNODE)
* outputs = number of outputs (CPNODE)
*
* Reference: "LCS-9.10.1
* Layout Control Specification: CMRInet Protocol
* Version 1.1 December 2014."
*/
#ifndef IO_CMRI_H
#define IO_CMRI_H
#include "IODevice.h"
/**********************************************************************
* CMRInode class
*
* This encapsulates the state associated with a single CMRI node,
* which includes the address type, number of inputs and outputs, and
* the states of the inputs and outputs.
**********************************************************************/
class CMRInode : public IODevice {
private:
uint8_t _busNo;
uint8_t _address;
char _type;
CMRInode *_next = NULL;
uint8_t *_inputStates = NULL;
uint8_t *_outputStates = NULL;
uint16_t _numInputs = 0;
uint16_t _numOutputs = 0;
bool _initialised = false;
public:
static void create(VPIN firstVpin, int nPins, uint8_t busNo, uint8_t address, char type, uint16_t inputs=0, uint16_t outputs=0) {
if (checkNoOverlap(firstVpin, nPins)) new CMRInode(firstVpin, nPins, busNo, address, type, inputs, outputs);
}
CMRInode(VPIN firstVpin, int nPins, uint8_t busNo, uint8_t address, char type, uint16_t inputs=0, uint16_t outputs=0);
uint8_t getAddress() {
return _address;
}
CMRInode *getNext() {
return _next;
}
void setNext(CMRInode *node) {
_next = node;
}
bool isInitialised() {
return _initialised;
}
void setInitialised() {
_initialised = true;
}
void _begin() {
_initialised = false;
}
int _read(VPIN vpin) {
// Return current state from this device
uint16_t pin = vpin - _firstVpin;
if (pin < _numInputs) {
uint8_t mask = 1 << (pin & 0x7);
int index = pin / 8;
return (_inputStates[index] & mask) != 0;
} else
return 0;
}
void _write(VPIN vpin, int value) {
// Update current state for this device, in preparation the bus transmission
uint16_t pin = vpin - _firstVpin - _numInputs;
if (pin < _numOutputs) {
uint8_t mask = 1 << (pin & 0x7);
int index = pin / 8;
if (value)
_outputStates[index] |= mask;
else
_outputStates[index] &= ~mask;
}
}
void saveIncomingData(uint8_t index, uint8_t data) {
if (index < (_numInputs+7)/8)
_inputStates[index] = data;
}
uint8_t getOutputStates(uint8_t index) {
if (index < (_numOutputs+7)/8)
return _outputStates[index];
else
return 0;
}
uint16_t getNumInputs() {
return _numInputs;
}
uint16_t getNumOutputs() {
return _numOutputs;
}
char getType() {
return _type;
}
uint8_t getBusNumber() {
return _busNo;
}
void _display() override {
DIAG(F("CMRInode type:'%c' configured on bus:%d address:%d VPINs:%u-%u (in) %u-%u (out)"),
_type, _busNo, _address, _firstVpin, _firstVpin+_numInputs-1,
_firstVpin+_numInputs, _firstVpin+_numInputs+_numOutputs-1);
}
};
/**********************************************************************
* CMRIbus class
*
* This encapsulates the properties state of the bus and the
* transmission and reception of data across that bus. Each CMRIbus
* object owns a set of CMRInode objects which represent the nodes
* attached to that bus.
**********************************************************************/
class CMRIbus : public IODevice {
private:
// Here we define the device-specific variables.
uint8_t _busNo;
HardwareSerial *_serial;
unsigned long _baud;
CMRInode *_nodeListStart = NULL, *_nodeListEnd = NULL;
CMRInode *_currentNode = NULL;
// Transmitter state machine states
enum {TD_IDLE, TD_INIT, TD_TRANSMIT, TD_PROMPT, TD_RECEIVE};
uint8_t _transmitState = TD_IDLE;
// Receiver state machine states.
enum {RD_SYN1, RD_SYN2, RD_STX, RD_ADDR, RD_TYPE,
RD_DATA, RD_ESCDATA, RD_SKIPDATA, RD_SKIPESCDATA, RD_ETX};
uint8_t _receiveState = RD_SYN1;
uint16_t _receiveDataIndex = 0; // Index of next data byte to be received.
CMRIbus *_nextBus = NULL; // Pointer to next bus instance in list.
unsigned long _cycleStartTime = 0;
unsigned long _timeoutStart = 0;
unsigned long _cycleTime; // target time between successive read/write cycles, microseconds
uint32_t _timeoutPeriod; // timeout on read responses, in microseconds.
unsigned long _currentMicros; // last value of micros() from _loop function.
static CMRIbus *_busList; // linked list of defined bus instances
// Definition of special characters in CMRInet protocol
enum : uint8_t {
STX = 0x02,
ETX = 0x03,
DLE = 0x10,
SYN = 0xff,
};
public:
static void create(uint8_t busNo, HardwareSerial &serial, unsigned long baud, uint16_t cycleTimeMS = 500) {
new CMRIbus(busNo, serial, baud, cycleTimeMS);
}
// Add new CMRInode to the list of nodes for this bus.
void addNode(CMRInode *newNode) {
if (!_nodeListStart)
_nodeListStart = newNode;
if (!_nodeListEnd)
_nodeListEnd = newNode;
else
_nodeListEnd->setNext(newNode);
}
protected:
CMRIbus(uint8_t busNo, HardwareSerial &serial, unsigned long baud, uint16_t cycleTimeMS) {
_busNo = busNo;
_serial = &serial;
_baud = baud;
_cycleTime = cycleTimeMS * 1000UL; // convert from milliseconds to microseconds.
// Max message length is 256+6=262 bytes.
// Each byte is one start bit, 8 data bits and 1 stop bit = 10 bits per byte.
// Calculate timeout based on double this time.
_timeoutPeriod = 2 * 10 * 262 * 1000UL / (_baud / 1000);
//DIAG(F("Timeout=%l"), _timeoutPeriod);
// Add device to HAL device chain
IODevice::addDevice(this);
// Add bus to CMRIbus chain.
_nextBus = _busList;
_busList = this;
}
// Device-specific initialisation
void _begin() override {
// Some sources quote one stop bit, some two.
_serial->begin(_baud, SERIAL_8N1);
#if defined(DIAG_IO)
_display();
#endif
}
void _loop(unsigned long currentMicros) override;
// Display information about the device.
void _display() override {
DIAG(F("CMRIbus %d configured, speed=%d baud, cycle=%d ms"), _busNo, _baud, _cycleTime/1000);
}
// Locate CMRInode object with specified address.
CMRInode *findNode(uint8_t address) {
for (CMRInode *node = _nodeListStart; node != NULL; node = node->getNext()) {
if (node->getAddress() == address)
return node;
}
return NULL;
}
// Send output data to the bus for nominated CMRInode
bool sendData(CMRInode *node) {
uint16_t numDataBytes = (node->getNumOutputs()+7)/8;
_serial->write(SYN);
_serial->write(SYN);
_serial->write(STX);
_serial->write(node->getAddress() + 65);
_serial->write('T'); // T for Transmit data message
for (uint8_t index=0; index<numDataBytes; index++) {
uint8_t value = node->getOutputStates(index);
if (value == DLE || value == STX || value == ETX) _serial->write(DLE);
_serial->write(value);
}
_serial->write(ETX);
return true;
}
// Send request for input data to nominated CMRInode.
bool requestData(CMRInode *node) {
_serial->write(SYN);
_serial->write(SYN);
_serial->write(STX);
_serial->write(node->getAddress() + 65);
_serial->write('P'); // P for Poll message
_serial->write(ETX);
return true;
}
bool sendInitialisation(CMRInode *node) {
_serial->write(SYN);
_serial->write(SYN);
_serial->write(STX);
_serial->write(node->getAddress() + 65);
_serial->write('I'); // I for initialise message
_serial->write(node->getType()); // NDP
_serial->write(0); // dH
_serial->write(0); // dL
_serial->write(0); // NS
_serial->write(ETX);
return true;
}
// Process any data bytes received from a CMRInode.
void processIncoming();
// Process any outgoing traffic that is due.
void processOutgoing();
public:
uint8_t getBusNumber() {
return _busNo;
}
static CMRIbus *findBus(uint8_t busNo) {
for (CMRIbus *bus=_busList; bus!=NULL; bus=bus->_nextBus) {
if (bus->_busNo == busNo) return bus;
}
return NULL;
}
};
#endif // IO_CMRI_H