Lydia - Printhead
Public Types | Public Member Functions | Public Attributes | List of all members
ModbusMaster< txBufSize, rxBufSize > Struct Template Reference

#include <ModbusMaster.h>

Inheritance diagram for ModbusMaster< txBufSize, rxBufSize >:
[legend]

Public Types

typedef Callback< void(Result)> CB
 
enum  FC : uint8_t {
  FC::none = 0x00, FC::readCoils = 0x01, FC::readDiscreteInputs = 0x02, FC::writeSingleCoil = 0x05,
  FC::writeMultipleCoils = 0x0F, FC::readHoldingRegisters = 0x03, FC::readInputRegisters = 0x04, FC::writeSingleRegister = 0x06,
  FC::writeMultipleRegisters = 0x10
}
 
enum  Result : uint8_t {
  Result::success = 0x00, Result::illegalFunction = 0x01, Result::illegalDataAddress = 0x02, Result::illegalDataValue = 0x03,
  Result::slaveDeviceFailure = 0x04, Result::acknowledge = 0x05, Result::slaveDeviceBusy = 0x06, Result::negativeAcknowledge = 0x07,
  Result::memoryParityError = 0x08, Result::timeout = 0xE0, Result::busy = 0xE1, Result::incompleteResponse = 0xE2,
  Result::invalidSlaveId = 0xE3, Result::invalidFunction = 0xE4, Result::invalidCRC = 0xE5
}
 
typedef TransactionSerial< rxBufSize > STX
 

Public Member Functions

void attachPostReceive (Callback< uint16_t(uint8_t *adu, uint16_t len)> f)
 
void attachPostTransmit (Callback< void()> f)
 
void attachPreTransmit (Callback< void()> f)
 
uint32_t crc16 (uint8_t *buf, int len)
 
uint8_t * getCoils ()
 
uint16_t * getRegisters ()
 
 ModbusMaster (EventQueue *queue, PinName txPin, PinName rxPin, int baud, uint8_t slaveId, std::chrono::milliseconds rxTimeout=50ms)
 
void readCoils (uint16_t addr, uint16_t num, CB cb)
 
void readDiscreteInputs (uint16_t addr, uint16_t num, CB cb)
 
void readHoldingRegisters (uint16_t addr, uint16_t num, CB cb)
 
void readInputRegisters (uint16_t addr, uint16_t num, CB cb)
 
void setCrcCheck (bool c)
 
void setSlaveId (uint8_t id)
 
void setTimeout (std::chrono::milliseconds t)
 
void transaction (FC fc, uint16_t addr, uint16_t num, uint8_t *val, CB cb)
 
void writeMultipleCoils (uint16_t addr, uint16_t num, uint8_t *val, CB cb)
 
void writeMultipleRegisters (uint16_t addr, uint16_t num, uint16_t *val, CB cb)
 
void writeSingleCoil (uint16_t addr, bool val, CB cb)
 
void writeSingleRegister (uint16_t addr, uint16_t val, CB cb)
 
void writeUInt16 (uint16_t val)
 

Public Attributes

uint8_t adu [txBufSize]
 
bool checkCrc = true
 
CB complete = NULL
 
Callback< uint16_t(uint8_t *adu, uint16_t len)> postReceive = NULL
 
FC reqFc = FC::none
 
uint8_t slaveId
 
STX stx
 
size_t txIdx = 0
 

Detailed Description

template<size_t txBufSize, size_t rxBufSize>
struct ModbusMaster< txBufSize, rxBufSize >

Definition at line 89 of file ModbusMaster.h.

Member Typedef Documentation

◆ CB

template<size_t txBufSize, size_t rxBufSize>
typedef Callback<void(Result)> ModbusMaster< txBufSize, rxBufSize >::CB

Definition at line 125 of file ModbusMaster.h.

◆ STX

template<size_t txBufSize, size_t rxBufSize>
typedef TransactionSerial<rxBufSize> ModbusMaster< txBufSize, rxBufSize >::STX

