Merge pull request #2 from NikolasK-source/development

Development

Author: NikolasK-source

.gitmodules

@@ -1,6 +1,6 @@
 [submodule "libs/cxxopts"]
 	path = libs/cxxopts
-    url = https://github.com/NikolasK-source/cxxopts.git
+	url = https://github.com/NikolasK-source/cxxopts.git
 [submodule "libs/libmodbus"]
 	path = libs/libmodbus
 	url = https://github.com/stephane/libmodbus

CMakeLists.txt

@@ -4,7 +4,7 @@ cmake_minimum_required(VERSION 3.13.4 FATAL_ERROR)
 # ======================================================================================================================
 
 # project
-project(Modbus_TCP_client_shm LANGUAGES CXX VERSION 1.0.3)
+project(Modbus_TCP_client_shm LANGUAGES CXX VERSION 1.1.0)
 
 # settings
 set(Target "Modbus_TCP_client_shm")    # Executable name (without file extension!)

libs/cxxopts

@@ -5,15 +5,23 @@
 
 #include "Modbus_TCP_Slave.hpp"
 
+#include <algorithm>
+#include <arpa/inet.h>
+#include <cstring>
+#include <netinet/in.h>
+#include <netinet/tcp.h>
+#include <sstream>
 #include <stdexcept>
