CMakeLists.txt

@@ -1,16 +1,13 @@
 cmake_minimum_required(VERSION 3.6.0)
 project(hoymilesClient VERSION 0.1.0 LANGUAGES C CXX)
 
-add_subdirectory(src/libmodbus)
-
 # set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pthread")
 
-include_directories(inc inc/libmodbus inc/hoymiles inc/hoymiles/portParameters inc/hoymiles/sunspecParameters src/libmodbus/inc)
+include_directories(inc inc/libmodbus inc/hoymiles inc/hoymiles/portParameters inc/hoymiles/sunspecParameters)
 
 file(GLOB SOURCES src/*.cpp src/libmodbus/*.c src/hoymiles/*.cpp src/hoymiles/portParameters/*.cpp src/hoymiles/sunspecParameters/*.cpp)
 
 add_executable(hoymilesClient_exec ${SOURCES})
-target_link_libraries(hoymilesClient_exec libmodbus)
 
 # configure_file(${CMAKE_CURRENT_SOURCE_DIR}/config.h.in ${CMAKE_CURRENT_SOURCE_DIR}/inc/libmodbus/config.h)
 

inc/hoymiles/dtu.h

@@ -10,21 +10,23 @@
 
 class Dtu {
       private:
-	modbus_t *modbus;
+	std::shared_ptr<class modbus> modbus;
 
 	std::vector<Microinverter> microinverters;
 
-	bool connected;
-
 	void populateMicroinverters();
 
       public:
-	Dtu(const char *address, int id, bool rtu, bool tcp);
+	Dtu(const char *ip_address, int port);
 
 	std::pair<Microinverter *, bool> getMicroinverterBySerialNumber(long long serialNumber);
 
 	bool isConnected();
 
+	bool modbusError();
+
+	std::string modbusErrorMessage();
+
 	void updateMicroinverters(std::vector<std::string> &parametersToGet, bool allParameters, std::vector<long long> &microinvertersToGet);
 
 	void printMicroinverters(std::vector<std::string> &parametersToGet, bool allParameters, std::vector<long long> &microinvertersToGet, bool shortNames, bool printTodayProduction, bool printTotalProduction);
@@ -33,8 +35,6 @@ class Dtu {
 
 	bool empty();
 
-	void listOfMicroinverters();
-
 	~Dtu();
 };
 

inc/hoymiles/microinverter.h

@@ -11,7 +11,7 @@
 
 class Microinverter {
       private:
-	modbus_t *modbus;
+	std::shared_ptr<class modbus> modbus;
 
 	Sunspec sunspec;
 
@@ -20,7 +20,7 @@ class Microinverter {
 	int statusStartAddress;
 
       public:
-	Microinverter(modbus_t *modbus, int startAddress, long long serialNumber);
+	Microinverter(std::shared_ptr<class modbus> modbus, int startAddress, long long serialNumber);
 
 	long long serialNumber;
 

inc/hoymiles/port.h

@@ -41,9 +41,9 @@ class Port {
 
 	void printParameters(std::vector<std::string> &parametersToGet, bool allParameters, bool shortNames);
 
-	void turnOff(modbus_t *modbus);
+	void turnOff(class modbus &modbus);
 
-	bool isOff(modbus_t *modbus);
+	bool isOff(class modbus &modbus);
 };
 
 #endif

inc/hoymiles/portParameters/portParametersGeneric.h

@@ -42,7 +42,7 @@ class PortParameter {
 
 	std::pair<PortParameterValue, PortParameterValueType> getValue();
 
-	PortParameter& writeValue(uint16_t value, modbus_t *modbus, int portStartAddress);
+	PortParameter& writeValue(uint16_t value, class modbus& modbus, int portStartAddress);
 
 	virtual std::string getOutputValue();
 

inc/hoymiles/sunspec.h

@@ -11,7 +11,7 @@
 
 class Sunspec {
       protected:
-    modbus_t *modbus;
+    std::shared_ptr<class modbus> modbus;
 
     std::vector<std::shared_ptr<SunspecParameter>> parameters;
 
@@ -29,7 +29,7 @@ class Sunspec {
     void populateParameters();
 
       public:
-    Sunspec(int address, modbus_t *modbus);
+    Sunspec(int address, std::shared_ptr<class modbus> modbus);
 
     uint16_t getAddress();
 };

inc/modbus.h

@@ -0,0 +1,717 @@
+/* modbus.h
+ *
+ * Copyright (C) 20017-2021 Fanzhe Lyu <lvfanzhe@hotmail.com>, all rights reserved.
+ *
+ * modbuspp 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.
+ *
+ * This program 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 this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef MODBUSPP_MODBUS_H
+#define MODBUSPP_MODBUS_H
+
+#include <cstring>
+#include <stdint.h>
+#include <string>
+
+#ifdef ENABLE_MODBUSPP_LOGGING
+#include <cstdio>
+#define LOG(fmt, ...) printf("[ modbuspp ]" fmt, ##__VA_ARGS__)
+#else
+#define LOG(...) (void)0
+#endif
+
+#ifdef _WIN32
+// WINDOWS socket
+#define _WINSOCK_DEPRECATED_NO_WARNINGS
+
+#include <winsock2.h>
+#pragma comment(lib, "Ws2_32.lib")
+using X_SOCKET = SOCKET;
+// using ssize_t = int;
+
+#define X_ISVALIDSOCKET(s) ((s) != INVALID_SOCKET)
+#define X_CLOSE_SOCKET(s) closesocket(s)
+#define X_ISCONNECTSUCCEED(s) ((s) != SOCKET_ERROR)
+
+#else
+// Berkeley socket
+#include <unistd.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+using X_SOCKET = int;
+
+#define X_ISVALIDSOCKET(s) ((s) >= 0)
+#define X_CLOSE_SOCKET(s) close(s)
+#define X_ISCONNECTSUCCEED(s) ((s) >= 0)
+#endif
+
+using SOCKADDR = struct sockaddr;
+using SOCKADDR_IN = struct sockaddr_in;
+
+#define MAX_MSG_LENGTH 260
+
+///Function Code
+#define READ_COILS 0x01
+#define READ_INPUT_BITS 0x02
+#define READ_REGS 0x03
+#define READ_INPUT_REGS 0x04
+#define WRITE_COIL 0x05
+#define WRITE_REG 0x06
+#define WRITE_COILS 0x0F
+#define WRITE_REGS 0x10
+
+///Exception Codes
+
+#define EX_ILLEGAL_FUNCTION 0x01 // Function Code not Supported
+#define EX_ILLEGAL_ADDRESS 0x02  // Output Address not exists
+#define EX_ILLEGAL_VALUE 0x03    // Output Value not in Range
+#define EX_SERVER_FAILURE 0x04   // Slave Deive Fails to process request
+#define EX_ACKNOWLEDGE 0x05      // Service Need Long Time to Execute
+#define EX_SERVER_BUSY 0x06      // Server Was Unable to Accept MB Request PDU
+#define EX_NEGATIVE_ACK 0x07
+#define EX_MEM_PARITY_PROB 0x08
+#define EX_GATEWAY_PROBLEMP 0x0A // Gateway Path not Available
+#define EX_GATEWAY_PROBLEMF 0x0B // Target Device Failed to Response
+#define EX_BAD_DATA 0XFF         // Bad Data lenght or Address
+
+#define BAD_CON -1
+
+/// Modbus Operator Class
+/**
+ * Modbus Operator Class
+ * Providing networking support and mobus operation support.
+ */
+class modbus
+{
+
+public:
+    bool err{};
+    int err_no{};
+    std::string error_msg;
+
+    modbus(std::string host, uint16_t port);
+    ~modbus();
+
+    bool modbus_connect();
+    void modbus_close() const;
+
+    bool is_connected() const { return _connected; }
+
+    void modbus_set_slave_id(int id);
+
+    int modbus_read_coils(uint16_t address, uint16_t amount, bool *buffer);
+    int modbus_read_input_bits(uint16_t address, uint16_t amount, bool *buffer);
+    int modbus_read_holding_registers(uint16_t address, uint16_t amount, uint16_t *buffer);
+    int modbus_read_input_registers(uint16_t address, uint16_t amount, uint16_t *buffer);
+
+    int modbus_write_coil(uint16_t address, const bool &to_write);
+    int modbus_write_register(uint16_t address, const uint16_t &value);
+    int modbus_write_coils(uint16_t address, uint16_t amount, const bool *value);
+    int modbus_write_registers(uint16_t address, uint16_t amount, const uint16_t *value);
+
+private:
+    bool _connected{};
+    uint16_t PORT{};
+    uint32_t _msg_id{};
+    int _slaveid{};
+    std::string HOST;
+
+    X_SOCKET _socket{};
+    SOCKADDR_IN _server{};
+
+#ifdef _WIN32
+    WSADATA wsadata;
+#endif
+
+    void modbus_build_request(uint8_t *to_send, uint16_t address, int func) const;
+
+    int modbus_read(uint16_t address, uint16_t amount, int func);
+    int modbus_write(uint16_t address, uint16_t amount, int func, const uint16_t *value);
+
+    ssize_t modbus_send(uint8_t *to_send, size_t length);
+    ssize_t modbus_receive(uint8_t *buffer) const;
+
+    void modbuserror_handle(const uint8_t *msg, int func);
+
+    void set_bad_con();
+    void set_bad_input();
+};
+
+/**
+ * Main Constructor of Modbus Connector Object
+ * @param host IP Address of Host
+ * @param port Port for the TCP Connection
+ * @return     A Modbus Connector Object
+ */
+inline modbus::modbus(std::string host, uint16_t port = 502)
+{
+    HOST = host;
+    PORT = port;
+    _slaveid = 1;
+    _msg_id = 1;
+    _connected = false;
+    err = false;
+    err_no = 0;
+    error_msg = "";
+}
+
+/**
+ * Destructor of Modbus Connector Object
+ */
+inline modbus::~modbus(void) = default;
+
+/**
+ * Modbus Slave ID Setter
+ * @param id  ID of the Modbus Server Slave
+ */
+inline void modbus::modbus_set_slave_id(int id)
+{
+    _slaveid = id;
+}
+
+/**
+ * Build up a Modbus/TCP Connection
+ * @return   If A Connection Is Successfully Built
+ */
+inline bool modbus::modbus_connect()
+{
+    if (HOST.empty() || PORT == 0)
+    {
+        LOG("Missing Host and Port");
+        return false;
+    }
+    else
+    {
+        LOG("Found Proper Host %s and Port %d", HOST.c_str(), PORT);
+    }
+
+#ifdef _WIN32
+    if (WSAStartup(0x0202, &wsadata))
+    {
+        return false;
+    }
+#endif
+
+    _socket = socket(AF_INET, SOCK_STREAM, 0);
+    if (!X_ISVALIDSOCKET(_socket))
+    {
+        LOG("Error Opening Socket");
+#ifdef _WIN32
+        WSACleanup();
+#endif
+        return false;
+    }
+    else
+    {
+        LOG("Socket Opened Successfully");
+    }
+
+#ifdef WIN32
+    const DWORD timeout = 20000;
+#else
+    struct timeval timeout
+    {
+    };
+    timeout.tv_sec = 20; // after 20 seconds connect() will timeout
+    timeout.tv_usec = 0;
+#endif
+
+    setsockopt(_socket, SOL_SOCKET, SO_SNDTIMEO, (const char *)&timeout, sizeof(timeout));
+    setsockopt(_socket, SOL_SOCKET, SO_RCVTIMEO, (const char *)&timeout, sizeof(timeout));
+    _server.sin_family = AF_INET;
+    _server.sin_addr.s_addr = inet_addr(HOST.c_str());
+    _server.sin_port = htons(PORT);
+
+    if (!X_ISCONNECTSUCCEED(connect(_socket, (SOCKADDR *)&_server, sizeof(_server))))
+    {
+        LOG("Connection Error");
+#ifdef _WIN32
+        WSACleanup();
+#endif
+        return false;
+    }
+
+    LOG("Connected");
+    _connected = true;
+    return true;
+}
+
+/**
+ * Close the Modbus/TCP Connection
+ */
+inline void modbus::modbus_close() const
+{
+    X_CLOSE_SOCKET(_socket);
+#ifdef _WIN32
+    WSACleanup();
+#endif
+    LOG("Socket Closed");
+}
+
+/**
+ * Modbus Request Builder
+ * @param to_send   Message Buffer to Be Sent
+ * @param address   Reference Address
+ * @param func      Modbus Functional Code
+ */
+inline void modbus::modbus_build_request(uint8_t *to_send, uint16_t address, int func) const
+{
+    to_send[0] = (uint8_t)(_msg_id >> 8u);
+    to_send[1] = (uint8_t)(_msg_id & 0x00FFu);
+    to_send[2] = 0;
+    to_send[3] = 0;
+    to_send[4] = 0;
+    to_send[6] = (uint8_t)_slaveid;
+    to_send[7] = (uint8_t)func;
+    to_send[8] = (uint8_t)(address >> 8u);
+    to_send[9] = (uint8_t)(address & 0x00FFu);
+}
+
+/**
+ * Write Request Builder and Sender
+ * @param address   Reference Address
+ * @param amount    Amount of data to be Written
+ * @param func      Modbus Functional Code
+ * @param value     Data to Be Written
+ */
+inline int modbus::modbus_write(uint16_t address, uint16_t amount, int func, const uint16_t *value)
+{
+    int status = 0;
+    uint8_t *to_send;
+    if (func == WRITE_COIL || func == WRITE_REG)
+    {
+        to_send = new uint8_t[12];
+        modbus_build_request(to_send, address, func);
+        to_send[5] = 6;
+        to_send[10] = (uint8_t)(value[0] >> 8u);
+        to_send[11] = (uint8_t)(value[0] & 0x00FFu);
+        status = modbus_send(to_send, 12);
+    }
+    else if (func == WRITE_REGS)
+    {
+        to_send = new uint8_t[13 + 2 * amount];
+        modbus_build_request(to_send, address, func);
+        to_send[5] = (uint8_t)(7 + 2 * amount);
+        to_send[10] = (uint8_t)(amount >> 8u);
+        to_send[11] = (uint8_t)(amount & 0x00FFu);
+        to_send[12] = (uint8_t)(2 * amount);
+        for (int i = 0; i < amount; i++)
+        {
+            to_send[13 + 2 * i] = (uint8_t)(value[i] >> 8u);
+            to_send[14 + 2 * i] = (uint8_t)(value[i] & 0x00FFu);
+        }
+        status = modbus_send(to_send, 13 + 2 * amount);
+    }
+    else if (func == WRITE_COILS)
+    {
+        to_send = new uint8_t[14 + (amount - 1) / 8];
+        modbus_build_request(to_send, address, func);
+        to_send[5] = (uint8_t)(7 + (amount + 7) / 8);
+        to_send[10] = (uint8_t)(amount >> 8u);
+        to_send[11] = (uint8_t)(amount & 0x00FFu);
+        to_send[12] = (uint8_t)((amount + 7) / 8);
+        for (int i = 0; i < (amount + 7) / 8; i++)
+            to_send[13 + i] = 0; // init needed before summing!
+        for (int i = 0; i < amount; i++)
+        {
+            to_send[13 + i / 8] += (uint8_t)(value[i] << (i % 8u));
+        }
+        status = modbus_send(to_send, 14 + (amount - 1) / 8);
+    }
+    delete[] to_send;
+    return status;
+}
+
+/**
+ * Read Request Builder and Sender
+ * @param address   Reference Address
+ * @param amount    Amount of Data to Read
+ * @param func      Modbus Functional Code
+ */
+inline int modbus::modbus_read(uint16_t address, uint16_t amount, int func)
+{
+    uint8_t to_send[12];
+    modbus_build_request(to_send, address, func);
+    to_send[5] = 6;
+    to_send[10] = (uint8_t)(amount >> 8u);
+    to_send[11] = (uint8_t)(amount & 0x00FFu);
+    return modbus_send(to_send, 12);
+}
+
+/**
+ * Read Holding Registers
+ * MODBUS FUNCTION 0x03
+ * @param address    Reference Address
+ * @param amount     Amount of Registers to Read
+ * @param buffer     Buffer to Store Data Read from Registers
+ */
+inline int modbus::modbus_read_holding_registers(uint16_t address, uint16_t amount, uint16_t *buffer)
+{
+    if (_connected)
+    {
+        modbus_read(address, amount, READ_REGS);
+        uint8_t to_rec[MAX_MSG_LENGTH];
+        ssize_t k = modbus_receive(to_rec);
+        if (k == -1)
+        {
+            set_bad_con();
+            return BAD_CON;
+        }
+        modbuserror_handle(to_rec, READ_REGS);
+        if (err)
+            return err_no;
+        for (auto i = 0; i < amount; i++)
+        {
+            buffer[i] = ((uint16_t)to_rec[9u + 2u * i]) << 8u;
+            buffer[i] += (uint16_t)to_rec[10u + 2u * i];
+        }
+        return 0;
+    }
+    else
+    {
+        set_bad_con();
+        return BAD_CON;
+    }
+}
+
+/**
+ * Read Input Registers
+ * MODBUS FUNCTION 0x04
+ * @param address     Reference Address
+ * @param amount      Amount of Registers to Read
+ * @param buffer      Buffer to Store Data Read from Registers
+ */
+inline int modbus::modbus_read_input_registers(uint16_t address, uint16_t amount, uint16_t *buffer)
+{
+    if (_connected)
+    {
+        modbus_read(address, amount, READ_INPUT_REGS);
+        uint8_t to_rec[MAX_MSG_LENGTH];
+        ssize_t k = modbus_receive(to_rec);
+        if (k == -1)
+        {
+            set_bad_con();
+            return BAD_CON;
+        }
+        modbuserror_handle(to_rec, READ_INPUT_REGS);
+        if (err)
+            return err_no;
+        for (auto i = 0; i < amount; i++)
+        {
+            buffer[i] = ((uint16_t)to_rec[9u + 2u * i]) << 8u;
+            buffer[i] += (uint16_t)to_rec[10u + 2u * i];
+        }
+        return 0;
+    }
+    else
+    {
+        set_bad_con();
+        return BAD_CON;
+    }
+}
+
+/**
+ * Read Coils
+ * MODBUS FUNCTION 0x01
+ * @param address     Reference Address
+ * @param amount      Amount of Coils to Read
+ * @param buffer      Buffer to Store Data Read from Coils
+ */
+inline int modbus::modbus_read_coils(uint16_t address, uint16_t amount, bool *buffer)
+{
+    if (_connected)
+    {
+        if (amount > 2040)
+        {
+            set_bad_input();
+            return EX_BAD_DATA;
+        }
+        modbus_read(address, amount, READ_COILS);
+        uint8_t to_rec[MAX_MSG_LENGTH];
+        ssize_t k = modbus_receive(to_rec);
+        if (k == -1)
+        {
+            set_bad_con();
+            return BAD_CON;
+        }
+        modbuserror_handle(to_rec, READ_COILS);
+        if (err)
+            return err_no;
+        for (auto i = 0; i < amount; i++)
+        {
+            buffer[i] = (bool)((to_rec[9u + i / 8u] >> (i % 8u)) & 1u);
+        }
+        return 0;
+    }
+    else
+    {
+        set_bad_con();
+        return BAD_CON;
+    }
+}
+
+/**
+ * Read Input Bits(Discrete Data)
+ * MODBUS FUNCITON 0x02
+ * @param address   Reference Address
+ * @param amount    Amount of Bits to Read
+ * @param buffer    Buffer to store Data Read from Input Bits
+ */
+inline int modbus::modbus_read_input_bits(uint16_t address, uint16_t amount, bool *buffer)
+{
+    if (_connected)
+    {
+        if (amount > 2040)
+        {
+            set_bad_input();
+            return EX_BAD_DATA;
+        }
+        modbus_read(address, amount, READ_INPUT_BITS);
+        uint8_t to_rec[MAX_MSG_LENGTH];
+        ssize_t k = modbus_receive(to_rec);
+        if (k == -1)
+        {
+            set_bad_con();
+            return BAD_CON;
+        }
+        if (err)
+            return err_no;
+        for (auto i = 0; i < amount; i++)
+        {
+            buffer[i] = (bool)((to_rec[9u + i / 8u] >> (i % 8u)) & 1u);
+        }
+        modbuserror_handle(to_rec, READ_INPUT_BITS);
+        return 0;
+    }
+    else
+    {
+        return BAD_CON;
+    }
+}
+
+/**
+ * Write Single Coils
+ * MODBUS FUNCTION 0x05
+ * @param address    Reference Address
+ * @param to_write   Value to be Written to Coil
+ */
+inline int modbus::modbus_write_coil(uint16_t address, const bool &to_write)
+{
+    if (_connected)
+    {
+        int value = to_write * 0xFF00;
+        modbus_write(address, 1, WRITE_COIL, (uint16_t *)&value);
+        uint8_t to_rec[MAX_MSG_LENGTH];
+        ssize_t k = modbus_receive(to_rec);
+        if (k == -1)
+        {
+            set_bad_con();
+            return BAD_CON;
+        }
+        modbuserror_handle(to_rec, WRITE_COIL);
+        if (err)
+            return err_no;
+        return 0;
+    }
+    else
+    {
+        set_bad_con();
+        return BAD_CON;
+    }
+}
+
+/**
+ * Write Single Register
+ * FUCTION 0x06
+ * @param address   Reference Address
+ * @param value     Value to Be Written to Register
+ */
+inline int modbus::modbus_write_register(uint16_t address, const uint16_t &value)
+{
+    if (_connected)
+    {
+        modbus_write(address, 1, WRITE_REG, &value);
+        uint8_t to_rec[MAX_MSG_LENGTH];
+        ssize_t k = modbus_receive(to_rec);
+        if (k == -1)
+        {
+            set_bad_con();
+            return BAD_CON;
+        }
+        modbuserror_handle(to_rec, WRITE_COIL);
+        if (err)
+            return err_no;
+        return 0;
+    }
+    else
+    {
+        set_bad_con();
+        return BAD_CON;
+    }
+}
+
+/**
+ * Write Multiple Coils
+ * MODBUS FUNCTION 0x0F
+ * @param address  Reference Address
+ * @param amount   Amount of Coils to Write
+ * @param value    Values to Be Written to Coils
+ */
+inline int modbus::modbus_write_coils(uint16_t address, uint16_t amount, const bool *value)
+{
+    if (_connected)
+    {
+        uint16_t *temp = new uint16_t[amount];
+        for (int i = 0; i < amount; i++)
+        {
+            temp[i] = (uint16_t)value[i];
+        }
+        modbus_write(address, amount, WRITE_COILS, temp);
+        delete[] temp;
+        uint8_t to_rec[MAX_MSG_LENGTH];
+        ssize_t k = modbus_receive(to_rec);
+        if (k == -1)
+        {
+            set_bad_con();
+            return BAD_CON;
+        }
+        modbuserror_handle(to_rec, WRITE_COILS);
+        if (err)
+            return err_no;
+        return 0;
+    }
+    else
+    {
+        set_bad_con();
+        return BAD_CON;
+    }
+}
+
+/**
+ * Write Multiple Registers
+ * MODBUS FUNCION 0x10
+ * @param address Reference Address
+ * @param amount  Amount of Value to Write
+ * @param value   Values to Be Written to the Registers
+ */
+inline int modbus::modbus_write_registers(uint16_t address, uint16_t amount, const uint16_t *value)
+{
+    if (_connected)
+    {
+        modbus_write(address, amount, WRITE_REGS, value);
+        uint8_t to_rec[MAX_MSG_LENGTH];
+        ssize_t k = modbus_receive(to_rec);
+        if (k == -1)
+        {
+            set_bad_con();
+            return BAD_CON;
+        }
+        modbuserror_handle(to_rec, WRITE_REGS);
+        if (err)
+            return err_no;
+        return 0;
+    }
+    else
+    {
+        set_bad_con();
+        return BAD_CON;
+    }
+}
+
+/**
+ * Data Sender
+ * @param to_send Request to Be Sent to Server
+ * @param length  Length of the Request
+ * @return        Size of the request
+ */
+inline ssize_t modbus::modbus_send(uint8_t *to_send, size_t length)
+{
+    _msg_id++;
+    return send(_socket, (const char *)to_send, (size_t)length, 0);
+}
+
+/**
+ * Data Receiver
+ * @param buffer Buffer to Store the Data Retrieved
+ * @return       Size of Incoming Data
+ */
+inline ssize_t modbus::modbus_receive(uint8_t *buffer) const
+{
+    return recv(_socket, (char *)buffer, MAX_MSG_LENGTH, 0);
+}
+
+inline void modbus::set_bad_con()
+{
+    err = true;
+    error_msg = "BAD CONNECTION";
+}
+
+inline void modbus::set_bad_input()
+{
+    err = true;
+    error_msg = "BAD FUNCTION INPUT";
+}
+
+/**
+ * Error Code Handler
+ * @param msg   Message Received from the Server
+ * @param func  Modbus Functional Code
+ */
+inline void modbus::modbuserror_handle(const uint8_t *msg, int func)
+{
+    err = false;
+    error_msg = "NO ERR";
+    if (msg[7] == func + 0x80)
+    {
+        err = true;
+        switch (msg[8])
+        {
+        case EX_ILLEGAL_FUNCTION:
+            error_msg = "1 Illegal Function";
+            break;
+        case EX_ILLEGAL_ADDRESS:
+            error_msg = "2 Illegal Address";
+            break;
+        case EX_ILLEGAL_VALUE:
+            error_msg = "3 Illegal Value";
+            break;
+        case EX_SERVER_FAILURE:
+            error_msg = "4 Server Failure";
+            break;
+        case EX_ACKNOWLEDGE:
+            error_msg = "5 Acknowledge";
+            break;
+        case EX_SERVER_BUSY:
+            error_msg = "6 Server Busy";
+            break;
+        case EX_NEGATIVE_ACK:
+            error_msg = "7 Negative Acknowledge";
+            break;
+        case EX_MEM_PARITY_PROB:
+            error_msg = "8 Memory Parity Problem";
+            break;
+        case EX_GATEWAY_PROBLEMP:
+            error_msg = "10 Gateway Path Unavailable";
+            break;
+        case EX_GATEWAY_PROBLEMF:
+            error_msg = "11 Gateway Target Device Failed to Respond";
+            break;
+        default:
+            error_msg = "UNK";
+            break;
+        }
+    }
+}
+
+#endif //MODBUSPP_MODBUS_H

src/hoymiles/dtu.cpp

@@ -1,8 +1,6 @@
 #include <iostream>
 #include <string>
 #include <vector>
-#include <chrono>
-#include <thread>
 
 #include "modbus.h"
 
@@ -11,47 +9,41 @@
 
 #include "portParameters.h"
 
-Dtu::Dtu(const char *address, int id, bool rtu, bool tcp) {
+Dtu::Dtu(const char *ip_address, int port) {
-	if(tcp) {
+	class modbus modbus {
-		this->modbus = modbus_new_tcp(address, id);
+		ip_address, (uint16_t)port
-	}
+	};
-	if(rtu) {
+	this->modbus = std::make_shared<class modbus>(modbus);
-		this->modbus = modbus_new_rtu(address, 9600, 'N', 8, 1);
-		modbus_rtu_set_serial_mode(this->modbus, MODBUS_RTU_RS485);
-	}
 
-	this->connected = false;
+	if (!this->modbus.get()->modbus_connect()) {
-	if (modbus_connect(this->modbus) == -1) {
 		std::cerr << "NOT CONNECTED" << std::endl;
 	}
-	else {
+
-		this->connected = true;
+	if (this->modbus.get()->is_connected()) {
-		if(rtu) {
-			modbus_set_slave(this->modbus, id);
-		}
 		this->populateMicroinverters();
 	}
 }
 
-bool Dtu::isConnected() { return this->connected; }
+bool Dtu::isConnected() { return this->modbus.get()->is_connected(); }
 
-Dtu::~Dtu() {
+bool Dtu::modbusError() { return this->modbus.get()->err; }
-	modbus_close(this->modbus);
+
-	modbus_free(this->modbus);
+std::string Dtu::modbusErrorMessage() { return this->modbus.get()->error_msg; }
-}
+
+Dtu::~Dtu() { this->modbus.get()->modbus_close(); }
 
 void Dtu::populateMicroinverters() {
 	int portStartAddress = 0x4000;
 	uint16_t registers[19];
 
 	int registerCount;
-	registerCount = modbus_read_registers(this->modbus, portStartAddress, 19, registers);
+	registerCount = this->modbus.get()->modbus_read_holding_registers(portStartAddress, 19, registers);
 
-	if (registerCount == -1) {
+	if (registerCount != 0) {
 		return;
 	}
 
-	while (registerCount != -1) {
+	while (registerCount == 0) {
 		if(registers[0] != 12) {
 			break;
 		}
@@ -68,8 +60,7 @@ void Dtu::populateMicroinverters() {
 
 		portStartAddress += 0x0019;
 
-		std::this_thread::sleep_for(std::chrono::milliseconds(10));
+		registerCount = this->modbus.get()->modbus_read_holding_registers(portStartAddress, 19, registers);
-		registerCount = modbus_read_registers(this->modbus, portStartAddress, 19, registers);
 	}
 }
 
@@ -155,12 +146,3 @@ void Dtu::setStatusMicroinverters(uint16_t value, std::string statusName, std::v
 bool Dtu::empty() {
 	return this->microinverters.empty();
 }
-
-void Dtu::listOfMicroinverters() {
-	std::vector<Microinverter>::iterator microinvertersIterator = this->microinverters.begin();
-	std::cout << "Microinverter list:" << std::endl;
-	while(microinvertersIterator != this->microinverters.end()) {
-		std::cout << "  " << microinvertersIterator->serialNumber << std::endl;
-		microinvertersIterator++;
-	}
-}

src/hoymiles/microinverter.cpp

@@ -8,7 +8,7 @@
 #include "port.h"
 #include "sunspec.h"
 
-Microinverter::Microinverter(modbus_t *modbus, int startAddress, long long serialNumber) : sunspec(40000, modbus) {
+Microinverter::Microinverter(std::shared_ptr<class modbus> modbus, int startAddress, long long serialNumber) : sunspec(40000, modbus) {
 	this->modbus = modbus;
 	this->startAddress = startAddress;
 	this->serialNumber = serialNumber;
@@ -37,9 +37,9 @@ void Microinverter::updateParameters(std::vector<std::string> &parametersToGet,
 		uint16_t registers[registersToRead];
 
 		int registerCount;
-		registerCount = modbus_read_registers(this->modbus, this->startAddress + (portsRead * 0x0019), registersToRead, registers);
+		registerCount = this->modbus.get()->modbus_read_holding_registers(this->startAddress + (portsRead * 0x0019), registersToRead, registers);
 
-		if (registerCount == -1) {
+		if (registerCount != 0) {
 			this->age++;
 			return;
 		}
@@ -64,9 +64,9 @@ void Microinverter::updateStatusParameters() {
 		uint16_t registers[registersToRead];
 
 		int registerCount;
-		registerCount = modbus_read_registers(this->modbus, this->statusStartAddress + (portsRead * 6), registersToRead, registers);
+		registerCount = this->modbus.get()->modbus_read_holding_registers(this->statusStartAddress + (portsRead * 6), registersToRead, registers);
 
-		if (registerCount == -1) {
+		if (registerCount != 0) {
 			this->age++;
 			return;
 		}
@@ -120,7 +120,7 @@ void Microinverter::setStatus(std::vector<std::pair<int, uint16_t>> portsToSet,
 	while(portsToSetIterator != portsToSet.end()) {
 		try {
 			if(this->ports.at(portsToSetIterator->first).getStatusByName(statusName).second) {
-				this->ports.at(portsToSetIterator->first).getStatusByName(statusName).first->writeValue(portsToSetIterator->second, this->modbus, this->statusStartAddress);
+				this->ports.at(portsToSetIterator->first).getStatusByName(statusName).first->writeValue(portsToSetIterator->second, *this->modbus, this->statusStartAddress);
 			}
 		}
 		catch(const std::out_of_range& outOfRange) {
@@ -133,7 +133,7 @@ void Microinverter::setStatus(std::vector<std::pair<int, uint16_t>> portsToSet,
 void Microinverter::setStatusWholeMicroinverter(uint16_t value, std::string statusName) {
 	if(this->ports.begin() != this->ports.end()) {
 		if(this->ports.begin()->getStatusByName(statusName).second) {
-			this->ports.begin()->getStatusByName(statusName).first.get()->writeValue(value, this->modbus, this->ports.begin()->statusPortStartAddress);
+			this->ports.begin()->getStatusByName(statusName).first.get()->writeValue(value, *this->modbus, this->ports.begin()->statusPortStartAddress);
 		}
 	}
 }

src/hoymiles/port.cpp

@@ -212,9 +212,9 @@ void Port::printParameters(std::vector<std::string> &parametersToGet, bool allPa
 	}
 }
 
-void Port::turnOff(modbus_t *modbus) { this->getStatusByName("onOff").first.get()->writeValue(0, modbus, this->statusPortStartAddress); }
+void Port::turnOff(class modbus &modbus) { this->getStatusByName("onOff").first.get()->writeValue(0, modbus, this->statusPortStartAddress); }
 
-bool Port::isOff(modbus_t *modbus) {
+bool Port::isOff(class modbus &modbus) {
 	if (this->getStatusByName("onOff").first.get()->getValue().first.i == 1) {
 		return true;
 	} else {

src/hoymiles/portParameters/portParametersGeneric.cpp

@@ -28,9 +28,9 @@ std::pair<PortParameter::PortParameterValue, PortParameter::PortParameterValueTy
     return std::pair<PortParameter::PortParameterValue, PortParameter::PortParameterValueType>(this->value, this->valueType);
 }
 
-PortParameter& PortParameter::writeValue(uint16_t value, modbus_t *modbus, int portStartAddress) {
+PortParameter& PortParameter::writeValue(uint16_t value, class modbus& modbus, int portStartAddress) {
 	int writeCount;
-	writeCount = modbus_write_register(modbus, this->parameterAddressOffset + portStartAddress, value);
+	writeCount = modbus.modbus_write_register(this->parameterAddressOffset + portStartAddress, value);
 	return *this;
 }
 

src/hoymiles/sunspec.cpp

@@ -6,7 +6,7 @@
 #include "modbus.h"
 #include "sunspecParameters.h"
 
-Sunspec::Sunspec(int address, modbus_t *modbus) {
+Sunspec::Sunspec(int address, std::shared_ptr<class modbus> modbus) {
     this->modbus = modbus;
     this->sunspecAddress = address;
 
@@ -19,7 +19,7 @@ void Sunspec::setValues() {
     uint16_t registers[70];
 
     int registerCount;
-    registerCount = modbus_read_registers(this->modbus, this->sunspecAddress, 70, registers);
+    registerCount = this->modbus.get()->modbus_read_holding_registers(this->sunspecAddress, 70, registers);
 
     std::vector<std::shared_ptr<SunspecParameter>>::iterator parametersIterator = this->parameters.begin();
     while(parametersIterator != this->parameters.end()) {

src/libmodbus/CMakeLists.txt

@@ -1,7 +0,0 @@
-include_directories(inc)
-
-configure_file(${CMAKE_CURRENT_SOURCE_DIR}/config.h.in ${CMAKE_CURRENT_SOURCE_DIR}/inc/config.h)
-
-file(GLOB SOURCES src/*.c)
-
-add_library(libmodbus STATIC ${SOURCES})

src/libmodbus/config.h.in

@@ -1,291 +0,0 @@
-/* config.h.in.  Generated from configure.ac by autoheader.  */
-
-/* Define to 1 if you have the `accept4' function. */
-#undef HAVE_ACCEPT4
-
-/* Define to 1 if you have the <arpa/inet.h> header file. */
-#undef HAVE_ARPA_INET_H
-
-/* Define to 1 if you have the <byteswap.h> header file. */
-#undef HAVE_BYTESWAP_H
-
-/* Define to 1 if you have the declaration of `TIOCM_RTS', and to 0 if you
-   don't. */
-#undef HAVE_DECL_TIOCM_RTS
-
-/* Define to 1 if you have the declaration of `TIOCSRS485', and to 0 if you
-   don't. */
-#undef HAVE_DECL_TIOCSRS485
-
-/* Define to 1 if you have the declaration of `__CYGWIN__', and to 0 if you
-   don't. */
-#undef HAVE_DECL___CYGWIN__
-
-/* Define to 1 if you have the <dlfcn.h> header file. */
-#undef HAVE_DLFCN_H
-
-/* Define to 1 if you have the <errno.h> header file. */
-#undef HAVE_ERRNO_H
-
-/* Define to 1 if you have the <fcntl.h> header file. */
-#undef HAVE_FCNTL_H
-
-/* Define to 1 if you have the `getaddrinfo' function. */
-#undef HAVE_GETADDRINFO
-
-/* Define to 1 if you have the `gettimeofday' function. */
-#undef HAVE_GETTIMEOFDAY
-
-/* Define to 1 if you have the `inet_ntop' function. */
-#undef HAVE_INET_NTOP
-
-/* Define to 1 if you have the `inet_pton' function. */
-#undef HAVE_INET_PTON
-
-/* Define to 1 if you have the <inttypes.h> header file. */
-#undef HAVE_INTTYPES_H
-
-/* Define to 1 if you have the <limits.h> header file. */
-#undef HAVE_LIMITS_H
-
-/* Define to 1 if you have the <linux/serial.h> header file. */
-#undef HAVE_LINUX_SERIAL_H
-
-/* Define to 1 if you have the <minix/config.h> header file. */
-#undef HAVE_MINIX_CONFIG_H
-
-/* Define to 1 if you have the <netdb.h> header file. */
-#undef HAVE_NETDB_H
-
-/* Define to 1 if you have the <netinet/in.h> header file. */
-#undef HAVE_NETINET_IN_H
-
-/* Define to 1 if you have the <netinet/tcp.h> header file. */
-#undef HAVE_NETINET_TCP_H
-
-/* Define to 1 if you have the `select' function. */
-#undef HAVE_SELECT
-
-/* Define to 1 if you have the `socket' function. */
-#undef HAVE_SOCKET
-
-/* Define to 1 if you have the <stdint.h> header file. */
-#undef HAVE_STDINT_H
-
-/* Define to 1 if you have the <stdio.h> header file. */
-#undef HAVE_STDIO_H
-
-/* Define to 1 if you have the <stdlib.h> header file. */
-#undef HAVE_STDLIB_H
-
-/* Define to 1 if you have the `strerror' function. */
-#undef HAVE_STRERROR
-
-/* Define to 1 if you have the <strings.h> header file. */
-#undef HAVE_STRINGS_H
-
-/* Define to 1 if you have the <string.h> header file. */
-#undef HAVE_STRING_H
-
-/* Define to 1 if you have the `strlcpy' function. */
-#undef HAVE_STRLCPY
-
-/* Define to 1 if you have the <sys/ioctl.h> header file. */
-#undef HAVE_SYS_IOCTL_H
-
-/* Define to 1 if you have the <sys/params.h> header file. */
-#undef HAVE_SYS_PARAMS_H
-
-/* Define to 1 if you have the <sys/socket.h> header file. */
-#undef HAVE_SYS_SOCKET_H
-
-/* Define to 1 if you have the <sys/stat.h> header file. */
-#undef HAVE_SYS_STAT_H
-
-/* Define to 1 if you have the <sys/time.h> header file. */
-#undef HAVE_SYS_TIME_H
-
-/* Define to 1 if you have the <sys/types.h> header file. */
-#undef HAVE_SYS_TYPES_H
-
-/* Define to 1 if you have the <termios.h> header file. */
-#undef HAVE_TERMIOS_H
-
-/* Define to 1 if you have the <time.h> header file. */
-#undef HAVE_TIME_H
-
-/* Define to 1 if you have the <unistd.h> header file. */
-#undef HAVE_UNISTD_H
-
-/* Define to 1 if you have the <wchar.h> header file. */
-#undef HAVE_WCHAR_H
-
-/* Define to 1 if you have the <winsock2.h> header file. */
-#undef HAVE_WINSOCK2_H
-
-/* Define to the sub-directory where libtool stores uninstalled libraries. */
-#undef LT_OBJDIR
-
-/* Name of package */
-#undef PACKAGE
-
-/* Define to the address where bug reports for this package should be sent. */
-#undef PACKAGE_BUGREPORT
-
-/* Define to the full name of this package. */
-#undef PACKAGE_NAME
-
-/* Define to the full name and version of this package. */
-#undef PACKAGE_STRING
-
-/* Define to the one symbol short name of this package. */
-#undef PACKAGE_TARNAME
-
-/* Define to the home page for this package. */
-#undef PACKAGE_URL
-
-/* Define to the version of this package. */
-#undef PACKAGE_VERSION
-
-/* Define to 1 if all of the C90 standard headers exist (not just the ones
-   required in a freestanding environment). This macro is provided for
-   backward compatibility; new code need not use it. */
-#undef STDC_HEADERS
-
-/* Enable extensions on AIX 3, Interix.  */
-#ifndef _ALL_SOURCE
-# undef _ALL_SOURCE
-#endif
-/* Enable general extensions on macOS.  */
-#ifndef _DARWIN_C_SOURCE
-# undef _DARWIN_C_SOURCE
-#endif
-/* Enable general extensions on Solaris.  */
-#ifndef __EXTENSIONS__
-# undef __EXTENSIONS__
-#endif
-/* Enable GNU extensions on systems that have them.  */
-#ifndef _GNU_SOURCE
-# undef _GNU_SOURCE
-#endif
-/* Enable X/Open compliant socket functions that do not require linking
-   with -lxnet on HP-UX 11.11.  */
-#ifndef _HPUX_ALT_XOPEN_SOCKET_API
-# undef _HPUX_ALT_XOPEN_SOCKET_API
-#endif
-/* Identify the host operating system as Minix.
-   This macro does not affect the system headers' behavior.
-   A future release of Autoconf may stop defining this macro.  */
-#ifndef _MINIX
-# undef _MINIX
-#endif
-/* Enable general extensions on NetBSD.
-   Enable NetBSD compatibility extensions on Minix.  */
-#ifndef _NETBSD_SOURCE
-# undef _NETBSD_SOURCE
-#endif
-/* Enable OpenBSD compatibility extensions on NetBSD.
-   Oddly enough, this does nothing on OpenBSD.  */
-#ifndef _OPENBSD_SOURCE
-# undef _OPENBSD_SOURCE
-#endif
-/* Define to 1 if needed for POSIX-compatible behavior.  */
-#ifndef _POSIX_SOURCE
-# undef _POSIX_SOURCE
-#endif
-/* Define to 2 if needed for POSIX-compatible behavior.  */
-#ifndef _POSIX_1_SOURCE
-# undef _POSIX_1_SOURCE
-#endif
-/* Enable POSIX-compatible threading on Solaris.  */
-#ifndef _POSIX_PTHREAD_SEMANTICS
-# undef _POSIX_PTHREAD_SEMANTICS
-#endif
-/* Enable extensions specified by ISO/IEC TS 18661-5:2014.  */
-#ifndef __STDC_WANT_IEC_60559_ATTRIBS_EXT__
-# undef __STDC_WANT_IEC_60559_ATTRIBS_EXT__
-#endif
-/* Enable extensions specified by ISO/IEC TS 18661-1:2014.  */
-#ifndef __STDC_WANT_IEC_60559_BFP_EXT__
-# undef __STDC_WANT_IEC_60559_BFP_EXT__
-#endif
-/* Enable extensions specified by ISO/IEC TS 18661-2:2015.  */
-#ifndef __STDC_WANT_IEC_60559_DFP_EXT__
-# undef __STDC_WANT_IEC_60559_DFP_EXT__
-#endif
-/* Enable extensions specified by ISO/IEC TS 18661-4:2015.  */
-#ifndef __STDC_WANT_IEC_60559_FUNCS_EXT__
-# undef __STDC_WANT_IEC_60559_FUNCS_EXT__
-#endif
-/* Enable extensions specified by ISO/IEC TS 18661-3:2015.  */
-#ifndef __STDC_WANT_IEC_60559_TYPES_EXT__
-# undef __STDC_WANT_IEC_60559_TYPES_EXT__
-#endif
-/* Enable extensions specified by ISO/IEC TR 24731-2:2010.  */
-#ifndef __STDC_WANT_LIB_EXT2__
-# undef __STDC_WANT_LIB_EXT2__
-#endif
-/* Enable extensions specified by ISO/IEC 24747:2009.  */
-#ifndef __STDC_WANT_MATH_SPEC_FUNCS__
-# undef __STDC_WANT_MATH_SPEC_FUNCS__
-#endif
-/* Enable extensions on HP NonStop.  */
-#ifndef _TANDEM_SOURCE
-# undef _TANDEM_SOURCE
-#endif
-/* Enable X/Open extensions.  Define to 500 only if necessary
-   to make mbstate_t available.  */
-#ifndef _XOPEN_SOURCE
-# undef _XOPEN_SOURCE
-#endif
-
-
-/* Version number of package */
-#undef VERSION
-
-/* _ */
-#undef WINVER
-
-/* Number of bits in a file offset, on hosts where this is settable. */
-#undef _FILE_OFFSET_BITS
-
-/* Define for large files, on AIX-style hosts. */
-#undef _LARGE_FILES
-
-/* Define for Solaris 2.5.1 so the uint32_t typedef from <sys/synch.h>,
-   <pthread.h>, or <semaphore.h> is not used. If the typedef were allowed, the
-   #define below would cause a syntax error. */
-#undef _UINT32_T
-
-/* Define for Solaris 2.5.1 so the uint8_t typedef from <sys/synch.h>,
-   <pthread.h>, or <semaphore.h> is not used. If the typedef were allowed, the
-   #define below would cause a syntax error. */
-#undef _UINT8_T
-
-/* Define to `__inline__' or `__inline' if that's what the C compiler
-   calls it, or to nothing if 'inline' is not supported under any name.  */
-#ifndef __cplusplus
-#undef inline
-#endif
-
-/* Define to the type of a signed integer type of width exactly 64 bits if
-   such a type exists and the standard includes do not define it. */
-#undef int64_t
-
-/* Define to `unsigned int' if <sys/types.h> does not define. */
-#undef size_t
-
-/* Define to `int' if <sys/types.h> does not define. */
-#undef ssize_t
-
-/* Define to the type of an unsigned integer type of width exactly 16 bits if
-   such a type exists and the standard includes do not define it. */
-#undef uint16_t
-
-/* Define to the type of an unsigned integer type of width exactly 32 bits if
-   such a type exists and the standard includes do not define it. */
-#undef uint32_t
-
-/* Define to the type of an unsigned integer type of width exactly 8 bits if
-   such a type exists and the standard includes do not define it. */
-#undef uint8_t

src/libmodbus/inc/config.h

@@ -1,291 +0,0 @@
-/* config.h.in.  Generated from configure.ac by autoheader.  */
-
-/* Define to 1 if you have the `accept4' function. */
-#undef HAVE_ACCEPT4
-
-/* Define to 1 if you have the <arpa/inet.h> header file. */
-#undef HAVE_ARPA_INET_H
-
-/* Define to 1 if you have the <byteswap.h> header file. */
-#undef HAVE_BYTESWAP_H
-
-/* Define to 1 if you have the declaration of `TIOCM_RTS', and to 0 if you
-   don't. */
-#undef HAVE_DECL_TIOCM_RTS
-
-/* Define to 1 if you have the declaration of `TIOCSRS485', and to 0 if you
-   don't. */
-#undef HAVE_DECL_TIOCSRS485
-
-/* Define to 1 if you have the declaration of `__CYGWIN__', and to 0 if you
-   don't. */
-#undef HAVE_DECL___CYGWIN__
-
-/* Define to 1 if you have the <dlfcn.h> header file. */
-#undef HAVE_DLFCN_H
-
-/* Define to 1 if you have the <errno.h> header file. */
-#undef HAVE_ERRNO_H
-
-/* Define to 1 if you have the <fcntl.h> header file. */
-#undef HAVE_FCNTL_H
-
-/* Define to 1 if you have the `getaddrinfo' function. */
-#undef HAVE_GETADDRINFO
-
-/* Define to 1 if you have the `gettimeofday' function. */
-#undef HAVE_GETTIMEOFDAY
-
-/* Define to 1 if you have the `inet_ntop' function. */
-#undef HAVE_INET_NTOP
-
-/* Define to 1 if you have the `inet_pton' function. */
-#undef HAVE_INET_PTON
-
-/* Define to 1 if you have the <inttypes.h> header file. */
-#undef HAVE_INTTYPES_H
-
-/* Define to 1 if you have the <limits.h> header file. */
-#undef HAVE_LIMITS_H
-
-/* Define to 1 if you have the <linux/serial.h> header file. */
-#undef HAVE_LINUX_SERIAL_H
-
-/* Define to 1 if you have the <minix/config.h> header file. */
-#undef HAVE_MINIX_CONFIG_H
-
-/* Define to 1 if you have the <netdb.h> header file. */
-#undef HAVE_NETDB_H
-
-/* Define to 1 if you have the <netinet/in.h> header file. */
-#undef HAVE_NETINET_IN_H
-
-/* Define to 1 if you have the <netinet/tcp.h> header file. */
-#undef HAVE_NETINET_TCP_H
-
-/* Define to 1 if you have the `select' function. */
-#undef HAVE_SELECT
-
-/* Define to 1 if you have the `socket' function. */
-#undef HAVE_SOCKET
-
-/* Define to 1 if you have the <stdint.h> header file. */
-#undef HAVE_STDINT_H
-
-/* Define to 1 if you have the <stdio.h> header file. */
-#undef HAVE_STDIO_H
-
-/* Define to 1 if you have the <stdlib.h> header file. */
-#undef HAVE_STDLIB_H
-
-/* Define to 1 if you have the `strerror' function. */
-#undef HAVE_STRERROR
-
-/* Define to 1 if you have the <strings.h> header file. */
-#undef HAVE_STRINGS_H
-
-/* Define to 1 if you have the <string.h> header file. */
-#undef HAVE_STRING_H
-
-/* Define to 1 if you have the `strlcpy' function. */
-#undef HAVE_STRLCPY
-
-/* Define to 1 if you have the <sys/ioctl.h> header file. */
-#undef HAVE_SYS_IOCTL_H
-
-/* Define to 1 if you have the <sys/params.h> header file. */
-#undef HAVE_SYS_PARAMS_H
-
-/* Define to 1 if you have the <sys/socket.h> header file. */
-#undef HAVE_SYS_SOCKET_H
-
-/* Define to 1 if you have the <sys/stat.h> header file. */
-#undef HAVE_SYS_STAT_H
-
-/* Define to 1 if you have the <sys/time.h> header file. */
-#undef HAVE_SYS_TIME_H
-
-/* Define to 1 if you have the <sys/types.h> header file. */
-#undef HAVE_SYS_TYPES_H
-
-/* Define to 1 if you have the <termios.h> header file. */
-#undef HAVE_TERMIOS_H
-
-/* Define to 1 if you have the <time.h> header file. */
-#undef HAVE_TIME_H
-
-/* Define to 1 if you have the <unistd.h> header file. */
-#undef HAVE_UNISTD_H
-
-/* Define to 1 if you have the <wchar.h> header file. */
-#undef HAVE_WCHAR_H
-
-/* Define to 1 if you have the <winsock2.h> header file. */
-#undef HAVE_WINSOCK2_H
-
-/* Define to the sub-directory where libtool stores uninstalled libraries. */
-#undef LT_OBJDIR
-
-/* Name of package */
-#undef PACKAGE
-
-/* Define to the address where bug reports for this package should be sent. */
-#undef PACKAGE_BUGREPORT
-
-/* Define to the full name of this package. */
-#undef PACKAGE_NAME
-
-/* Define to the full name and version of this package. */
-#undef PACKAGE_STRING
-
-/* Define to the one symbol short name of this package. */
-#undef PACKAGE_TARNAME
-
-/* Define to the home page for this package. */
-#undef PACKAGE_URL
-
-/* Define to the version of this package. */
-#undef PACKAGE_VERSION
-
-/* Define to 1 if all of the C90 standard headers exist (not just the ones
-   required in a freestanding environment). This macro is provided for
-   backward compatibility; new code need not use it. */
-#undef STDC_HEADERS
-
-/* Enable extensions on AIX 3, Interix.  */
-#ifndef _ALL_SOURCE
-# undef _ALL_SOURCE
-#endif
-/* Enable general extensions on macOS.  */
-#ifndef _DARWIN_C_SOURCE
-# undef _DARWIN_C_SOURCE
-#endif
-/* Enable general extensions on Solaris.  */
-#ifndef __EXTENSIONS__
-# undef __EXTENSIONS__
-#endif
-/* Enable GNU extensions on systems that have them.  */
-#ifndef _GNU_SOURCE
-# undef _GNU_SOURCE
-#endif
-/* Enable X/Open compliant socket functions that do not require linking
-   with -lxnet on HP-UX 11.11.  */
-#ifndef _HPUX_ALT_XOPEN_SOCKET_API
-# undef _HPUX_ALT_XOPEN_SOCKET_API
-#endif
-/* Identify the host operating system as Minix.
-   This macro does not affect the system headers' behavior.
-   A future release of Autoconf may stop defining this macro.  */
-#ifndef _MINIX
-# undef _MINIX
-#endif
-/* Enable general extensions on NetBSD.
-   Enable NetBSD compatibility extensions on Minix.  */
-#ifndef _NETBSD_SOURCE
-# undef _NETBSD_SOURCE
-#endif
-/* Enable OpenBSD compatibility extensions on NetBSD.
-   Oddly enough, this does nothing on OpenBSD.  */
-#ifndef _OPENBSD_SOURCE
-# undef _OPENBSD_SOURCE
-#endif
-/* Define to 1 if needed for POSIX-compatible behavior.  */
-#ifndef _POSIX_SOURCE
-# undef _POSIX_SOURCE
-#endif
-/* Define to 2 if needed for POSIX-compatible behavior.  */
-#ifndef _POSIX_1_SOURCE
-# undef _POSIX_1_SOURCE
-#endif
-/* Enable POSIX-compatible threading on Solaris.  */
-#ifndef _POSIX_PTHREAD_SEMANTICS
-# undef _POSIX_PTHREAD_SEMANTICS
-#endif
-/* Enable extensions specified by ISO/IEC TS 18661-5:2014.  */
-#ifndef __STDC_WANT_IEC_60559_ATTRIBS_EXT__
-# undef __STDC_WANT_IEC_60559_ATTRIBS_EXT__
-#endif
-/* Enable extensions specified by ISO/IEC TS 18661-1:2014.  */
-#ifndef __STDC_WANT_IEC_60559_BFP_EXT__
-# undef __STDC_WANT_IEC_60559_BFP_EXT__
-#endif
-/* Enable extensions specified by ISO/IEC TS 18661-2:2015.  */
-#ifndef __STDC_WANT_IEC_60559_DFP_EXT__
-# undef __STDC_WANT_IEC_60559_DFP_EXT__
-#endif
-/* Enable extensions specified by ISO/IEC TS 18661-4:2015.  */
-#ifndef __STDC_WANT_IEC_60559_FUNCS_EXT__
-# undef __STDC_WANT_IEC_60559_FUNCS_EXT__
-#endif
-/* Enable extensions specified by ISO/IEC TS 18661-3:2015.  */
-#ifndef __STDC_WANT_IEC_60559_TYPES_EXT__
-# undef __STDC_WANT_IEC_60559_TYPES_EXT__
-#endif
-/* Enable extensions specified by ISO/IEC TR 24731-2:2010.  */
-#ifndef __STDC_WANT_LIB_EXT2__
-# undef __STDC_WANT_LIB_EXT2__
-#endif
-/* Enable extensions specified by ISO/IEC 24747:2009.  */
-#ifndef __STDC_WANT_MATH_SPEC_FUNCS__
-# undef __STDC_WANT_MATH_SPEC_FUNCS__
-#endif
-/* Enable extensions on HP NonStop.  */
-#ifndef _TANDEM_SOURCE
-# undef _TANDEM_SOURCE
-#endif
-/* Enable X/Open extensions.  Define to 500 only if necessary
-   to make mbstate_t available.  */
-#ifndef _XOPEN_SOURCE
-# undef _XOPEN_SOURCE
-#endif
-
-
-/* Version number of package */
-#undef VERSION
-
-/* _ */
-#undef WINVER
-
-/* Number of bits in a file offset, on hosts where this is settable. */
-#undef _FILE_OFFSET_BITS
-
-/* Define for large files, on AIX-style hosts. */
-#undef _LARGE_FILES
-
-/* Define for Solaris 2.5.1 so the uint32_t typedef from <sys/synch.h>,
-   <pthread.h>, or <semaphore.h> is not used. If the typedef were allowed, the
-   #define below would cause a syntax error. */
-#undef _UINT32_T
-
-/* Define for Solaris 2.5.1 so the uint8_t typedef from <sys/synch.h>,
-   <pthread.h>, or <semaphore.h> is not used. If the typedef were allowed, the
-   #define below would cause a syntax error. */
-#undef _UINT8_T
-
-/* Define to `__inline__' or `__inline' if that's what the C compiler
-   calls it, or to nothing if 'inline' is not supported under any name.  */
-#ifndef __cplusplus
-#undef inline
-#endif
-
-/* Define to the type of a signed integer type of width exactly 64 bits if
-   such a type exists and the standard includes do not define it. */
-#undef int64_t
-
-/* Define to `unsigned int' if <sys/types.h> does not define. */
-#undef size_t
-
-/* Define to `int' if <sys/types.h> does not define. */
-#undef ssize_t
-
-/* Define to the type of an unsigned integer type of width exactly 16 bits if
-   such a type exists and the standard includes do not define it. */
-#undef uint16_t
-
-/* Define to the type of an unsigned integer type of width exactly 32 bits if
-   such a type exists and the standard includes do not define it. */
-#undef uint32_t
-
-/* Define to the type of an unsigned integer type of width exactly 8 bits if
-   such a type exists and the standard includes do not define it. */
-#undef uint8_t

src/libmodbus/inc/modbus-private.h

@@ -1,121 +0,0 @@
-/*
- * Copyright © Stéphane Raimbault <stephane.raimbault@gmail.com>
- *
- * SPDX-License-Identifier: LGPL-2.1-or-later
- */
-
-#ifndef MODBUS_PRIVATE_H
-#define MODBUS_PRIVATE_H
-
-// clang-format off
-#ifndef _MSC_VER
-# include <stdint.h>
-# include <sys/time.h>
-#else
-# include "stdint.h"
-# include <time.h>
-typedef int ssize_t;
-#endif
-// clang-format on
-#include <config.h>
-#include <sys/types.h>
-
-#include "modbus.h"
-
-MODBUS_BEGIN_DECLS
-
-/* It's not really the minimal length (the real one is report slave ID
- * in RTU (4 bytes)) but it's a convenient size to use in RTU or TCP
- * communications to read many values or write a single one.
- * Maximum between :
- * - HEADER_LENGTH_TCP (7) + function (1) + address (2) + number (2)
- * - HEADER_LENGTH_RTU (1) + function (1) + address (2) + number (2) + CRC (2)
- */
-#define _MIN_REQ_LENGTH 12
-
-#define _REPORT_SLAVE_ID 180
-
-#define _MODBUS_EXCEPTION_RSP_LENGTH 5
-
-/* Timeouts in microsecond (0.5 s) */
-#define _RESPONSE_TIMEOUT 500000
-#define _BYTE_TIMEOUT     500000
-
-typedef enum {
-    _MODBUS_BACKEND_TYPE_RTU = 0,
-    _MODBUS_BACKEND_TYPE_TCP
-} modbus_backend_type_t;
-
-/*
- *  ---------- Request     Indication ----------
- *  | Client | ---------------------->| Server |
- *  ---------- Confirmation  Response ----------
- */
-typedef enum {
-    /* Request message on the server side */
-    MSG_INDICATION,
-    /* Request message on the client side */
-    MSG_CONFIRMATION
-} msg_type_t;
-
-/* This structure reduces the number of params in functions and so
- * optimizes the speed of execution (~ 37%). */
-typedef struct _sft {
-    int slave;
-    int function;
-    int t_id;
-} sft_t;
-
-typedef struct _modbus_backend {
-    unsigned int backend_type;
-    unsigned int header_length;
-    unsigned int checksum_length;
-    unsigned int max_adu_length;
-    int (*set_slave)(modbus_t *ctx, int slave);
-    int (*build_request_basis)(
-        modbus_t *ctx, int function, int addr, int nb, uint8_t *req);
-    int (*build_response_basis)(sft_t *sft, uint8_t *rsp);
-    int (*prepare_response_tid)(const uint8_t *req, int *req_length);
-    int (*send_msg_pre)(uint8_t *req, int req_length);
-    ssize_t (*send)(modbus_t *ctx, const uint8_t *req, int req_length);
-    int (*receive)(modbus_t *ctx, uint8_t *req);
-    ssize_t (*recv)(modbus_t *ctx, uint8_t *rsp, int rsp_length);
-    int (*check_integrity)(modbus_t *ctx, uint8_t *msg, const int msg_length);
-    int (*pre_check_confirmation)(modbus_t *ctx,
-                                  const uint8_t *req,
-                                  const uint8_t *rsp,
-                                  int rsp_length);
-    int (*connect)(modbus_t *ctx);
-    unsigned int (*is_connected)(modbus_t *ctx);
-    void (*close)(modbus_t *ctx);
-    int (*flush)(modbus_t *ctx);
-    int (*select)(modbus_t *ctx, fd_set *rset, struct timeval *tv, int msg_length);
-    void (*free)(modbus_t *ctx);
-} modbus_backend_t;
-
-struct _modbus {
-    /* Slave address */
-    int slave;
-    /* Socket or file descriptor */
-    int s;
-    int debug;
-    int error_recovery;
-    int quirks;
-    struct timeval response_timeout;
-    struct timeval byte_timeout;
-    struct timeval indication_timeout;
-    const modbus_backend_t *backend;
-    void *backend_data;
-};
-
-void _modbus_init_common(modbus_t *ctx);
-void _error_print(modbus_t *ctx, const char *context);
-int _modbus_receive_msg(modbus_t *ctx, uint8_t *msg, msg_type_t msg_type);
-
-#ifndef HAVE_STRLCPY
-size_t strlcpy(char *dest, const char *src, size_t dest_size);
-#endif
-
-MODBUS_END_DECLS
-
-#endif /* MODBUS_PRIVATE_H */

src/libmodbus/inc/modbus-rtu-private.h

@@ -1,77 +0,0 @@
-/*
- * Copyright © Stéphane Raimbault <stephane.raimbault@gmail.com>
- *
- * SPDX-License-Identifier: LGPL-2.1-or-later
- */
-
-#ifndef MODBUS_RTU_PRIVATE_H
-#define MODBUS_RTU_PRIVATE_H
-
-#ifndef _MSC_VER
-#include <stdint.h>
-#else
-#include "stdint.h"
-#endif
-
-#if defined(_WIN32)
-#include <windows.h>
-#else
-#include <termios.h>
-#endif
-
-#define _MODBUS_RTU_HEADER_LENGTH     1
-#define _MODBUS_RTU_PRESET_REQ_LENGTH 6
-#define _MODBUS_RTU_PRESET_RSP_LENGTH 2
-
-#define _MODBUS_RTU_CHECKSUM_LENGTH 2
-
-#if defined(_WIN32)
-#if !defined(ENOTSUP)
-#define ENOTSUP WSAEOPNOTSUPP
-#endif
-
-/* WIN32: struct containing serial handle and a receive buffer */
-#define PY_BUF_SIZE 512
-
-struct win32_ser {
-    /* File handle */
-    HANDLE fd;
-    /* Receive buffer */
-    uint8_t buf[PY_BUF_SIZE];
-    /* Received chars */
-    DWORD n_bytes;
-};
-#endif /* _WIN32 */
-
-typedef struct _modbus_rtu {
-    /* Device: "/dev/ttyS0", "/dev/ttyUSB0" or "/dev/tty.USA19*" on Mac OS X. */
-    char *device;
-    /* Bauds: 9600, 19200, 57600, 115200, etc */
-    int baud;
-    /* Data bit */
-    uint8_t data_bit;
-    /* Stop bit */
-    uint8_t stop_bit;
-    /* Parity: 'N', 'O', 'E' */
-    char parity;
-#if defined(_WIN32)
-    struct win32_ser w_ser;
-    DCB old_dcb;
-#else
-    /* Save old termios settings */
-    struct termios old_tios;
-#endif
-#if HAVE_DECL_TIOCSRS485
-    int serial_mode;
-#endif
-#if HAVE_DECL_TIOCM_RTS
-    int rts;
-    int rts_delay;
-    int onebyte_time;
-    void (*set_rts)(modbus_t *ctx, int on);
-#endif
-    /* To handle many slaves on the same link */
-    int confirmation_to_ignore;
-} modbus_rtu_t;
-
-#endif /* MODBUS_RTU_PRIVATE_H */

src/libmodbus/inc/modbus-rtu.h

@@ -1,43 +0,0 @@
-/*
- * Copyright © Stéphane Raimbault <stephane.raimbault@gmail.com>
- *
- * SPDX-License-Identifier: LGPL-2.1-or-later
- */
-
-#ifndef MODBUS_RTU_H
-#define MODBUS_RTU_H
-
-#include "modbus.h"
-
-MODBUS_BEGIN_DECLS
-
-/* Modbus_Application_Protocol_V1_1b.pdf Chapter 4 Section 1 Page 5
- * RS232 / RS485 ADU = 253 bytes + slave (1 byte) + CRC (2 bytes) = 256 bytes
- */
-#define MODBUS_RTU_MAX_ADU_LENGTH 256
-
-MODBUS_API modbus_t *
-modbus_new_rtu(const char *device, int baud, char parity, int data_bit, int stop_bit);
-
-#define MODBUS_RTU_RS232 0
-#define MODBUS_RTU_RS485 1
-
-MODBUS_API int modbus_rtu_set_serial_mode(modbus_t *ctx, int mode);
-MODBUS_API int modbus_rtu_get_serial_mode(modbus_t *ctx);
-
-#define MODBUS_RTU_RTS_NONE 0
-#define MODBUS_RTU_RTS_UP   1
-#define MODBUS_RTU_RTS_DOWN 2
-
-MODBUS_API int modbus_rtu_set_rts(modbus_t *ctx, int mode);
-MODBUS_API int modbus_rtu_get_rts(modbus_t *ctx);
-
-MODBUS_API int modbus_rtu_set_custom_rts(modbus_t *ctx,
-                                         void (*set_rts)(modbus_t *ctx, int on));
-
-MODBUS_API int modbus_rtu_set_rts_delay(modbus_t *ctx, int us);
-MODBUS_API int modbus_rtu_get_rts_delay(modbus_t *ctx);
-
-MODBUS_END_DECLS
-
-#endif /* MODBUS_RTU_H */

src/libmodbus/inc/modbus-tcp-private.h

@@ -1,41 +0,0 @@
-/*
- * Copyright © Stéphane Raimbault <stephane.raimbault@gmail.com>
- *
- * SPDX-License-Identifier: LGPL-2.1-or-later
- */
-
-#ifndef MODBUS_TCP_PRIVATE_H
-#define MODBUS_TCP_PRIVATE_H
-
-#define _MODBUS_TCP_HEADER_LENGTH     7
-#define _MODBUS_TCP_PRESET_REQ_LENGTH 12
-#define _MODBUS_TCP_PRESET_RSP_LENGTH 8
-
-#define _MODBUS_TCP_CHECKSUM_LENGTH 0
-
-/* In both structures, the transaction ID must be placed on first position
-   to have a quick access not dependent of the TCP backend */
-typedef struct _modbus_tcp {
-    /* Extract from MODBUS Messaging on TCP/IP Implementation Guide V1.0b
-       (page 23/46):
-       The transaction identifier is used to associate the future response
-       with the request. This identifier is unique on each TCP connection. */
-    uint16_t t_id;
-    /* TCP port */
-    int port;
-    /* IP address */
-    char ip[16];
-} modbus_tcp_t;
-
-typedef struct _modbus_tcp_pi {
-    /* Transaction ID */
-    uint16_t t_id;
-    /* TCP port */
-    int port;
-    /* Node */
-    char *node;
-    /* Service */
-    char *service;
-} modbus_tcp_pi_t;
-
-#endif /* MODBUS_TCP_PRIVATE_H */

src/libmodbus/inc/modbus-tcp.h

@@ -1,52 +0,0 @@
-/*
- * Copyright © Stéphane Raimbault <stephane.raimbault@gmail.com>
- *
- * SPDX-License-Identifier: LGPL-2.1-or-later
- */
-
-#ifndef MODBUS_TCP_H
-#define MODBUS_TCP_H
-
-#include "modbus.h"
-
-MODBUS_BEGIN_DECLS
-
-#if defined(_WIN32) && !defined(__CYGWIN__)
-/* Win32 with MinGW, supplement to <errno.h> */
-#include <winsock2.h>
-#if !defined(ECONNRESET)
-#define ECONNRESET WSAECONNRESET
-#endif
-#if !defined(ECONNREFUSED)
-#define ECONNREFUSED WSAECONNREFUSED
-#endif
-#if !defined(ETIMEDOUT)
-#define ETIMEDOUT WSAETIMEDOUT
-#endif
-#if !defined(ENOPROTOOPT)
-#define ENOPROTOOPT WSAENOPROTOOPT
-#endif
-#if !defined(EINPROGRESS)
-#define EINPROGRESS WSAEINPROGRESS
-#endif
-#endif
-
-#define MODBUS_TCP_DEFAULT_PORT 502
-#define MODBUS_TCP_SLAVE        0xFF
-
-/* Modbus_Application_Protocol_V1_1b.pdf Chapter 4 Section 1 Page 5
- * TCP MODBUS ADU = 253 bytes + MBAP (7 bytes) = 260 bytes
- */
-#define MODBUS_TCP_MAX_ADU_LENGTH 260
-
-MODBUS_API modbus_t *modbus_new_tcp(const char *ip_address, int port);
-MODBUS_API int modbus_tcp_listen(modbus_t *ctx, int nb_connection);
-MODBUS_API int modbus_tcp_accept(modbus_t *ctx, int *s);
-
-MODBUS_API modbus_t *modbus_new_tcp_pi(const char *node, const char *service);
-MODBUS_API int modbus_tcp_pi_listen(modbus_t *ctx, int nb_connection);
-MODBUS_API int modbus_tcp_pi_accept(modbus_t *ctx, int *s);
-
-MODBUS_END_DECLS
-
-#endif /* MODBUS_TCP_H */

src/libmodbus/inc/modbus-version.h

@@ -1,51 +0,0 @@
-/*
- * Copyright © Stéphane Raimbault <stephane.raimbault@gmail.com>
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * This library 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
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef MODBUS_VERSION_H
-#define MODBUS_VERSION_H
-
-/* The major version, (1, if %LIBMODBUS_VERSION is 1.2.3) */
-#define LIBMODBUS_VERSION_MAJOR (3)
-
-/* The minor version (2, if %LIBMODBUS_VERSION is 1.2.3) */
-#define LIBMODBUS_VERSION_MINOR (1)
-
-/* The micro version (3, if %LIBMODBUS_VERSION is 1.2.3) */
-#define LIBMODBUS_VERSION_MICRO (10)
-
-/* The full version, like 1.2.3 */
-#define LIBMODBUS_VERSION 3.1.10
-
-/* The full version, in string form (suited for string concatenation)
- */
-#define LIBMODBUS_VERSION_STRING "3.1.10"
-
-/* Numerically encoded version, eg. v1.2.3 is 0x010203 */
-#define LIBMODBUS_VERSION_HEX                                                                      \
-    ((LIBMODBUS_VERSION_MAJOR << 16) | (LIBMODBUS_VERSION_MINOR << 8) |                            \
-     (LIBMODBUS_VERSION_MICRO << 0))
-
-/* Evaluates to True if the version is greater than @major, @minor and @micro
- */
-#define LIBMODBUS_VERSION_CHECK(major, minor, micro)                                               \
-    (LIBMODBUS_VERSION_MAJOR > (major) ||                                                          \
-     (LIBMODBUS_VERSION_MAJOR == (major) && LIBMODBUS_VERSION_MINOR > (minor)) ||                  \
-     (LIBMODBUS_VERSION_MAJOR == (major) && LIBMODBUS_VERSION_MINOR == (minor) &&                  \
-      LIBMODBUS_VERSION_MICRO >= (micro)))
-
-#endif /* MODBUS_VERSION_H */

src/libmodbus/inc/modbus.h

@@ -1,329 +0,0 @@
-/*
- * Copyright © Stéphane Raimbault <stephane.raimbault@gmail.com>
- *
- * SPDX-License-Identifier: LGPL-2.1-or-later
- */
-
-#ifndef MODBUS_H
-#define MODBUS_H
-
-// clang-format off
-/* 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)
-# 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
-// clang-format on
-
-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 _modbus_mapping_t {
-    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;
-
-typedef enum {
-    MODBUS_QUIRK_NONE = 0,
-    MODBUS_QUIRK_MAX_SLAVE = (1 << 1),
-    MODBUS_QUIRK_REPLY_TO_BROADCAST = (1 << 2),
-    MODBUS_QUIRK_ALL = 0xFF
-} modbus_quirks;
-
-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, const uint16_t 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, const 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);
-MODBUS_API int modbus_enable_quirks(modbus_t *ctx, unsigned int quirks_mask);
-MODBUS_API int modbus_disable_quirks(modbus_t *ctx, unsigned int quirks_mask);
-
-/**
- * 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) \
-  (((int32_t) tab_int16[(index)] << 16) | (int32_t) tab_int16[(index) + 1])
-#define MODBUS_GET_INT16_FROM_INT8(tab_int8, index) \
-  (((int16_t) tab_int8[(index)] << 8) | (int16_t) tab_int8[(index) + 1])
-#define MODBUS_SET_INT16_TO_INT8(tab_int8, index, value)        \
-  do {                                                          \
-    ((int8_t *) (tab_int8))[(index)] = (int8_t) ((value) >> 8); \
-    ((int8_t *) (tab_int8))[(index) + 1] = (int8_t) (value);    \
-  } while (0)
-#define MODBUS_SET_INT32_TO_INT16(tab_int16, index, value)          \
-  do {                                                              \
-    ((int16_t *) (tab_int16))[(index)] = (int16_t) ((value) >> 16); \
-    ((int16_t *) (tab_int16))[(index) + 1] = (int16_t) (value);     \
-  } while (0)
-#define MODBUS_SET_INT64_TO_INT16(tab_int16, index, value)              \
-  do {                                                                  \
-    ((int16_t *) (tab_int16))[(index)] = (int16_t) ((value) >> 48);     \
-    ((int16_t *) (tab_int16))[(index) + 1] = (int16_t) ((value) >> 32); \
-    ((int16_t *) (tab_int16))[(index) + 2] = (int16_t) ((value) >> 16); \
-    ((int16_t *) (tab_int16))[(index) + 3] = (int16_t) (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-rtu.h"
-#include "modbus-tcp.h"
-
-MODBUS_END_DECLS
-
-#endif /* MODBUS_H */

src/libmodbus/src/modbus-data.c

@@ -1,292 +0,0 @@
-/*
- * Copyright © Stéphane Raimbault <stephane.raimbault@gmail.com>
- *
- * SPDX-License-Identifier: LGPL-2.1-or-later
- */
-
-#include <stdlib.h>
-
-// clang-format off
-#ifndef _MSC_VER
-#  include <stdint.h>
-#else
-#  include "stdint.h"
-#endif
-
-#include <string.h>
-#include <assert.h>
-
-#if defined(_WIN32)
-#  include <winsock2.h>
-#else
-#  include <arpa/inet.h>
-#endif
-
-#include <config.h>
-
-#include "modbus.h"
-
-#if defined(HAVE_BYTESWAP_H)
-#  include <byteswap.h>
-#endif
-
-#if defined(__APPLE__)
-#  include <libkern/OSByteOrder.h>
-#  define bswap_16 OSSwapInt16
-#  define bswap_32 OSSwapInt32
-#  define bswap_64 OSSwapInt64
-#endif
-
-#if defined(__GNUC__)
-#  define GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__ * 10)
-#  if GCC_VERSION >= 430
-// Since GCC >= 4.30, GCC provides __builtin_bswapXX() alternatives so we switch to them
-#    undef bswap_32
-#    define bswap_32 __builtin_bswap32
-#  endif
-#  if GCC_VERSION >= 480
-#    undef bswap_16
-#    define bswap_16 __builtin_bswap16
-#  endif
-#endif
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1400)
-#  define bswap_32 _byteswap_ulong
-#  define bswap_16 _byteswap_ushort
-#endif
-
-#if !defined(bswap_16)
-#  warning "Fallback on C functions for bswap_16"
-static inline uint16_t bswap_16(uint16_t x)
-{
-    return (x >> 8) | (x << 8);
-}
-#endif
-
-#if !defined(bswap_32)
-#  warning "Fallback on C functions for bswap_32"
-static inline uint32_t bswap_32(uint32_t x)
-{
-    return (bswap_16(x & 0xffff) << 16) | (bswap_16(x >> 16));
-}
-#endif
-// clang-format on
-
-/* Sets many bits from a single byte value (all 8 bits of the byte value are
-   set) */
-void modbus_set_bits_from_byte(uint8_t *dest, int idx, const uint8_t value)
-{
-    int i;
-
-    for (i = 0; i < 8; i++) {
-        dest[idx + i] = (value & (1 << i)) ? 1 : 0;
-    }
-}
-
-/* Sets many bits from a table of bytes (only the bits between idx and
-   idx + nb_bits are set) */
-void modbus_set_bits_from_bytes(uint8_t *dest,
-                                int idx,
-                                unsigned int nb_bits,
-                                const uint8_t *tab_byte)
-{
-    unsigned int i;
-    int shift = 0;
-
-    for (i = idx; i < idx + nb_bits; i++) {
-        dest[i] = tab_byte[(i - idx) / 8] & (1 << shift) ? 1 : 0;
-        /* gcc doesn't like: shift = (++shift) % 8; */
-        shift++;
-        shift %= 8;
-    }
-}
-
-/* Gets the byte value from many bits.
-   To obtain a full byte, set nb_bits to 8. */
-uint8_t modbus_get_byte_from_bits(const uint8_t *src, int idx, unsigned int nb_bits)
-{
-    unsigned int i;
-    uint8_t value = 0;
-
-    if (nb_bits > 8) {
-        /* Assert is ignored if NDEBUG is set */
-        assert(nb_bits < 8);
-        nb_bits = 8;
-    }
-
-    for (i = 0; i < nb_bits; i++) {
-        value |= (src[idx + i] << i);
-    }
-
-    return value;
-}
-
-/* Get a float from 4 bytes (Modbus) without any conversion (ABCD) */
-float modbus_get_float_abcd(const uint16_t *src)
-{
-    float f;
-    uint32_t i;
-    uint8_t a, b, c, d;
-
-    a = (src[0] >> 8) & 0xFF;
-    b = (src[0] >> 0) & 0xFF;
-    c = (src[1] >> 8) & 0xFF;
-    d = (src[1] >> 0) & 0xFF;
-
-    i = (a << 24) | (b << 16) | (c << 8) | (d << 0);
-    memcpy(&f, &i, 4);
-
-    return f;
-}
-
-/* Get a float from 4 bytes (Modbus) in inversed format (DCBA) */
-float modbus_get_float_dcba(const uint16_t *src)
-{
-    float f;
-    uint32_t i;
-    uint8_t a, b, c, d;
-
-    a = (src[0] >> 8) & 0xFF;
-    b = (src[0] >> 0) & 0xFF;
-    c = (src[1] >> 8) & 0xFF;
-    d = (src[1] >> 0) & 0xFF;
-
-    i = (d << 24) | (c << 16) | (b << 8) | (a << 0);
-    memcpy(&f, &i, 4);
-
-    return f;
-}
-
-/* Get a float from 4 bytes (Modbus) with swapped bytes (BADC) */
-float modbus_get_float_badc(const uint16_t *src)
-{
-    float f;
-    uint32_t i;
-    uint8_t a, b, c, d;
-
-    a = (src[0] >> 8) & 0xFF;
-    b = (src[0] >> 0) & 0xFF;
-    c = (src[1] >> 8) & 0xFF;
-    d = (src[1] >> 0) & 0xFF;
-
-    i = (b << 24) | (a << 16) | (d << 8) | (c << 0);
-    memcpy(&f, &i, 4);
-
-    return f;
-}
-
-/* Get a float from 4 bytes (Modbus) with swapped words (CDAB) */
-float modbus_get_float_cdab(const uint16_t *src)
-{
-    float f;
-    uint32_t i;
-    uint8_t a, b, c, d;
-
-    a = (src[0] >> 8) & 0xFF;
-    b = (src[0] >> 0) & 0xFF;
-    c = (src[1] >> 8) & 0xFF;
-    d = (src[1] >> 0) & 0xFF;
-
-    i = (c << 24) | (d << 16) | (a << 8) | (b << 0);
-    memcpy(&f, &i, 4);
-
-    return f;
-}
-
-/* DEPRECATED - Get a float from 4 bytes in sort of Modbus format */
-float modbus_get_float(const uint16_t *src)
-{
-    float f;
-    uint32_t i;
-
-    i = (((uint32_t) src[1]) << 16) + src[0];
-    memcpy(&f, &i, sizeof(float));
-
-    return f;
-}
-
-/* Set a float to 4 bytes for Modbus w/o any conversion (ABCD) */
-void modbus_set_float_abcd(float f, uint16_t *dest)
-{
-    uint32_t i;
-    uint8_t *out = (uint8_t *) dest;
-    uint8_t a, b, c, d;
-
-    memcpy(&i, &f, sizeof(uint32_t));
-    a = (i >> 24) & 0xFF;
-    b = (i >> 16) & 0xFF;
-    c = (i >> 8) & 0xFF;
-    d = (i >> 0) & 0xFF;
-
-    out[0] = a;
-    out[1] = b;
-    out[2] = c;
-    out[3] = d;
-}
-
-/* Set a float to 4 bytes for Modbus with byte and word swap conversion (DCBA) */
-void modbus_set_float_dcba(float f, uint16_t *dest)
-{
-    uint32_t i;
-    uint8_t *out = (uint8_t *) dest;
-    uint8_t a, b, c, d;
-
-    memcpy(&i, &f, sizeof(uint32_t));
-    a = (i >> 24) & 0xFF;
-    b = (i >> 16) & 0xFF;
-    c = (i >> 8) & 0xFF;
-    d = (i >> 0) & 0xFF;
-
-    out[0] = d;
-    out[1] = c;
-    out[2] = b;
-    out[3] = a;
-}
-
-/* Set a float to 4 bytes for Modbus with byte swap conversion (BADC) */
-void modbus_set_float_badc(float f, uint16_t *dest)
-{
-    uint32_t i;
-    uint8_t *out = (uint8_t *) dest;
-    uint8_t a, b, c, d;
-
-    memcpy(&i, &f, sizeof(uint32_t));
-    a = (i >> 24) & 0xFF;
-    b = (i >> 16) & 0xFF;
-    c = (i >> 8) & 0xFF;
-    d = (i >> 0) & 0xFF;
-
-    out[0] = b;
-    out[1] = a;
-    out[2] = d;
-    out[3] = c;
-}
-
-/* Set a float to 4 bytes for Modbus with word swap conversion (CDAB) */
-void modbus_set_float_cdab(float f, uint16_t *dest)
-{
-    uint32_t i;
-    uint8_t *out = (uint8_t *) dest;
-    uint8_t a, b, c, d;
-
-    memcpy(&i, &f, sizeof(uint32_t));
-    a = (i >> 24) & 0xFF;
-    b = (i >> 16) & 0xFF;
-    c = (i >> 8) & 0xFF;
-    d = (i >> 0) & 0xFF;
-
-    out[0] = c;
-    out[1] = d;
-    out[2] = a;
-    out[3] = b;
-}
-
-/* DEPRECATED - Set a float to 4 bytes in a sort of Modbus format! */
-void modbus_set_float(float f, uint16_t *dest)
-{
-    uint32_t i;
-
-    memcpy(&i, &f, sizeof(uint32_t));
-    dest[0] = (uint16_t) i;
-    dest[1] = (uint16_t) (i >> 16);
-}

src/libmodbus/src/modbus-tcp.c

@@ -1,974 +0,0 @@
-/*
- * Copyright © Stéphane Raimbault <stephane.raimbault@gmail.com>
- *
- * SPDX-License-Identifier: LGPL-2.1-or-later
- */
-
-// clang-format off
-#if defined(_WIN32)
-# define OS_WIN32
-/* ws2_32.dll has getaddrinfo and freeaddrinfo on Windows XP and later.
- * minwg32 headers check WINVER before allowing the use of these */
-# ifndef WINVER
-#   define WINVER 0x0501
-# endif
-#endif
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <errno.h>
-#ifndef _MSC_VER
-#include <unistd.h>
-#endif
-#include <signal.h>
-#include <sys/types.h>
-
-#if defined(_WIN32)
-/* Already set in modbus-tcp.h but it seems order matters in VS2005 */
-# include <winsock2.h>
-# include <ws2tcpip.h>
-# define SHUT_RDWR 2
-# define close closesocket
-# define strdup _strdup
-#else
-# include <sys/socket.h>
-# include <sys/ioctl.h>
-
-#if defined(__OpenBSD__) || (defined(__FreeBSD__) && __FreeBSD__ < 5)
-# define OS_BSD
-# include <netinet/in_systm.h>
-#endif
-
-# include <netinet/in.h>
-# include <netinet/ip.h>
-# include <netinet/tcp.h>
-# include <arpa/inet.h>
-# include <netdb.h>
-#endif
-
-#if !defined(MSG_NOSIGNAL)
-#define MSG_NOSIGNAL 0
-#endif
-
-#if defined(_AIX) && !defined(MSG_DONTWAIT)
-#define MSG_DONTWAIT MSG_NONBLOCK
-#endif
-// clang-format on
-
-#include "modbus-private.h"
-
-#include "modbus-tcp-private.h"
-#include "modbus-tcp.h"
-
-#ifdef OS_WIN32
-static int _modbus_tcp_init_win32(void)
-{
-    /* Initialise Windows Socket API */
-    WSADATA wsaData;
-
-    if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0) {
-        fprintf(stderr,
-                "WSAStartup() returned error code %d\n",
-                (unsigned int) GetLastError());
-        errno = EIO;
-        return -1;
-    }
-    return 0;
-}
-#endif
-
-static int _modbus_set_slave(modbus_t *ctx, int slave)
-{
-    int max_slave = (ctx->quirks & MODBUS_QUIRK_MAX_SLAVE) ? 255 : 247;
-
-    /* Broadcast address is 0 (MODBUS_BROADCAST_ADDRESS) */
-    if (slave >= 0 && slave <= max_slave) {
-        ctx->slave = slave;
-    } else if (slave == MODBUS_TCP_SLAVE) {
-        /* The special value MODBUS_TCP_SLAVE (0xFF) can be used in TCP mode to
-         * restore the default value. */
-        ctx->slave = slave;
-    } else {
-        errno = EINVAL;
-        return -1;
-    }
-
-    return 0;
-}
-
-/* Builds a TCP request header */
-static int _modbus_tcp_build_request_basis(
-    modbus_t *ctx, int function, int addr, int nb, uint8_t *req)
-{
-    modbus_tcp_t *ctx_tcp = ctx->backend_data;
-
-    /* Increase transaction ID */
-    if (ctx_tcp->t_id < UINT16_MAX)
-        ctx_tcp->t_id++;
-    else
-        ctx_tcp->t_id = 0;
-    req[0] = ctx_tcp->t_id >> 8;
-    req[1] = ctx_tcp->t_id & 0x00ff;
-
-    /* Protocol Modbus */
-    req[2] = 0;
-    req[3] = 0;
-
-    /* Length will be defined later by set_req_length_tcp at offsets 4
-       and 5 */
-
-    req[6] = ctx->slave;
-    req[7] = function;
-    req[8] = addr >> 8;
-    req[9] = addr & 0x00ff;
-    req[10] = nb >> 8;
-    req[11] = nb & 0x00ff;
-
-    return _MODBUS_TCP_PRESET_REQ_LENGTH;
-}
-
-/* Builds a TCP response header */
-static int _modbus_tcp_build_response_basis(sft_t *sft, uint8_t *rsp)
-{
-    /* Extract from MODBUS Messaging on TCP/IP Implementation
-       Guide V1.0b (page 23/46):
-       The transaction identifier is used to associate the future
-       response with the request. */
-    rsp[0] = sft->t_id >> 8;
-    rsp[1] = sft->t_id & 0x00ff;
-
-    /* Protocol Modbus */
-    rsp[2] = 0;
-    rsp[3] = 0;
-
-    /* Length will be set later by send_msg (4 and 5) */
-
-    /* The slave ID is copied from the indication */
-    rsp[6] = sft->slave;
-    rsp[7] = sft->function;
-
-    return _MODBUS_TCP_PRESET_RSP_LENGTH;
-}
-
-static int _modbus_tcp_prepare_response_tid(const uint8_t *req, int *req_length)
-{
-    return (req[0] << 8) + req[1];
-}
-
-static int _modbus_tcp_send_msg_pre(uint8_t *req, int req_length)
-{
-    /* Subtract the header length to the message length */
-    int mbap_length = req_length - 6;
-
-    req[4] = mbap_length >> 8;
-    req[5] = mbap_length & 0x00FF;
-
-    return req_length;
-}
-
-static ssize_t _modbus_tcp_send(modbus_t *ctx, const uint8_t *req, int req_length)
-{
-    /* MSG_NOSIGNAL
-       Requests not to send SIGPIPE on errors on stream oriented
-       sockets when the other end breaks the connection.  The EPIPE
-       error is still returned. */
-    return send(ctx->s, (const char *) req, req_length, MSG_NOSIGNAL);
-}
-
-static int _modbus_tcp_receive(modbus_t *ctx, uint8_t *req)
-{
-    return _modbus_receive_msg(ctx, req, MSG_INDICATION);
-}
-
-static ssize_t _modbus_tcp_recv(modbus_t *ctx, uint8_t *rsp, int rsp_length)
-{
-    return recv(ctx->s, (char *) rsp, rsp_length, 0);
-}
-
-static int _modbus_tcp_check_integrity(modbus_t *ctx, uint8_t *msg, const int msg_length)
-{
-    return msg_length;
-}
-
-static int _modbus_tcp_pre_check_confirmation(modbus_t *ctx,
-                                              const uint8_t *req,
-                                              const uint8_t *rsp,
-                                              int rsp_length)
-{
-    unsigned int protocol_id;
-    /* Check transaction ID */
-    if (req[0] != rsp[0] || req[1] != rsp[1]) {
-        if (ctx->debug) {
-            fprintf(stderr,
-                    "Invalid transaction ID received 0x%X (not 0x%X)\n",
-                    (rsp[0] << 8) + rsp[1],
-                    (req[0] << 8) + req[1]);
-        }
-        errno = EMBBADDATA;
-        return -1;
-    }
-
-    /* Check protocol ID */
-    protocol_id = (rsp[2] << 8) + rsp[3];
-    if (protocol_id != 0x0) {
-        if (ctx->debug) {
-            fprintf(stderr, "Invalid protocol ID received 0x%X (not 0x0)\n", protocol_id);
-        }
-        errno = EMBBADDATA;
-        return -1;
-    }
-
-    return 0;
-}
-
-static int _modbus_tcp_set_ipv4_options(int s)
-{
-    int rc;
-    int option;
-
-    /* Set the TCP no delay flag */
-    /* SOL_TCP = IPPROTO_TCP */
-    option = 1;
-    rc = setsockopt(s, IPPROTO_TCP, TCP_NODELAY, (const void *) &option, sizeof(int));
-    if (rc == -1) {
-        return -1;
-    }
-
-    /* If the OS does not offer SOCK_NONBLOCK, fall back to setting FIONBIO to
-     * make sockets non-blocking */
-    /* Do not care about the return value, this is optional */
-#if !defined(SOCK_NONBLOCK) && defined(FIONBIO)
-#ifdef OS_WIN32
-    {
-        /* Setting FIONBIO expects an unsigned long according to MSDN */
-        u_long loption = 1;
-        ioctlsocket(s, FIONBIO, &loption);
-    }
-#else
-    option = 1;
-    ioctl(s, FIONBIO, &option);
-#endif
-#endif
-
-#ifndef OS_WIN32
-    /**
-     * Cygwin defines IPTOS_LOWDELAY but can't handle that flag so it's
-     * necessary to workaround that problem.
-     **/
-    /* Set the IP low delay option */
-    option = IPTOS_LOWDELAY;
-    rc = setsockopt(s, IPPROTO_IP, IP_TOS, (const void *) &option, sizeof(int));
-    if (rc == -1) {
-        return -1;
-    }
-#endif
-
-    return 0;
-}
-
-static int _connect(int sockfd,
-                    const struct sockaddr *addr,
-                    socklen_t addrlen,
-                    const struct timeval *ro_tv)
-{
-    int rc = connect(sockfd, addr, addrlen);
-
-#ifdef OS_WIN32
-    int wsaError = 0;
-    if (rc == -1) {
-        wsaError = WSAGetLastError();
-    }
-
-    if (wsaError == WSAEWOULDBLOCK || wsaError == WSAEINPROGRESS) {
-#else
-    if (rc == -1 && errno == EINPROGRESS) {
-#endif
-        fd_set wset;
-        int optval;
-        socklen_t optlen = sizeof(optval);
-        struct timeval tv = *ro_tv;
-
-        /* Wait to be available in writing */
-        FD_ZERO(&wset);
-        FD_SET(sockfd, &wset);
-        rc = select(sockfd + 1, NULL, &wset, NULL, &tv);
-        if (rc <= 0) {
-            /* Timeout or fail */
-            return -1;
-        }
-
-        /* The connection is established if SO_ERROR and optval are set to 0 */
-        rc = getsockopt(sockfd, SOL_SOCKET, SO_ERROR, (void *) &optval, &optlen);
-        if (rc == 0 && optval == 0) {
-            return 0;
-        } else {
-            errno = ECONNREFUSED;
-            return -1;
-        }
-    }
-    return rc;
-}
-
-/* Establishes a modbus TCP connection with a Modbus server. */
-static int _modbus_tcp_connect(modbus_t *ctx)
-{
-    int rc;
-    /* Specialized version of sockaddr for Internet socket address (same size) */
-    struct sockaddr_in addr;
-    modbus_tcp_t *ctx_tcp = ctx->backend_data;
-    int flags = SOCK_STREAM;
-
-#ifdef OS_WIN32
-    if (_modbus_tcp_init_win32() == -1) {
-        return -1;
-    }
-#endif
-
-#ifdef SOCK_CLOEXEC
-    flags |= SOCK_CLOEXEC;
-#endif
-
-#ifdef SOCK_NONBLOCK
-    flags |= SOCK_NONBLOCK;
-#endif
-
-    ctx->s = socket(PF_INET, flags, 0);
-    if (ctx->s < 0) {
-        return -1;
-    }
-
-    rc = _modbus_tcp_set_ipv4_options(ctx->s);
-    if (rc == -1) {
-        close(ctx->s);
-        ctx->s = -1;
-        return -1;
-    }
-
-    if (ctx->debug) {
-        printf("Connecting to %s:%d\n", ctx_tcp->ip, ctx_tcp->port);
-    }
-
-    addr.sin_family = AF_INET;
-    addr.sin_port = htons(ctx_tcp->port);
-    rc = inet_pton(addr.sin_family, ctx_tcp->ip, &(addr.sin_addr));
-    if (rc <= 0) {
-        if (ctx->debug) {
-            fprintf(stderr, "Invalid IP address: %s\n", ctx_tcp->ip);
-        }
-        close(ctx->s);
-        ctx->s = -1;
-        return -1;
-    }
-
-    rc =
-        _connect(ctx->s, (struct sockaddr *) &addr, sizeof(addr), &ctx->response_timeout);
-    if (rc == -1) {
-        close(ctx->s);
-        ctx->s = -1;
-        return -1;
-    }
-
-    return 0;
-}
-
-/* Establishes a modbus TCP PI connection with a Modbus server. */
-static int _modbus_tcp_pi_connect(modbus_t *ctx)
-{
-    int rc;
-    struct addrinfo *ai_list;
-    struct addrinfo *ai_ptr;
-    struct addrinfo ai_hints;
-    modbus_tcp_pi_t *ctx_tcp_pi = ctx->backend_data;
-
-#ifdef OS_WIN32
-    if (_modbus_tcp_init_win32() == -1) {
-        return -1;
-    }
-#endif
-
-    memset(&ai_hints, 0, sizeof(ai_hints));
-#ifdef AI_ADDRCONFIG
-    ai_hints.ai_flags |= AI_ADDRCONFIG;
-#endif
-    ai_hints.ai_family = AF_UNSPEC;
-    ai_hints.ai_socktype = SOCK_STREAM;
-    ai_hints.ai_addr = NULL;
-    ai_hints.ai_canonname = NULL;
-    ai_hints.ai_next = NULL;
-
-    ai_list = NULL;
-    rc = getaddrinfo(ctx_tcp_pi->node, ctx_tcp_pi->service, &ai_hints, &ai_list);
-    if (rc != 0) {
-        if (ctx->debug) {
-            fprintf(stderr, "Error returned by getaddrinfo: %s\n", gai_strerror(rc));
-        }
-        errno = ECONNREFUSED;
-        return -1;
-    }
-
-    for (ai_ptr = ai_list; ai_ptr != NULL; ai_ptr = ai_ptr->ai_next) {
-        int flags = ai_ptr->ai_socktype;
-        int s;
-
-#ifdef SOCK_CLOEXEC
-        flags |= SOCK_CLOEXEC;
-#endif
-
-#ifdef SOCK_NONBLOCK
-        flags |= SOCK_NONBLOCK;
-#endif
-
-        s = socket(ai_ptr->ai_family, flags, ai_ptr->ai_protocol);
-        if (s < 0)
-            continue;
-
-        if (ai_ptr->ai_family == AF_INET)
-            _modbus_tcp_set_ipv4_options(s);
-
-        if (ctx->debug) {
-            printf("Connecting to [%s]:%s\n", ctx_tcp_pi->node, ctx_tcp_pi->service);
-        }
-
-        rc = _connect(s, ai_ptr->ai_addr, ai_ptr->ai_addrlen, &ctx->response_timeout);
-        if (rc == -1) {
-            close(s);
-            continue;
-        }
-
-        ctx->s = s;
-        break;
-    }
-
-    freeaddrinfo(ai_list);
-
-    if (ctx->s < 0) {
-        return -1;
-    }
-
-    return 0;
-}
-
-static unsigned int _modbus_tcp_is_connected(modbus_t *ctx)
-{
-    return ctx->s >= 0;
-}
-
-/* Closes the network connection and socket in TCP mode */
-static void _modbus_tcp_close(modbus_t *ctx)
-{
-    if (ctx->s >= 0) {
-        shutdown(ctx->s, SHUT_RDWR);
-        close(ctx->s);
-        ctx->s = -1;
-    }
-}
-
-static int _modbus_tcp_flush(modbus_t *ctx)
-{
-    int rc;
-    int rc_sum = 0;
-
-    do {
-        /* Extract the garbage from the socket */
-        char devnull[MODBUS_TCP_MAX_ADU_LENGTH];
-#ifndef OS_WIN32
-        rc = recv(ctx->s, devnull, MODBUS_TCP_MAX_ADU_LENGTH, MSG_DONTWAIT);
-#else
-        /* On Win32, it's a bit more complicated to not wait */
-        fd_set rset;
-        struct timeval tv;
-
-        tv.tv_sec = 0;
-        tv.tv_usec = 0;
-        FD_ZERO(&rset);
-        FD_SET(ctx->s, &rset);
-        rc = select(ctx->s + 1, &rset, NULL, NULL, &tv);
-        if (rc == -1) {
-            return -1;
-        }
-
-        if (rc == 1) {
-            /* There is data to flush */
-            rc = recv(ctx->s, devnull, MODBUS_TCP_MAX_ADU_LENGTH, 0);
-        }
-#endif
-        if (rc > 0) {
-            rc_sum += rc;
-        }
-    } while (rc == MODBUS_TCP_MAX_ADU_LENGTH);
-
-    return rc_sum;
-}
-
-/* Listens for any request from one or many modbus masters in TCP */
-int modbus_tcp_listen(modbus_t *ctx, int nb_connection)
-{
-    int new_s;
-    int enable;
-    int flags;
-    struct sockaddr_in addr;
-    modbus_tcp_t *ctx_tcp;
-    int rc;
-
-    if (ctx == NULL) {
-        errno = EINVAL;
-        return -1;
-    }
-
-    ctx_tcp = ctx->backend_data;
-
-#ifdef OS_WIN32
-    if (_modbus_tcp_init_win32() == -1) {
-        return -1;
-    }
-#endif
-
-    flags = SOCK_STREAM;
-
-#ifdef SOCK_CLOEXEC
-    flags |= SOCK_CLOEXEC;
-#endif
-
-    new_s = socket(PF_INET, flags, IPPROTO_TCP);
-    if (new_s == -1) {
-        return -1;
-    }
-
-    enable = 1;
-    if (setsockopt(new_s, SOL_SOCKET, SO_REUSEADDR, (char *) &enable, sizeof(enable)) ==
-        -1) {
-        close(new_s);
-        return -1;
-    }
-
-    memset(&addr, 0, sizeof(addr));
-    addr.sin_family = AF_INET;
-    /* If the modbus port is < to 1024, we need the setuid root. */
-    addr.sin_port = htons(ctx_tcp->port);
-    if (ctx_tcp->ip[0] == '0') {
-        /* Listen any addresses */
-        addr.sin_addr.s_addr = htonl(INADDR_ANY);
-    } else {
-        /* Listen only specified IP address */
-        rc = inet_pton(addr.sin_family, ctx_tcp->ip, &(addr.sin_addr));
-        if (rc <= 0) {
-            if (ctx->debug) {
-                fprintf(stderr, "Invalid IP address: %s\n", ctx_tcp->ip);
-            }
-            close(new_s);
-            return -1;
-        }
-    }
-
-    if (bind(new_s, (struct sockaddr *) &addr, sizeof(addr)) == -1) {
-        close(new_s);
-        return -1;
-    }
-
-    if (listen(new_s, nb_connection) == -1) {
-        close(new_s);
-        return -1;
-    }
-
-    return new_s;
-}
-
-int modbus_tcp_pi_listen(modbus_t *ctx, int nb_connection)
-{
-    int rc;
-    struct addrinfo *ai_list;
-    struct addrinfo *ai_ptr;
-    struct addrinfo ai_hints;
-    const char *node;
-    const char *service;
-    int new_s;
-    modbus_tcp_pi_t *ctx_tcp_pi;
-
-    if (ctx == NULL) {
-        errno = EINVAL;
-        return -1;
-    }
-
-    ctx_tcp_pi = ctx->backend_data;
-
-#ifdef OS_WIN32
-    if (_modbus_tcp_init_win32() == -1) {
-        return -1;
-    }
-#endif
-
-    if (ctx_tcp_pi->node[0] == 0) {
-        node = NULL; /* == any */
-    } else {
-        node = ctx_tcp_pi->node;
-    }
-
-    if (ctx_tcp_pi->service[0] == 0) {
-        service = "502";
-    } else {
-        service = ctx_tcp_pi->service;
-    }
-
-    memset(&ai_hints, 0, sizeof(ai_hints));
-    /* If node is not NULL, than the AI_PASSIVE flag is ignored. */
-    ai_hints.ai_flags |= AI_PASSIVE;
-#ifdef AI_ADDRCONFIG
-    ai_hints.ai_flags |= AI_ADDRCONFIG;
-#endif
-    ai_hints.ai_family = AF_UNSPEC;
-    ai_hints.ai_socktype = SOCK_STREAM;
-    ai_hints.ai_addr = NULL;
-    ai_hints.ai_canonname = NULL;
-    ai_hints.ai_next = NULL;
-
-    ai_list = NULL;
-    rc = getaddrinfo(node, service, &ai_hints, &ai_list);
-    if (rc != 0) {
-        if (ctx->debug) {
-            fprintf(stderr, "Error returned by getaddrinfo: %s\n", gai_strerror(rc));
-        }
-        errno = ECONNREFUSED;
-        return -1;
-    }
-
-    new_s = -1;
-    for (ai_ptr = ai_list; ai_ptr != NULL; ai_ptr = ai_ptr->ai_next) {
-        int flags = ai_ptr->ai_socktype;
-        int s;
-
-#ifdef SOCK_CLOEXEC
-        flags |= SOCK_CLOEXEC;
-#endif
-
-        s = socket(ai_ptr->ai_family, flags, ai_ptr->ai_protocol);
-        if (s < 0) {
-            if (ctx->debug) {
-                perror("socket");
-            }
-            continue;
-        } else {
-            int enable = 1;
-            rc =
-                setsockopt(s, SOL_SOCKET, SO_REUSEADDR, (void *) &enable, sizeof(enable));
-            if (rc != 0) {
-                close(s);
-                if (ctx->debug) {
-                    perror("setsockopt");
-                }
-                continue;
-            }
-        }
-
-        rc = bind(s, ai_ptr->ai_addr, ai_ptr->ai_addrlen);
-        if (rc != 0) {
-            close(s);
-            if (ctx->debug) {
-                perror("bind");
-            }
-            continue;
-        }
-
-        rc = listen(s, nb_connection);
-        if (rc != 0) {
-            close(s);
-            if (ctx->debug) {
-                perror("listen");
-            }
-            continue;
-        }
-
-        new_s = s;
-        break;
-    }
-    freeaddrinfo(ai_list);
-
-    if (new_s < 0) {
-        return -1;
-    }
-
-    return new_s;
-}
-
-int modbus_tcp_accept(modbus_t *ctx, int *s)
-{
-    struct sockaddr_in addr;
-    socklen_t addrlen;
-
-    if (ctx == NULL) {
-        errno = EINVAL;
-        return -1;
-    }
-
-    addrlen = sizeof(addr);
-#ifdef HAVE_ACCEPT4
-    /* Inherit socket flags and use accept4 call */
-    ctx->s = accept4(*s, (struct sockaddr *) &addr, &addrlen, SOCK_CLOEXEC);
-#else
-    ctx->s = accept(*s, (struct sockaddr *) &addr, &addrlen);
-#endif
-
-    if (ctx->s < 0) {
-        return -1;
-    }
-
-    if (ctx->debug) {
-        char buf[INET_ADDRSTRLEN];
-        if (inet_ntop(AF_INET, &(addr.sin_addr), buf, INET_ADDRSTRLEN) == NULL) {
-            fprintf(stderr, "Client connection accepted from unparsable IP.\n");
-        } else {
-            printf("Client connection accepted from %s.\n", buf);
-        }
-    }
-
-    return ctx->s;
-}
-
-int modbus_tcp_pi_accept(modbus_t *ctx, int *s)
-{
-    struct sockaddr_in6 addr;
-    socklen_t addrlen;
-
-    if (ctx == NULL) {
-        errno = EINVAL;
-        return -1;
-    }
-
-    addrlen = sizeof(addr);
-#ifdef HAVE_ACCEPT4
-    /* Inherit socket flags and use accept4 call */
-    ctx->s = accept4(*s, (struct sockaddr *) &addr, &addrlen, SOCK_CLOEXEC);
-#else
-    ctx->s = accept(*s, (struct sockaddr *) &addr, &addrlen);
-#endif
-
-    if (ctx->s < 0) {
-        return -1;
-    }
-
-    if (ctx->debug) {
-        char buf[INET6_ADDRSTRLEN];
-        if (inet_ntop(AF_INET6, &(addr.sin6_addr), buf, INET6_ADDRSTRLEN) == NULL) {
-            fprintf(stderr, "Client connection accepted from unparsable IP.\n");
-        } else {
-            printf("Client connection accepted from %s.\n", buf);
-        }
-    }
-
-    return ctx->s;
-}
-
-static int
-_modbus_tcp_select(modbus_t *ctx, fd_set *rset, struct timeval *tv, int length_to_read)
-{
-    int s_rc;
-    while ((s_rc = select(ctx->s + 1, rset, NULL, NULL, tv)) == -1) {
-        if (errno == EINTR) {
-            if (ctx->debug) {
-                fprintf(stderr, "A non blocked signal was caught\n");
-            }
-            /* Necessary after an error */
-            FD_ZERO(rset);
-            FD_SET(ctx->s, rset);
-        } else {
-            return -1;
-        }
-    }
-
-    if (s_rc == 0) {
-        errno = ETIMEDOUT;
-        return -1;
-    }
-
-    return s_rc;
-}
-
-static void _modbus_tcp_free(modbus_t *ctx)
-{
-    if (ctx->backend_data) {
-        free(ctx->backend_data);
-    }
-    free(ctx);
-}
-
-static void _modbus_tcp_pi_free(modbus_t *ctx)
-{
-    if (ctx->backend_data) {
-        modbus_tcp_pi_t *ctx_tcp_pi = ctx->backend_data;
-        free(ctx_tcp_pi->node);
-        free(ctx_tcp_pi->service);
-        free(ctx->backend_data);
-    }
-
-    free(ctx);
-}
-
-// clang-format off
-const modbus_backend_t _modbus_tcp_backend = {
-    _MODBUS_BACKEND_TYPE_TCP,
-    _MODBUS_TCP_HEADER_LENGTH,
-    _MODBUS_TCP_CHECKSUM_LENGTH,
-    MODBUS_TCP_MAX_ADU_LENGTH,
-    _modbus_set_slave,
-    _modbus_tcp_build_request_basis,
-    _modbus_tcp_build_response_basis,
-    _modbus_tcp_prepare_response_tid,
-    _modbus_tcp_send_msg_pre,
-    _modbus_tcp_send,
-    _modbus_tcp_receive,
-    _modbus_tcp_recv,
-    _modbus_tcp_check_integrity,
-    _modbus_tcp_pre_check_confirmation,
-    _modbus_tcp_connect,
-    _modbus_tcp_is_connected,
-    _modbus_tcp_close,
-    _modbus_tcp_flush,
-    _modbus_tcp_select,
-    _modbus_tcp_free
-};
-
-const modbus_backend_t _modbus_tcp_pi_backend = {
-    _MODBUS_BACKEND_TYPE_TCP,
-    _MODBUS_TCP_HEADER_LENGTH,
-    _MODBUS_TCP_CHECKSUM_LENGTH,
-    MODBUS_TCP_MAX_ADU_LENGTH,
-    _modbus_set_slave,
-    _modbus_tcp_build_request_basis,
-    _modbus_tcp_build_response_basis,
-    _modbus_tcp_prepare_response_tid,
-    _modbus_tcp_send_msg_pre,
-    _modbus_tcp_send,
-    _modbus_tcp_receive,
-    _modbus_tcp_recv,
-    _modbus_tcp_check_integrity,
-    _modbus_tcp_pre_check_confirmation,
-    _modbus_tcp_pi_connect,
-    _modbus_tcp_is_connected,
-    _modbus_tcp_close,
-    _modbus_tcp_flush,
-    _modbus_tcp_select,
-    _modbus_tcp_pi_free
-};
-
-// clang-format on
-
-modbus_t *modbus_new_tcp(const char *ip, int port)
-{
-    modbus_t *ctx;
-    modbus_tcp_t *ctx_tcp;
-    size_t dest_size;
-    size_t ret_size;
-
-#if defined(OS_BSD)
-    /* MSG_NOSIGNAL is unsupported on *BSD so we install an ignore
-       handler for SIGPIPE. */
-    struct sigaction sa;
-
-    sa.sa_handler = SIG_IGN;
-    if (sigaction(SIGPIPE, &sa, NULL) < 0) {
-        /* The debug flag can't be set here... */
-        fprintf(stderr, "Could not install SIGPIPE handler.\n");
-        return NULL;
-    }
-#endif
-
-    ctx = (modbus_t *) malloc(sizeof(modbus_t));
-    if (ctx == NULL) {
-        return NULL;
-    }
-    _modbus_init_common(ctx);
-
-    /* Could be changed after to reach a remote serial Modbus device */
-    ctx->slave = MODBUS_TCP_SLAVE;
-
-    ctx->backend = &_modbus_tcp_backend;
-
-    ctx->backend_data = (modbus_tcp_t *) malloc(sizeof(modbus_tcp_t));
-    if (ctx->backend_data == NULL) {
-        modbus_free(ctx);
-        errno = ENOMEM;
-        return NULL;
-    }
-    ctx_tcp = (modbus_tcp_t *) ctx->backend_data;
-
-    if (ip != NULL) {
-        dest_size = sizeof(char) * 16;
-        ret_size = strlcpy(ctx_tcp->ip, ip, dest_size);
-        if (ret_size == 0) {
-            fprintf(stderr, "The IP string is empty\n");
-            modbus_free(ctx);
-            errno = EINVAL;
-            return NULL;
-        }
-
-        if (ret_size >= dest_size) {
-            fprintf(stderr, "The IP string has been truncated\n");
-            modbus_free(ctx);
-            errno = EINVAL;
-            return NULL;
-        }
-    } else {
-        ctx_tcp->ip[0] = '0';
-    }
-    ctx_tcp->port = port;
-    ctx_tcp->t_id = 0;
-
-    return ctx;
-}
-
-modbus_t *modbus_new_tcp_pi(const char *node, const char *service)
-{
-    modbus_t *ctx;
-    modbus_tcp_pi_t *ctx_tcp_pi;
-
-    ctx = (modbus_t *) malloc(sizeof(modbus_t));
-    if (ctx == NULL) {
-        return NULL;
-    }
-    _modbus_init_common(ctx);
-
-    /* Could be changed after to reach a remote serial Modbus device */
-    ctx->slave = MODBUS_TCP_SLAVE;
-
-    ctx->backend = &_modbus_tcp_pi_backend;
-
-    ctx->backend_data = (modbus_tcp_pi_t *) malloc(sizeof(modbus_tcp_pi_t));
-    if (ctx->backend_data == NULL) {
-        modbus_free(ctx);
-        errno = ENOMEM;
-        return NULL;
-    }
-    ctx_tcp_pi = (modbus_tcp_pi_t *) ctx->backend_data;
-    ctx_tcp_pi->node = NULL;
-    ctx_tcp_pi->service = NULL;
-
-    if (node != NULL) {
-        ctx_tcp_pi->node = strdup(node);
-    } else {
-        /* The node argument can be empty to indicate any hosts */
-        ctx_tcp_pi->node = strdup("");
-    }
-
-    if (ctx_tcp_pi->node == NULL) {
-        modbus_free(ctx);
-        errno = ENOMEM;
-        return NULL;
-    }
-
-    if (service != NULL && service[0] != '\0') {
-        ctx_tcp_pi->service = strdup(service);
-    } else {
-        /* Default Modbus port number */
-        ctx_tcp_pi->service = strdup("502");
-    }
-
-    if (ctx_tcp_pi->service == NULL) {
-        modbus_free(ctx);
-        errno = ENOMEM;
-        return NULL;
-    }
-
-    ctx_tcp_pi->t_id = 0;
-
-    return ctx;
-}

src/main.cpp

@@ -19,32 +19,16 @@ int main(int argc, char **argv) {
 	signal(SIGTERM, sigHandler);
 	signal(SIGABRT, sigHandler);
 
-	std::string version{"v2.3"};
+	std::string version{"v2.2w"};
 	std::cout << version << std::endl;
 
 	CLI::App hoymilesClient{"Client for DTU-Pro/DTU-ProS"};
 
 	hoymilesClient.set_version_flag("-v,--version", version);
 
-	std::string serialDeviceAddress{""};
-	std::string serialDeviceAddressHelp{"Serial device address"};
-	hoymilesClient.add_option<std::string>("-d,--serial_device_address", serialDeviceAddress, serialDeviceAddressHelp)->group("Serial");
-
-	bool rtuMode{false};
-	std::string rtuModeHelp{"Work in RTU mode"};
-	hoymilesClient.add_flag<bool>("-r,--rtu", rtuMode, rtuModeHelp)->needs(hoymilesClient.get_option("-d"))->group("Serial");
-
-	int rtuDeviceAddress{1};
-	std::string rtuDeviceAddressHelp{"Address on RS485 {default: }" + std::to_string(rtuDeviceAddress) + "}"};
-	hoymilesClient.add_option<int>("-a,--rt_device_address", rtuDeviceAddress, rtuDeviceAddressHelp)->group("Serial");
-
 	std::string ipAddress{"127.0.0.1"};
-	std::string ipAddressHelp{"Ipv4 address of DTU {default: " + ipAddress + "}"};
+	std::string ipAddressHelp{"ipv4 address of DTU {default: " + ipAddress + "}"};
-	hoymilesClient.add_option<std::string>("-i,--ip_address", ipAddress, ipAddressHelp)->group("Networking");
+	hoymilesClient.add_option<std::string>("-i,--ip_address", ipAddress, ipAddressHelp)->required()->group("Networking");
-
-	bool tcpMode{false};
-	std::string tcpModeHelp{"Work in Ipv4 mode"};
-	hoymilesClient.add_flag<bool>("-t,--tcp", tcpMode, tcpModeHelp)->needs(hoymilesClient.get_option("-i"))->group("Networking");
 
 	int port{502};
 	std::string portHelp{"Port of DTU {default: " + std::to_string(port) + "}"};
@@ -55,25 +39,21 @@ int main(int argc, char **argv) {
 					"todayProduction [tdP]\n  - totalProduction [ttP]\n  - temperature [t]\n  - operatingStatus [oS]\n  - alarmCode [aC]\n  - alarmCount [aCnt]\n  - linkStatus [lS]"};
 	hoymilesClient.add_option<std::vector<std::string>>("-P,--parameters", parametersToGet, parametersToGetHelp)->delimiter(',')->group("Parameters");
 
-	bool allParameters{false};
+	bool allParameters = false;
 	std::string allParametersHelp{"Fetch all parameters"};
-	hoymilesClient.add_flag<bool>("-A,--all_parameters", allParameters, allParametersHelp)->group("Parameters");
+	hoymilesClient.add_flag<bool>("-a,--all_parameters", allParameters, allParametersHelp)->group("Parameters");
 
-	bool shortNames{false};
+	bool shortNames = false;
 	std::string shortNamesHelp{"Print short parameter names"};
 	hoymilesClient.add_flag<bool>("-s,--short", shortNames, shortNamesHelp)->group("Parameters");
 
-	bool getMicroinverters{false};
-	std::string getMicroinvertersHelp{"Print all microinverters instead of getting parameters"};
-	hoymilesClient.add_flag<bool>("-M,--get_microinverters", getMicroinverters, getMicroinvertersHelp)->group("Microinverters");
-
 	std::vector<long long> microinvertersToChoose{};
 	std::string microinvertersToChooseHelp{"List of microinverters to work on, delimited by ','; if omitted, all are selected"};
 	hoymilesClient.add_option<std::vector<long long>>("-m,--microinverters", microinvertersToChoose, microinvertersToChooseHelp)->delimiter(',')->group("Microinverters");
 
 	bool microinvertersGetTodayProduction{false};
 	std::string microinvertersGetTodayProductionHelp{"Show today production for microinverters"};
-	hoymilesClient.add_flag<bool>("-D,--today_production", microinvertersGetTodayProduction, microinvertersGetTodayProductionHelp)->group("Microinverters");
+	hoymilesClient.add_flag<bool>("-t,--today_production", microinvertersGetTodayProduction, microinvertersGetTodayProductionHelp)->group("Microinverters");
 
 	bool microinvertersGetTotalProduction{false};
 	std::string microinvertersGetTotalProductionHelp{"Show total production for microinverters"};
@@ -103,22 +83,12 @@ int main(int argc, char **argv) {
 
 	std::cout << "Mapping out DTU" << std::endl;
 	auto startTime = std::chrono::high_resolution_clock::now();
-	std::string address;
+	Dtu dtu{ipAddress.c_str(), port};
-	int id;
-	if (tcpMode) {
-		address = ipAddress;
-		id = port;
-	}
-	if (rtuMode) {
-		address = serialDeviceAddress;
-		id = rtuDeviceAddress;
-	}
-	Dtu dtu{address.c_str(), id, rtuMode, tcpMode};
 	auto endTime = std::chrono::high_resolution_clock::now();
 	std::cout << "DTU construction time: " << std::chrono::duration_cast<std::chrono::milliseconds>(endTime - startTime).count() << "ms" << std::endl;
 	std::cout << std::endl << std::endl;
 
-	while ((!writeMode && !getMicroinverters) && (!dtu.empty() && ((dtu.isConnected() || ignoreNotConnected) && (!parametersToGet.empty() || allParameters)))) {
+	while (!writeMode && (!dtu.empty() && ((dtu.isConnected() || ignoreNotConnected) && (!parametersToGet.empty() || allParameters)))) {
 		time_t now = std::chrono::system_clock::to_time_t(std::chrono::system_clock::now());
 
 		startTime = std::chrono::high_resolution_clock::now();
@@ -135,11 +105,7 @@ int main(int argc, char **argv) {
 	// 	std::cerr << dtu.modbusErrorMessage() << std::endl;
 	// }
 
-	if(getMicroinverters) {
+	if(writeMode) {
-		dtu.listOfMicroinverters();
-	}
-
-	if (writeMode) {
 		std::cout << "Starting DTU write" << std::endl;
 
 		startTime = std::chrono::high_resolution_clock::now();