Definition at line 124 of file ModbusMaster.h.

Member Enumeration Documentation

◆ FC

template<size_t txBufSize, size_t rxBufSize>
enum ModbusMaster::FC : uint8_t
strong
Enumerator
none 
readCoils 
readDiscreteInputs 
writeSingleCoil 
writeMultipleCoils 
readHoldingRegisters 
readInputRegisters 
writeSingleRegister 
writeMultipleRegisters 

Definition at line 110 of file ModbusMaster.h.

110  : uint8_t { // Modbus Function Codes
111  none = 0x00,
112  // bit access
113  readCoils = 0x01,
114  readDiscreteInputs = 0x02,
115  writeSingleCoil = 0x05,
116  writeMultipleCoils = 0x0F,
117  // word access
118  readHoldingRegisters = 0x03,
119  readInputRegisters = 0x04,
120  writeSingleRegister = 0x06,
121  writeMultipleRegisters = 0x10,
122  };

◆ Result

template<size_t txBufSize, size_t rxBufSize>
enum ModbusMaster::Result : uint8_t
strong
Enumerator
success 
illegalFunction 
illegalDataAddress 
illegalDataValue 
slaveDeviceFailure 
acknowledge 
slaveDeviceBusy 
negativeAcknowledge 
memoryParityError 
timeout 
busy 
incompleteResponse 
invalidSlaveId 
invalidFunction 
invalidCRC 

Definition at line 90 of file ModbusMaster.h.

90  : uint8_t {
91  success = 0x00,
92  // modbus exceptions
93  illegalFunction = 0x01,
94  illegalDataAddress = 0x02,
95  illegalDataValue = 0x03,
96  slaveDeviceFailure = 0x04,
97  acknowledge = 0x05,
98  slaveDeviceBusy = 0x06,
99  negativeAcknowledge = 0x07,
100  memoryParityError = 0x08,
101  // response errors
102  timeout = 0xE0,
103  busy = 0xE1,
104  incompleteResponse = 0xE2,
105  invalidSlaveId = 0xE3,
106  invalidFunction = 0xE4,
107  invalidCRC = 0xE5,
108  };

Constructor & Destructor Documentation

◆ ModbusMaster()

template<size_t txBufSize, size_t rxBufSize>
ModbusMaster< txBufSize, rxBufSize >::ModbusMaster ( EventQueue *  queue,
PinName  txPin,
PinName  rxPin,
int  baud,
uint8_t  slaveId,
std::chrono::milliseconds  rxTimeout = 50ms 
)
inline

Definition at line 137 of file ModbusMaster.h.

144  : slaveId(slaveId),
145  stx(queue, txPin, rxPin, baud, std::chrono::microseconds((35 * MODBUS_MAX_LIFESPAN00) / baud), rxTimeout) {
146  }

Member Function Documentation

◆ attachPostReceive()

template<size_t txBufSize, size_t rxBufSize>
void ModbusMaster< txBufSize, rxBufSize >::attachPostReceive ( Callback< uint16_t(uint8_t *adu, uint16_t len)>  f)
inline

Definition at line 153 of file ModbusMaster.h.

153 { postReceive = f; };

◆ attachPostTransmit()

template<size_t txBufSize, size_t rxBufSize>
void ModbusMaster< txBufSize, rxBufSize >::attachPostTransmit ( Callback< void()>  f)
inline

Definition at line 152 of file ModbusMaster.h.

152 { stx.attachPostTransmit(f); };

◆ attachPreTransmit()

template<size_t txBufSize, size_t rxBufSize>
void ModbusMaster< txBufSize, rxBufSize >::attachPreTransmit ( Callback< void()>  f)
inline

Definition at line 151 of file ModbusMaster.h.

151 { stx.attachPreTransmit(f); };

◆ crc16()

template<size_t txBufSize, size_t rxBufSize>
uint32_t ModbusMaster< txBufSize, rxBufSize >::crc16 ( uint8_t *  buf,
int  len 
)
inline