+#include <sys/socket.h>
+#include <system_error>
 #include <unistd.h>
 
 namespace Modbus {
 namespace TCP {
 
 static constexpr int MAX_REGS = 0x10000;
 
-Slave::Slave(const std::string &ip, unsigned short port, modbus_mapping_t *mapping) {
+Slave::Slave(const std::string &ip, unsigned short port, modbus_mapping_t *mapping, std::size_t tcp_timeout) {
     // create modbus object
     modbus = modbus_new_tcp(ip.c_str(), static_cast<int>(port));
     if (modbus == nullptr) {
@@ -42,6 +50,48 @@ Slave::Slave(const std::string &ip, unsigned short port, modbus_mapping_t *mappi
         const std::string error_msg = modbus_strerror(errno);
         throw std::runtime_error("failed to create tcp socket: " + error_msg);
     }
+
+    // set socket options
+    // enable socket keepalive (--> fail if connection partner is not reachable)
+    int keepalive = 1;
+    int tmp       = setsockopt(socket, SOL_SOCKET, SO_KEEPALIVE, &keepalive, sizeof(keepalive));
+    if (tmp != 0) {
+        throw std::system_error(errno, std::generic_category(), "Failed to set socket option SO_KEEPALIVE");
+    }
+
+#ifdef OS_LINUX
+    if (tcp_timeout) {
+        // set user timeout (~= timeout for tcp connection)
+        unsigned user_timeout = static_cast<unsigned>(tcp_timeout) * 1000;
+        tmp                   = setsockopt(socket, IPPROTO_TCP, TCP_USER_TIMEOUT, &user_timeout, sizeof(keepalive));
+        if (tmp != 0) {
+            throw std::system_error(errno, std::generic_category(), "Failed to set socket option TCP_USER_TIMEOUT");
+        }
+
+        // start sending keepalive request after one second without request
+        unsigned keepidle = 1;
+        tmp               = setsockopt(socket, IPPROTO_TCP, TCP_KEEPIDLE, &keepidle, sizeof(keepidle));
+        if (tmp != 0) {
+            throw std::system_error(errno, std::generic_category(), "Failed to set socket option TCP_KEEPIDLE");
+        }
+
+        // send up to 5 keepalive requests during the timeout time, but not more than one per second
+        unsigned keepintvl = std::max(static_cast<unsigned>(tcp_timeout / 5), 1u);
+        tmp                = setsockopt(socket, IPPROTO_TCP, TCP_KEEPINTVL, &keepintvl, sizeof(keepintvl));
+        if (tmp != 0) {
+            throw std::system_error(errno, std::generic_category(), "Failed to set socket option TCP_KEEPINTVL");
+        }
+
+        // 5 keepalive requests if the timeout time is >= 5s; else send one request each second
+        unsigned keepcnt = std::min(static_cast<unsigned>(tcp_timeout), 5u);
+        tmp              = setsockopt(socket, IPPROTO_TCP, TCP_KEEPCNT, &keepcnt, sizeof(keepcnt));
+        if (tmp != 0) {
+            throw std::system_error(errno, std::generic_category(), "Failed to set socket option TCP_KEEPCNT");
+        }
+    }
+#else
+    static_cast<void>(tcp_timeout);
+#endif
 }
 
 Slave::~Slave() {
@@ -60,12 +110,29 @@ void Slave::set_debug(bool debug) {
     }
 }
 
-void Slave::connect_client() {
+std::string Slave::connect_client() {
     int tmp = modbus_tcp_accept(modbus, &socket);
     if (tmp < 0) {
         const std::string error_msg = modbus_strerror(errno);
         throw std::runtime_error("modbus_tcp_accept failed: " + error_msg);
     }
+
+    struct sockaddr_in peer_addr;
+    socklen_t          len = sizeof(peer_addr);
+    tmp = getpeername(modbus_get_socket(modbus), reinterpret_cast<struct sockaddr *>(&peer_addr), &len);
+
+    if (tmp < 0) {
+        const std::string error_msg = modbus_strerror(errno);
+        throw std::runtime_error("getpeername failed: " + error_msg);
+    }
+
+    char buffer[INET_ADDRSTRLEN];
+    inet_ntop(peer_addr.sin_family, &peer_addr.sin_addr, buffer, sizeof(buffer));
+
+    std::ostringstream sstr;
+    sstr << buffer << ':' << htons(peer_addr.sin_port);
+
+    return sstr.str();
 }
 
 bool Slave::handle_request() {
@@ -75,7 +142,11 @@ bool Slave::handle_request() {
 
     if (rc > 0) {
         // handle request
-        modbus_reply(modbus, query, rc, mapping);
+        int ret = modbus_reply(modbus, query, rc, mapping);
+        if (ret == -1) {
+            const std::string error_msg = modbus_strerror(errno);
+            throw std::runtime_error("modbus_reply failed: " + error_msg + ' ' + std::to_string(errno));
+        }
     } else if (rc == -1) {
         if (errno == ECONNRESET) return true;
 
@@ -86,5 +157,67 @@ bool Slave::handle_request() {
     return false;
 }
 
+struct timeout_t {
+    uint32_t sec;
+    uint32_t usec;
+};
+
+static inline timeout_t double_to_timeout_t(double timeout) {
+    timeout_t ret {};
+
+    ret.sec = static_cast<uint32_t>(timeout);
+
+    double fractional = timeout - static_cast<double>(ret.sec);
+    ret.usec          = static_cast<uint32_t>(fractional * 1000.0 * 1000.0);
+
+    return ret;
+}
+
+void Slave::set_byte_timeout(double timeout) {
+    const auto T   = double_to_timeout_t(timeout);
+    auto       ret = modbus_set_byte_timeout(modbus, T.sec, T.usec);
+
+    if (ret != 0) {
+        const std::string error_msg = modbus_strerror(errno);
+        throw std::runtime_error("modbus_receive failed: " + error_msg + ' ' + std::to_string(errno));
+    }
+}
+
+void Slave::set_response_timeout(double timeout) {
+    const auto T   = double_to_timeout_t(timeout);
+    auto       ret = modbus_set_response_timeout(modbus, T.sec, T.usec);
+
+    if (ret != 0) {
+        const std::string error_msg = modbus_strerror(errno);
+        throw std::runtime_error("modbus_receive failed: " + error_msg + ' ' + std::to_string(errno));
+    }
+}
+
+double Slave::get_byte_timeout() {
+    timeout_t timeout {};
+
+    auto ret = modbus_get_byte_timeout(modbus, &timeout.sec, &timeout.usec);
+
+    if (ret != 0) {
+        const std::string error_msg = modbus_strerror(errno);
+        throw std::runtime_error("modbus_receive failed: " + error_msg + ' ' + std::to_string(errno));
+    }
+
+    return static_cast<double>(timeout.sec) + (static_cast<double>(timeout.usec) / (1000.0 * 1000.0));
+}
+
+double Slave::get_response_timeout() {
+    timeout_t timeout {};
+
+    auto ret = modbus_get_response_timeout(modbus, &timeout.sec, &timeout.usec);
+
+    if (ret != 0) {
+        const std::string error_msg = modbus_strerror(errno);
+        throw std::runtime_error("modbus_receive failed: " + error_msg + ' ' + std::to_string(errno));
+    }
+
+    return static_cast<double>(timeout.sec) + (static_cast<double>(timeout.usec) / (1000.0 * 1000.0));
+}
+
 }  // namespace TCP
 }  // namespace Modbus

libs/libmodbus

@@ -26,9 +26,10 @@ class Slave {
      * @param port port to listen  for incoming connections (default 502)
      * @param mapping modbus mapping object (nullptr: an mapping object with maximum size is generated)
      */
-    explicit Slave(const std::string &ip      = "0.0.0.0",
-                   short unsigned int port    = 502,
-                   modbus_mapping_t  *mapping = nullptr);
+    explicit Slave(const std::string &ip          = "0.0.0.0",
+                   short unsigned int port        = 502,
+                   modbus_mapping_t  *mapping     = nullptr,
+                   std::size_t        tcp_timeout = 5);
 
     /*! \brief destroy the modbus slave
      *
@@ -43,15 +44,46 @@ class Slave {
 
     /*! \brief wait for client to connect
      *
+     * @return ip of the connected client
      */
-    void connect_client();
+    std::string connect_client();
 
     /*! \brief wait for request from Master and generate reply
      *
      * @return true: connection closed
      */
     bool handle_request();
 
+    /*!
+     * \brief set byte timeout
+     *
+     * @details see https://libmodbus.org/docs/v3.1.7/modbus_set_byte_timeout.html
+     *
+     * @param timeout byte timeout in seconds
+     */
+    void set_byte_timeout(double timeout);
+
+    /*!
+     * \brief set byte timeout
+     *
+     * @details see https://libmodbus.org/docs/v3.1.7/modbus_set_response_timeout.html
+     *
+     * @param timeout byte response in seconds
+     */
+    void set_response_timeout(double timeout);
+
+    /**
+     * \brief get byte timeout in seconds
+     * @return byte timeout
+     */
+    double get_byte_timeout();
+
+    /**
+     * \brief get response timeout in seconds
+     * @return response timeout
+     */
+    double get_response_timeout();
+
     /*! \brief get the modbus socket
      *
      * @return socket of the modbus connection