regs.hxx

// dawn/include/dawn/proto/modbus/regs.hxx
//
// SPDX-License-Identifier: Apache-2.0
//
 
#pragma once
 
#include <mutex>
#include <vector>
 
#include "dawn/common/object.hxx"
#include "dawn/porting/config.hxx"
#include <nxmodbus/nxmodbus.h>
 
namespace dawn
{
// Forward declaration
 
struct io_ddata_t;
class CIOCommon;
 
class CProtoModbusRegs
{
public:
  enum
  {
    MODBUS_TYPE_COIL = 1,            
    MODBUS_TYPE_DISCRETE = 2,        
    MODBUS_TYPE_COIL_PACKED = 3,     
    MODBUS_TYPE_DISCRETE_PACKED = 4, 
    MODBUS_TYPE_INPUT = 5,           
    MODBUS_TYPE_HOLDING = 6,         
    MODBUS_TYPE_SEEKABLE = 7,        
  };
 
  struct
  {
    uint32_t type;    
    uint32_t config;  
    uint32_t start;   
    uint32_t size;    
    uint32_t objid[]; 
  } typedef SProtoModbusIOBind;
 
  struct
  {
    const SProtoModbusIOBind *cfg;    
    std::vector<io_ddata_t *> iodata; 
    std::mutex mutex;                 
    void *data;                       
    size_t regs;                      
    size_t size;                      
    int ios;                          
  } typedef SProtoModbusRegs;
 
  CProtoModbusRegs()
    : initialized(false)
  {
  }
 
  ~CProtoModbusRegs();
 
  void valloc_push_back(SProtoModbusIOBind *alloc);
  int createRegs();
  int destroyRegs();
 
#ifdef CONFIG_DAWN_PROTO_MODBUS_COIL
  int coilsCb(uint8_t *buf, uint16_t addr, uint16_t ncoils, enum nxmb_regmode_e mode, void *priv);
#endif
 
#ifdef CONFIG_DAWN_PROTO_MODBUS_DISCRETE
  int discreteCb(uint8_t *buf, uint16_t addr, uint16_t ndiscrete, void *priv);
#endif
 
#ifdef CONFIG_DAWN_PROTO_MODBUS_INPUT
  int inputCb(uint8_t *buf, uint16_t addr, uint16_t nregs, void *priv);
#endif
 
#ifdef CONFIG_DAWN_PROTO_MODBUS_HOLDING
  int holdingCb(uint8_t *buf, uint16_t addr, uint16_t nregs, enum nxmb_regmode_e mode, void *priv);
#endif
 
private:
#ifdef CONFIG_DAWN_PROTO_MODBUS_SEEKABLE
  struct
  {
    SProtoModbusRegs *reg;                 
    size_t windowRegs;                     
    std::vector<size_t> seekOffsets;       
    std::vector<size_t> readProgressWords; 
  } typedef SSeekableState;
#endif
 
  std::vector<SProtoModbusIOBind *> valloc;  
#ifdef CONFIG_DAWN_PROTO_MODBUS_COIL
  std::vector<SProtoModbusRegs *> vcoils;    
#endif
#ifdef CONFIG_DAWN_PROTO_MODBUS_DISCRETE
  std::vector<SProtoModbusRegs *> vdiscrete; 
#endif
#ifdef CONFIG_DAWN_PROTO_MODBUS_INPUT
  std::vector<SProtoModbusRegs *> vinput;    
#endif
#ifdef CONFIG_DAWN_PROTO_MODBUS_HOLDING
  std::vector<SProtoModbusRegs *> vholding;  
#endif
#ifdef CONFIG_DAWN_PROTO_MODBUS_SEEKABLE
  std::vector<SSeekableState *> vseekable;   
#endif
  bool initialized;                          
 
  virtual CIOCommon *getIO_(SObjectId::ObjectId id) = 0;
 
  SProtoModbusRegs *findGroup(uint16_t addr,
                              uint16_t n,
                              const std::vector<SProtoModbusRegs *> &regs);
 
  const SProtoModbusRegs *hasOverlap(const std::vector<SProtoModbusRegs *> &regs,
                                     uint32_t start,
                                     size_t count) const;
 
  void cleanupGroups(std::vector<SProtoModbusRegs *> &groups);
 
#if defined(CONFIG_DAWN_PROTO_MODBUS_COIL) || defined(CONFIG_DAWN_PROTO_MODBUS_DISCRETE)
  int regReadWriteCoil(uint8_t *buff, uint16_t n, int index, bool read, SProtoModbusRegs *reg);
 
  int regReadWriteCoilPacked(uint8_t *buff,
                             uint16_t n,
                             int index,
                             bool read,
                             SProtoModbusRegs *reg);
#endif
 
#if defined(CONFIG_DAWN_PROTO_MODBUS_INPUT) || defined(CONFIG_DAWN_PROTO_MODBUS_HOLDING)
  int regReadWriteHolding(uint8_t *buff, uint16_t n, int index, bool read, SProtoModbusRegs *reg);
 
  int standardRegRW(uint8_t *buff, uint16_t n, int index, bool read, SProtoModbusRegs *reg);
 
#  ifdef CONFIG_DAWN_PROTO_MODBUS_SEEKABLE
  int seekableRegRW(uint8_t *buff,
                    uint16_t n,
                    int index,
                    bool read,
                    SProtoModbusRegs *reg,
                    SSeekableState *seekState);
#  endif
#endif
 
#ifdef CONFIG_DAWN_PROTO_MODBUS_SEEKABLE
  SSeekableState *findSeekableState(SProtoModbusRegs *reg);
#endif
 
  int finalizeRegGroup(SProtoModbusRegs *tmp,
                       const SProtoModbusIOBind *v,
                       size_t seekWindowRegs,
                       bool addSeekableState);
};
 
} // Namespace dawn