Definition at line 163 of file ModbusMaster.h.

163  {
164  uint32_t crc = 0xFFFF;
165  for (int pos = 0; pos < len; pos++) {
166  crc ^= (uint32_t) buf[pos]; // XOR byte into least sig. byte of crc
167  for (int i = 8; i != 0; i--) { // Loop over each bit
168  if ((crc & 0x0001) != 0) { // If the LSB is set
169  crc >>= 1; // Shift right and XOR 0xA001
170  crc ^= 0xA001;
171  } else { // Else LSB is not set
172  crc >>= 1; // Just shift right
173  }
174  }
175  }
176  return crc;
177  }

◆ getCoils()

template<size_t txBufSize, size_t rxBufSize>
uint8_t* ModbusMaster< txBufSize, rxBufSize >::getCoils ( )
inline

Definition at line 155 of file ModbusMaster.h.

155 { return stx.rxBuf + 3; };

◆ getRegisters()

template<size_t txBufSize, size_t rxBufSize>
uint16_t* ModbusMaster< txBufSize, rxBufSize >::getRegisters ( )
inline

Definition at line 156 of file ModbusMaster.h.

156 { return reinterpret_cast<uint16_t*>(stx.rxBuf + 3); }

◆ readCoils()

template<size_t txBufSize, size_t rxBufSize>
void ModbusMaster< txBufSize, rxBufSize >::readCoils ( uint16_t  addr,
uint16_t  num,
CB  cb 
)
inline

Definition at line 281 of file ModbusMaster.h.

281  {
282  transaction(FC::readCoils, addr, num, NULL, cb);
283  }

◆ readDiscreteInputs()

template<size_t txBufSize, size_t rxBufSize>
void ModbusMaster< txBufSize, rxBufSize >::readDiscreteInputs ( uint16_t  addr,
uint16_t  num,
CB  cb 
)
inline

Definition at line 284 of file ModbusMaster.h.

284  {
285  transaction(FC::readDiscreteInputs, addr, num, NULL, cb);
286  }

◆ readHoldingRegisters()

template<size_t txBufSize, size_t rxBufSize>
void ModbusMaster< txBufSize, rxBufSize >::readHoldingRegisters ( uint16_t  addr,
uint16_t  num,
CB  cb 
)
inline

Definition at line 295 of file ModbusMaster.h.

295  {
296  transaction(FC::readHoldingRegisters, addr, num, NULL, cb);
297  }

◆ readInputRegisters()

template<size_t txBufSize, size_t rxBufSize>
void ModbusMaster< txBufSize, rxBufSize >::readInputRegisters ( uint16_t  addr,
uint16_t  num,
CB  cb 
)
inline

Definition at line 298 of file ModbusMaster.h.

298  {
299  transaction(FC::readInputRegisters, addr, num, NULL, cb);
300  }

◆ setCrcCheck()

template<size_t txBufSize, size_t rxBufSize>
void ModbusMaster< txBufSize, rxBufSize >::setCrcCheck ( bool  c)
inline

Definition at line 150 of file ModbusMaster.h.

150 { checkCrc = c; };

◆ setSlaveId()

template<size_t txBufSize, size_t rxBufSize>
void ModbusMaster< txBufSize, rxBufSize >::setSlaveId ( uint8_t  id)
inline

Definition at line 148 of file ModbusMaster.h.

148 { slaveId = id; };

◆ setTimeout()

template<size_t txBufSize, size_t rxBufSize>
void ModbusMaster< txBufSize, rxBufSize >::setTimeout ( std::chrono::milliseconds  t)
inline

Definition at line 149 of file ModbusMaster.h.

149 { stx.setTimeout(t); };

◆ transaction()

template<size_t txBufSize, size_t rxBufSize>
void ModbusMaster< txBufSize, rxBufSize >::transaction ( FC  fc,
uint16_t  addr,
uint16_t  num,
uint8_t *  val,
CB  cb 
)
inline

Definition at line 179 of file ModbusMaster.h.

