Modbus.h

/*
    Modbus.h - Header for Modbus Base Library
    Copyright (C) 2014 André Sarmento Barbosa
    Copyright (C) 2023 Pascal JEAN aka epsilonrt
*/
#include "Arduino.h"
 
#pragma once
 
#define MAX_REGS     32 // Unused !
#define MAX_FRAME   128 // Unused !
//#define USE_HOLDING_REGISTERS_ONLY
 
// Function Codes
enum {
  MB_FC_READ_COILS       = 0x01, 
  MB_FC_READ_INPUT_STAT  = 0x02, 
  MB_FC_READ_REGS        = 0x03, 
  MB_FC_READ_INPUT_REGS  = 0x04, 
  MB_FC_WRITE_COIL       = 0x05, 
  MB_FC_WRITE_REG        = 0x06, 
  MB_FC_WRITE_COILS      = 0x0F, 
  MB_FC_WRITE_REGS       = 0x10, 
  MB_FC_REPORT_SERVER_ID = 0x11, 
};
 
// Exception Codes
enum {
  MB_EX_ILLEGAL_FUNCTION = 0x01, 
  MB_EX_ILLEGAL_ADDRESS  = 0x02, 
  MB_EX_ILLEGAL_VALUE    = 0x03, 
  MB_EX_SLAVE_FAILURE    = 0x04, 
};
 
// Reply Types
enum {
  MB_REPLY_OFF    = 0x01, 
  MB_REPLY_ECHO   = 0x02, 
  MB_REPLY_NORMAL = 0x03, 
};
 
#ifndef __DOXYGEN__
struct TExtData {
  word min;
  word max;
};
struct TRegister {
  word address;
  word value;
  TExtData *edata;
  TRegister *next;
  enum {
    CoilOffset = 1,
    IstsOffset = 10001,
    IregOffset = 30001,
    HregOffset = 40001
  };
};
#endif
 
class Modbus {
    #ifndef __DOXYGEN__
  private:
    TRegister *_regs_head;
    TRegister *_regs_last;
    char *_additional_data;
 
    void readRegisters (const byte fcode, const word startreg, const word numregs);
    void writeSingleRegister (const word reg, const word value);
    void writeMultipleRegisters (const byte *frame, const word startreg, const word numoutputs, const byte bytecount);
    void exceptionResponse (const byte fcode, const byte excode);
 
    #ifndef USE_HOLDING_REGISTERS_ONLY
    void readBits (const byte fcode, const word startreg, const word numregs);
    void writeSingleCoil (const word reg, const word status);
    void writeMultipleCoils (const byte *frame, const word startreg, const word numoutputs, const byte bytecount);
    #endif
 
    TRegister *searchRegister (word addr);
 
    void addReg (word address, word value = 0);
    bool setReg (word address, word value);
    word reg (word address);
    bool setRegBounds (word address, word min, word max);
    bool regOutOfBounds (word address, word value);
 
    // @deprecated
    inline bool Reg (word address, word value) {
      return setReg (address, value);
    }
    // @deprecated
    inline word Reg (word address) {
      return reg (address);
    }
 
  protected:
    byte *_frame;
    byte  _len;
    byte  _reply;
    Print *_debug;
    void receivePDU (byte *frame);
    void reportServerId();
    void debugMessage (bool reply = false);
    #endif
 
  public:
    Modbus();
 
    inline void addHreg (word offset, word value = 0) {
      this->addReg (offset + TRegister::HregOffset, value);
    }
    inline bool setHreg (word offset, word value) {
      return setReg (offset + TRegister::HregOffset, value);
    }
    inline word hreg (word offset) {
      return reg (offset + TRegister::HregOffset);
    }
    inline bool setHregBounds (word offset, word min, word max) {
      return setRegBounds (offset + TRegister::HregOffset, min, max);
    }
    inline bool hregOutOfBounds (word offset, word value) {
      return regOutOfBounds (offset + TRegister::HregOffset, value);
    }
    ;
    inline bool Hreg (word offset, word value) {
      return setHreg (offset, value);
    }
    inline word Hreg (word offset) {
      return hreg (offset);
    }
 
    inline void setDebug (Print &print) {
      _debug = &print;
      _debug->println ("Modbus: debug enabled....");
    }
 
    inline bool isDebug () {
      return _debug != nullptr;
    }
 
    inline void debug (const char *msg) {
      if (_debug) {
        _debug->println (msg);
      }
    }
 
    #ifndef USE_HOLDING_REGISTERS_ONLY
 
    void addCoil (word offset, bool value = false) {
      this->addReg (offset + TRegister::CoilOffset, value ? 0xFF00 : 0x0000);
    }
    inline void addIsts (word offset, bool value = false) {
      this->addReg (offset + TRegister::IstsOffset, value ? 0xFF00 : 0x0000);
    }
    inline void addIreg (word offset, word value = 0) {
      this->addReg (offset + TRegister::IregOffset, value);
    }
    inline bool setCoil (word offset, bool value) {
      return setReg (offset + TRegister::CoilOffset, value ? 0xFF00 : 0x0000);
    }
    inline bool setIsts (word offset, bool value) {
      return setReg (offset + TRegister::IstsOffset, value ? 0xFF00 : 0x0000);
    }
    inline bool setIreg (word offset, word value) {
      return setReg (offset + TRegister::IregOffset, value);
    }
    inline bool coil (word offset) {
      return (reg (offset + TRegister::CoilOffset) == 0xFF00);
    }
    inline bool ists (word offset) {
      return (reg (offset + TRegister::IstsOffset) == 0xFF00);
    }
    inline word ireg (word offset) {
      return reg (offset + TRegister::IregOffset);
    }
    inline bool Coil (word offset, bool value) {
      return setCoil (offset, value);
    }
    inline bool Ists (word offset, bool value) {
      return setIsts (offset, value);
    }
    inline bool Ireg (word offset, word value) {
      return setIreg (offset, value);
    }
    inline bool Coil (word offset) {
      return coil (offset);
    }
    inline bool Ists (word offset) {
      return ists (offset);
    }
    inline word Ireg (word offset) {
      return ireg (offset);
    }
    int setAdditionalServerData (const char data[]);
    #endif
};