text: /*
   * Copyright © 2001-2013 Stéphane Raimbault <stephane.raimbault@gmail.com>
   *
   * SPDX-License-Identifier: LGPL-2.1+
   */
  
  #ifndef MODBUS_H
  #define MODBUS_H
  
  /* Add this for macros that defined unix flavor */
  #if (defined(__unix__) || defined(unix)) && !defined(USG)
  #include <sys/param.h>
  #endif
  
  #ifndef _MSC_VER
  #include <stdint.h>
  #else
  #include "stdint.h"
  #endif
  
  #include "modbus-version.h"
  
  #if defined(_MSC_VER)
  # if defined(DLLBUILD)
  /* define DLLBUILD when building the DLL */
  #  define MODBUS_API __declspec(dllexport)
  # elif defined(STATICBUILD)
  #  define MODBUS_API 
  # else
  #  define MODBUS_API __declspec(dllimport)
  # endif
  #else
  # define MODBUS_API
  #endif
  
  #ifdef  __cplusplus
  # define MODBUS_BEGIN_DECLS  extern "C" {
  # define MODBUS_END_DECLS    }
  #else
  # define MODBUS_BEGIN_DECLS
  # define MODBUS_END_DECLS
  #endif
  
  MODBUS_BEGIN_DECLS
  
  #ifndef FALSE
  #define FALSE 0
  #endif
  
  #ifndef TRUE
  #define TRUE 1
  #endif
  
  #ifndef OFF
  #define OFF 0
  #endif
  
  #ifndef ON
  #define ON 1
  #endif
  
  /* Modbus function codes */
  #define MODBUS_FC_READ_COILS                0x01
  #define MODBUS_FC_READ_DISCRETE_INPUTS      0x02
  #define MODBUS_FC_READ_HOLDING_REGISTERS    0x03
  #define MODBUS_FC_READ_INPUT_REGISTERS      0x04
  #define MODBUS_FC_WRITE_SINGLE_COIL         0x05
  #define MODBUS_FC_WRITE_SINGLE_REGISTER     0x06
  #define MODBUS_FC_READ_EXCEPTION_STATUS     0x07
  #define MODBUS_FC_WRITE_MULTIPLE_COILS      0x0F
  #define MODBUS_FC_WRITE_MULTIPLE_REGISTERS  0x10
  #define MODBUS_FC_REPORT_SLAVE_ID           0x11
  #define MODBUS_FC_MASK_WRITE_REGISTER       0x16
  #define MODBUS_FC_WRITE_AND_READ_REGISTERS  0x17
  
  #define MODBUS_BROADCAST_ADDRESS    0
  
  /* Modbus_Application_Protocol_V1_1b.pdf (chapter 6 section 1 page 12)
   * Quantity of Coils to read (2 bytes): 1 to 2000 (0x7D0)
   * (chapter 6 section 11 page 29)
   * Quantity of Coils to write (2 bytes): 1 to 1968 (0x7B0)
   */
  #define MODBUS_MAX_READ_BITS              2000
  #define MODBUS_MAX_WRITE_BITS             1968
  
  /* Modbus_Application_Protocol_V1_1b.pdf (chapter 6 section 3 page 15)
   * Quantity of Registers to read (2 bytes): 1 to 125 (0x7D)
   * (chapter 6 section 12 page 31)
   * Quantity of Registers to write (2 bytes) 1 to 123 (0x7B)
   * (chapter 6 section 17 page 38)
   * Quantity of Registers to write in R/W registers (2 bytes) 1 to 121 (0x79)
   */
  #define MODBUS_MAX_READ_REGISTERS          125
  #define MODBUS_MAX_WRITE_REGISTERS         123
  #define MODBUS_MAX_WR_WRITE_REGISTERS      121
  #define MODBUS_MAX_WR_READ_REGISTERS       125
  
  /* The size of the MODBUS PDU is limited by the size constraint inherited from
   * the first MODBUS implementation on Serial Line network (max. RS485 ADU = 256
   * bytes). Therefore, MODBUS PDU for serial line communication = 256 - Server
   * address (1 byte) - CRC (2 bytes) = 253 bytes.
   */
  #define MODBUS_MAX_PDU_LENGTH              253
  
  /* Consequently:
   * - RTU MODBUS ADU = 253 bytes + Server address (1 byte) + CRC (2 bytes) = 256
   *   bytes.
   * - TCP MODBUS ADU = 253 bytes + MBAP (7 bytes) = 260 bytes.
   * so the maximum of both backend in 260 bytes. This size can used to allocate
   * an array of bytes to store responses and it will be compatible with the two
   * backends.
   */
  #define MODBUS_MAX_ADU_LENGTH              260
  
  /* Random number to avoid errno conflicts */
  #define MODBUS_ENOBASE 112345678
  
  /* Protocol exceptions */
  enum {
      MODBUS_EXCEPTION_ILLEGAL_FUNCTION = 0x01,
      MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS,
      MODBUS_EXCEPTION_ILLEGAL_DATA_VALUE,
      MODBUS_EXCEPTION_SLAVE_OR_SERVER_FAILURE,
      MODBUS_EXCEPTION_ACKNOWLEDGE,
      MODBUS_EXCEPTION_SLAVE_OR_SERVER_BUSY,
      MODBUS_EXCEPTION_NEGATIVE_ACKNOWLEDGE,
      MODBUS_EXCEPTION_MEMORY_PARITY,
      MODBUS_EXCEPTION_NOT_DEFINED,
      MODBUS_EXCEPTION_GATEWAY_PATH,
      MODBUS_EXCEPTION_GATEWAY_TARGET,
      MODBUS_EXCEPTION_MAX
  };
  
  #define EMBXILFUN  (MODBUS_ENOBASE + MODBUS_EXCEPTION_ILLEGAL_FUNCTION)
  #define EMBXILADD  (MODBUS_ENOBASE + MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS)
  #define EMBXILVAL  (MODBUS_ENOBASE + MODBUS_EXCEPTION_ILLEGAL_DATA_VALUE)
  #define EMBXSFAIL  (MODBUS_ENOBASE + MODBUS_EXCEPTION_SLAVE_OR_SERVER_FAILURE)
  #define EMBXACK    (MODBUS_ENOBASE + MODBUS_EXCEPTION_ACKNOWLEDGE)
  #define EMBXSBUSY  (MODBUS_ENOBASE + MODBUS_EXCEPTION_SLAVE_OR_SERVER_BUSY)
  #define EMBXNACK   (MODBUS_ENOBASE + MODBUS_EXCEPTION_NEGATIVE_ACKNOWLEDGE)
  #define EMBXMEMPAR (MODBUS_ENOBASE + MODBUS_EXCEPTION_MEMORY_PARITY)
  #define EMBXGPATH  (MODBUS_ENOBASE + MODBUS_EXCEPTION_GATEWAY_PATH)
  #define EMBXGTAR   (MODBUS_ENOBASE + MODBUS_EXCEPTION_GATEWAY_TARGET)
  
  /* Native libmodbus error codes */
  #define EMBBADCRC  (EMBXGTAR + 1)
  #define EMBBADDATA (EMBXGTAR + 2)
  #define EMBBADEXC  (EMBXGTAR + 3)
  #define EMBUNKEXC  (EMBXGTAR + 4)
  #define EMBMDATA   (EMBXGTAR + 5)
  #define EMBBADSLAVE (EMBXGTAR + 6)
  
  extern const unsigned int libmodbus_version_major;
  extern const unsigned int libmodbus_version_minor;
  extern const unsigned int libmodbus_version_micro;
  
  typedef struct _modbus modbus_t;
  
  typedef struct {
      int nb_bits;
      int start_bits;
      int nb_input_bits;
      int start_input_bits;
      int nb_input_registers;
      int start_input_registers;
      int nb_registers;
      int start_registers;
      uint8_t *tab_bits;
      uint8_t *tab_input_bits;
      uint16_t *tab_input_registers;
      uint16_t *tab_registers;
  } modbus_mapping_t;
  
  typedef enum
  {
      MODBUS_ERROR_RECOVERY_NONE          = 0,
      MODBUS_ERROR_RECOVERY_LINK          = (1<<1),
      MODBUS_ERROR_RECOVERY_PROTOCOL      = (1<<2)
  } modbus_error_recovery_mode;
  
  MODBUS_API int modbus_set_slave(modbus_t* ctx, int slave);
  MODBUS_API int modbus_get_slave(modbus_t* ctx);
  MODBUS_API int modbus_set_error_recovery(modbus_t *ctx, modbus_error_recovery_mode error_recovery);
  MODBUS_API int modbus_set_socket(modbus_t *ctx, int s);
  MODBUS_API int modbus_get_socket(modbus_t *ctx);
  
  MODBUS_API int modbus_get_response_timeout(modbus_t *ctx, uint32_t *to_sec, uint32_t *to_usec);
  MODBUS_API int modbus_set_response_timeout(modbus_t *ctx, uint32_t to_sec, uint32_t to_usec);
  
  MODBUS_API int modbus_get_byte_timeout(modbus_t *ctx, uint32_t *to_sec, uint32_t *to_usec);
  MODBUS_API int modbus_set_byte_timeout(modbus_t *ctx, uint32_t to_sec, uint32_t to_usec);
  
  MODBUS_API int modbus_get_indication_timeout(modbus_t *ctx, uint32_t *to_sec, uint32_t *to_usec);
  MODBUS_API int modbus_set_indication_timeout(modbus_t *ctx, uint32_t to_sec, uint32_t to_usec);
  
  MODBUS_API int modbus_get_header_length(modbus_t *ctx);
  
  MODBUS_API int modbus_connect(modbus_t *ctx);
  MODBUS_API void modbus_close(modbus_t *ctx);
  
  MODBUS_API void modbus_free(modbus_t *ctx);
  
  MODBUS_API int modbus_flush(modbus_t *ctx);
  MODBUS_API int modbus_set_debug(modbus_t *ctx, int flag);
  
  MODBUS_API const char *modbus_strerror(int errnum);
  
  MODBUS_API int modbus_read_bits(modbus_t *ctx, int addr, int nb, uint8_t *dest);
  MODBUS_API int modbus_read_input_bits(modbus_t *ctx, int addr, int nb, uint8_t *dest);
  MODBUS_API int modbus_read_registers(modbus_t *ctx, int addr, int nb, uint16_t *dest);
  MODBUS_API int modbus_read_input_registers(modbus_t *ctx, int addr, int nb, uint16_t *dest);
  MODBUS_API int modbus_write_bit(modbus_t *ctx, int coil_addr, int status);
  MODBUS_API int modbus_write_register(modbus_t *ctx, int reg_addr, int value);
  MODBUS_API int modbus_write_bits(modbus_t *ctx, int addr, int nb, const uint8_t *data);
  MODBUS_API int modbus_write_registers(modbus_t *ctx, int addr, int nb, const uint16_t *data);
  MODBUS_API int modbus_mask_write_register(modbus_t *ctx, int addr, uint16_t and_mask, uint16_t or_mask);
  MODBUS_API int modbus_write_and_read_registers(modbus_t *ctx, int write_addr, int write_nb,
                                                 const uint16_t *src, int read_addr, int read_nb,
                                                 uint16_t *dest);
  MODBUS_API int modbus_report_slave_id(modbus_t *ctx, int max_dest, uint8_t *dest);
  
  MODBUS_API modbus_mapping_t* modbus_mapping_new_start_address(
      unsigned int start_bits, unsigned int nb_bits,
      unsigned int start_input_bits, unsigned int nb_input_bits,
      unsigned int start_registers, unsigned int nb_registers,
      unsigned int start_input_registers, unsigned int nb_input_registers);
  
  MODBUS_API modbus_mapping_t* modbus_mapping_new(int nb_bits, int nb_input_bits,
                                                  int nb_registers, int nb_input_registers);
  MODBUS_API void modbus_mapping_free(modbus_mapping_t *mb_mapping);
  
  MODBUS_API int modbus_send_raw_request(modbus_t *ctx, uint8_t *raw_req, int raw_req_length);
  
  MODBUS_API int modbus_receive(modbus_t *ctx, uint8_t *req);
  
  MODBUS_API int modbus_receive_confirmation(modbus_t *ctx, uint8_t *rsp);
  
  MODBUS_API int modbus_reply(modbus_t *ctx, const uint8_t *req,
                              int req_length, modbus_mapping_t *mb_mapping);
  MODBUS_API int modbus_reply_exception(modbus_t *ctx, const uint8_t *req,
                                        unsigned int exception_code);
  
  /**
   * UTILS FUNCTIONS
   **/
  
  #define MODBUS_GET_HIGH_BYTE(data) (((data) >> 8) & 0xFF)
  #define MODBUS_GET_LOW_BYTE(data) ((data) & 0xFF)
  #define MODBUS_GET_INT64_FROM_INT16(tab_int16, index) \
      (((int64_t)tab_int16[(index)    ] << 48) + \
       ((int64_t)tab_int16[(index) + 1] << 32) + \
       ((int64_t)tab_int16[(index) + 2] << 16) + \
        (int64_t)tab_int16[(index) + 3])
  #define MODBUS_GET_INT32_FROM_INT16(tab_int16, index) ((tab_int16[(index)] << 16) + tab_int16[(index) + 1])
  #define MODBUS_GET_INT16_FROM_INT8(tab_int8, index) ((tab_int8[(index)] << 8) + tab_int8[(index) + 1])
  #define MODBUS_SET_INT16_TO_INT8(tab_int8, index, value) \
      do { \
          tab_int8[(index)] = (value) >> 8;  \
          tab_int8[(index) + 1] = (value) & 0xFF; \
      } while (0)
  #define MODBUS_SET_INT32_TO_INT16(tab_int16, index, value) \
      do { \
          tab_int16[(index)    ] = (value) >> 16; \
          tab_int16[(index) + 1] = (value); \
      } while (0)
  #define MODBUS_SET_INT64_TO_INT16(tab_int16, index, value) \
      do { \
          tab_int16[(index)    ] = (value) >> 48; \
          tab_int16[(index) + 1] = (value) >> 32; \
          tab_int16[(index) + 2] = (value) >> 16; \
          tab_int16[(index) + 3] = (value); \
      } while (0)
  
  MODBUS_API void modbus_set_bits_from_byte(uint8_t *dest, int idx, const uint8_t value);
  MODBUS_API void modbus_set_bits_from_bytes(uint8_t *dest, int idx, unsigned int nb_bits,
                                         const uint8_t *tab_byte);
  MODBUS_API uint8_t modbus_get_byte_from_bits(const uint8_t *src, int idx, unsigned int nb_bits);
  MODBUS_API float modbus_get_float(const uint16_t *src);
  MODBUS_API float modbus_get_float_abcd(const uint16_t *src);
  MODBUS_API float modbus_get_float_dcba(const uint16_t *src);
  MODBUS_API float modbus_get_float_badc(const uint16_t *src);
  MODBUS_API float modbus_get_float_cdab(const uint16_t *src);
  
  MODBUS_API void modbus_set_float(float f, uint16_t *dest);
  MODBUS_API void modbus_set_float_abcd(float f, uint16_t *dest);
  MODBUS_API void modbus_set_float_dcba(float f, uint16_t *dest);
  MODBUS_API void modbus_set_float_badc(float f, uint16_t *dest);
  MODBUS_API void modbus_set_float_cdab(float f, uint16_t *dest);
  
  #include "modbus-tcp.h"
  #include "modbus-rtu.h"
  
  MODBUS_END_DECLS
  
  #endif  /* MODBUS_H */
  