179  {
180  txIdx = 0;
181  reqFc = fc;
182  complete = cb;
183 
184  // Build Request
185  // ==============================================
186  adu[txIdx++] = slaveId;
187  adu[txIdx++] = static_cast<uint8_t>(fc);
188  writeUInt16(addr);
189  switch(fc) {
190  case FC::readCoils:
191  case FC::readDiscreteInputs:
192  case FC::writeMultipleCoils:
193  case FC::readHoldingRegisters:
194  case FC::readInputRegisters:
195  case FC::writeMultipleRegisters:
196  writeUInt16(num);
197  default:
198  break;
199  }
200  uint8_t payloadLen = 0;
201  switch(fc) {
202  case FC::writeSingleCoil:
203  payloadLen = 2;
204  break;
205  case FC::writeMultipleCoils:
206  payloadLen = (num / 8) + 1;
207  adu[txIdx++] = payloadLen;
208  break;
209  case FC::writeSingleRegister:
210  payloadLen = 2;
211  break;
212  case FC::writeMultipleRegisters:
213  payloadLen = num * 2;
214  adu[txIdx++] = payloadLen;
215  break;
216  default:
217  break;
218  }
219  for(int i = 0; i < payloadLen; i++) adu[txIdx++] = val[i];
220  uint32_t crc = crc16(adu, txIdx);
221  adu[txIdx++] = crc;
222  adu[txIdx++] = crc >> 8;
223 
224  // Serial Transaction
225  // ============================================
226  stx.transact(adu, txIdx, [this](auto result) {
227  if(result != STX::Result::success) {
228  complete((Result) result);
229  return;
230  }
231 
232  uint32_t rxLen = stx.rxIdx;
233  if(postReceive) rxLen = postReceive(stx.rxBuf, rxLen);
234 
235  if(rxLen < 4) {
236  complete(Result::incompleteResponse);
237  return;
238  }
239 
240  if(checkCrc) {
241  uint32_t compCRC = crc16(stx.rxBuf, rxLen - 2);
242  uint16_t recvCRC = stx.rxBuf[rxLen - 2] | (stx.rxBuf[rxLen - 1] << 8);
243  if(recvCRC != compCRC) {
244  complete(Result::invalidCRC);
245  return;
246  }
247  }
248 
249  if(stx.rxBuf[0] != slaveId) {
250  complete(Result::invalidSlaveId);
251  return;
252  }
253 
254  if(static_cast<FC>(stx.rxBuf[1] & 0x7F) != reqFc) {
255  complete(Result::invalidFunction);
256  return;
257  }
258 
259  if(stx.rxBuf[1] & 0x80) { // Exception
260  complete(static_cast<Result>(stx.rxBuf[2]));
261  return;
262  }
263 
264  switch(reqFc) {
265  case FC::readHoldingRegisters:
266  case FC::readInputRegisters: {
267  uint16_t* reg = getRegisters();
268  uint8_t regCount = (rxLen - 5) / 2;
269  for(int i = 0; i < regCount; i++) {
270  reg[i] = __builtin_bswap16(reg[i]);
271  }
272  }
273  default:
274  break;
275  }
276 
277  complete(Result::success);
278  });
279  }

◆ writeMultipleCoils()

template<size_t txBufSize, size_t rxBufSize>
void ModbusMaster< txBufSize, rxBufSize >::writeMultipleCoils ( uint16_t  addr,
uint16_t  num,
uint8_t *  val,
CB  cb 
)
inline

Definition at line 291 of file ModbusMaster.h.

291  {
292  transaction(FC::writeMultipleCoils, addr, num, val, cb);
293  }

◆ writeMultipleRegisters()

template<size_t txBufSize, size_t rxBufSize>
void ModbusMaster< txBufSize, rxBufSize >::writeMultipleRegisters ( uint16_t  addr,
uint16_t  num,
uint16_t *  val,
CB  cb 
)
inline

Definition at line 306 of file ModbusMaster.h.

306  {
307  for(int i = 0; i < num; i++) val[i] = __builtin_bswap16(val[i]);
308  uint8_t* payload = reinterpret_cast<uint8_t*>(val);
309  transaction(FC::writeMultipleRegisters, addr, num, payload, cb);
310  }

◆ writeSingleCoil()

template<size_t txBufSize, size_t rxBufSize>
void ModbusMaster< txBufSize, rxBufSize >::writeSingleCoil ( uint16_t  addr,
bool  val,
CB  cb 
)
inline

Definition at line 287 of file ModbusMaster.h.

287  {
288  uint16_t payload = __builtin_bswap16(val ? 0xFF00 : 0x0000);
289  transaction(FC::writeSingleCoil, addr, 1, reinterpret_cast<uint8_t*>(&payload), cb);
290  }

◆ writeSingleRegister()

template<size_t txBufSize, size_t rxBufSize>
void ModbusMaster< txBufSize, rxBufSize >::writeSingleRegister ( uint16_t  addr,
uint16_t  val,
CB  cb 
)
inline

Definition at line 301 of file ModbusMaster.h.

301  {
302  val = __builtin_bswap16(val);
303  uint8_t* payload = reinterpret_cast<uint8_t*>(&val);
304  transaction(FC::writeSingleRegister, addr, 1, payload, cb);
305  }

◆ writeUInt16()

template<size_t txBufSize, size_t rxBufSize>
void ModbusMaster< txBufSize, rxBufSize >::writeUInt16 ( uint16_t  val)
inline

Definition at line 158 of file ModbusMaster.h.

158  {
159  adu[txIdx++] = val >> 8;
160  adu[txIdx++] = val;
161  }

Member Data Documentation

◆ adu

template<size_t txBufSize, size_t rxBufSize>
uint8_t ModbusMaster< txBufSize, rxBufSize >::adu[txBufSize]

Definition at line 134 of file ModbusMaster.h.

◆ checkCrc

template<size_t txBufSize, size_t rxBufSize>
bool ModbusMaster< txBufSize, rxBufSize >::checkCrc = true

Definition at line 129 of file ModbusMaster.h.

◆ complete

template<size_t txBufSize, size_t rxBufSize>
CB ModbusMaster< txBufSize, rxBufSize >::complete = NULL

Definition at line 130 of file ModbusMaster.h.

◆ postReceive

template<size_t txBufSize, size_t rxBufSize>
Callback<uint16_t(uint8_t* adu, uint16_t len)> ModbusMaster< txBufSize, rxBufSize >::postReceive = NULL

Definition at line 131 of file ModbusMaster.h.

◆ reqFc

template<size_t txBufSize, size_t rxBufSize>
FC ModbusMaster< txBufSize, rxBufSize >::reqFc = FC::none

Definition at line 135 of file ModbusMaster.h.

◆ slaveId

template<size_t txBufSize, size_t rxBufSize>
uint8_t ModbusMaster< txBufSize, rxBufSize >::slaveId

Definition at line 128 of file ModbusMaster.h.

◆ stx

template<size_t txBufSize, size_t rxBufSize>
STX ModbusMaster< txBufSize, rxBufSize >::stx

Definition at line 127 of file ModbusMaster.h.

◆ txIdx

template<size_t txBufSize, size_t rxBufSize>
size_t ModbusMaster< txBufSize, rxBufSize >::txIdx = 0

Definition at line 133 of file ModbusMaster.h.

The documentation for this struct was generated from the following file:
ModbusMaster::readCoils
void readCoils(uint16_t addr, uint16_t num, CB cb)
Definition: ModbusMaster.h:281
ModbusMaster::writeMultipleRegisters
void writeMultipleRegisters(uint16_t addr, uint16_t num, uint16_t *val, CB cb)
Definition: ModbusMaster.h:306
ModbusMaster::FC::readInputRegisters
@ readInputRegisters
ModbusMaster::Result::success
@ success
ModbusMaster::Result
Result
Definition: ModbusMaster.h:90
ModbusMaster::FC::writeSingleCoil
@ writeSingleCoil
ModbusMaster::stx
STX stx
Definition: ModbusMaster.h:127
ModbusMaster::transaction
void transaction(FC fc, uint16_t addr, uint16_t num, uint8_t *val, CB cb)
Definition: ModbusMaster.h:179
ModbusMaster::writeMultipleCoils
void writeMultipleCoils(uint16_t addr, uint16_t num, uint8_t *val, CB cb)
Definition: ModbusMaster.h:291
TransactionSerial::rxBuf
uint8_t rxBuf[rxBufSize]
Definition: ModbusMaster.h:19
ModbusMaster::FC::writeMultipleRegisters
@ writeMultipleRegisters
ModbusMaster::Result::invalidCRC
@ invalidCRC
ModbusMaster::FC::readDiscreteInputs
@ readDiscreteInputs
ModbusMaster::postReceive
Callback< uint16_t(uint8_t *adu, uint16_t len)> postReceive
Definition: ModbusMaster.h:131
ModbusMaster::FC::writeMultipleCoils
@ writeMultipleCoils
TransactionSerial::attachPreTransmit
void attachPreTransmit(Callback< void()> f)
Definition: ModbusMaster.h:41
ModbusMaster::Result::incompleteResponse
@ incompleteResponse
ModbusMaster::FC::readHoldingRegisters
@ readHoldingRegisters
ModbusMaster::Result::invalidSlaveId
@ invalidSlaveId
ModbusMaster::getRegisters
uint16_t * getRegisters()
Definition: ModbusMaster.h:156
TransactionSerial::rxIdx
size_t rxIdx
Definition: ModbusMaster.h:18
ModbusMaster::slaveId
uint8_t slaveId
Definition: ModbusMaster.h:128
ModbusMaster::FC::writeSingleRegister
@ writeSingleRegister
ModbusMaster::FC
FC
Definition: ModbusMaster.h:110
TransactionSerial::attachPostTransmit
void attachPostTransmit(Callback< void()> f)
Definition: ModbusMaster.h:42
ModbusMaster::writeSingleRegister
void writeSingleRegister(uint16_t addr, uint16_t val, CB cb)
Definition: ModbusMaster.h:301
ModbusMaster::FC::readCoils
@ readCoils
TransactionSerial::transact
void transact(uint8_t *txBuf, int txLen, Callback< void(Result)> cb)
Definition: ModbusMaster.h:75
ModbusMaster::reqFc
FC reqFc
Definition: ModbusMaster.h:135
TransactionSerial::setTimeout
void setTimeout(std::chrono::milliseconds t)
Definition: ModbusMaster.h:40
ModbusMaster::complete
CB complete
Definition: ModbusMaster.h:130
ModbusMaster::checkCrc
bool checkCrc
Definition: ModbusMaster.h:129
ModbusMaster::readInputRegisters
void readInputRegisters(uint16_t addr, uint16_t num, CB cb)
Definition: ModbusMaster.h:298
TransactionSerial::Result::success
@ success
ModbusMaster::adu
uint8_t adu[txBufSize]
Definition: ModbusMaster.h:134
ModbusMaster::readHoldingRegisters
void readHoldingRegisters(uint16_t addr, uint16_t num, CB cb)
Definition: ModbusMaster.h:295
ModbusMaster::writeSingleCoil
void writeSingleCoil(uint16_t addr, bool val, CB cb)
Definition: ModbusMaster.h:287
ModbusMaster::crc16
uint32_t crc16(uint8_t *buf, int len)
Definition: ModbusMaster.h:163
ModbusMaster::readDiscreteInputs
void readDiscreteInputs(uint16_t addr, uint16_t num, CB cb)
Definition: ModbusMaster.h:284
ModbusMaster::writeUInt16
void writeUInt16(uint16_t val)
Definition: ModbusMaster.h:158
ModbusMaster::Result::invalidFunction
@ invalidFunction
ModbusMaster::txIdx
size_t txIdx
Definition: ModbusMaster.h:133