Merge pull request #12 from NikolasK-source/feature_clientid

Feature: Option to create separate shared memory for selected client ids

Author: NikolasK-source

.github/workflows/cmake.yml

@@ -2,7 +2,6 @@ name: CMake
 
 on:
   push:
-    branches: [ "main", "development" ]
   pull_request:
     branches: [ "main" ]
 

.github/workflows/codeql-analysis.yml

@@ -13,7 +13,7 @@ name: "CodeQL"
 
 on:
   push:
-    branches: [ "main", "development" ]
+    branches: [ "main", "release" ]
   pull_request:
     # The branches below must be a subset of the branches above
     branches: [ "main" ]

.github/workflows/flatpak_test.yml

@@ -1,7 +1,5 @@
 on:
-  push:
-    branches: [ "main", "development" ]
-  pull_request:
+  [ push, pull_request ]
 name: Flatpak_test
 jobs:
   flatpak:
@@ -27,4 +25,4 @@ jobs:
       with:
         bundle: test_modbus-tcp-client-shm.flatpak
         manifest-path: network.koesling.test-modbus-tcp-client-shm.yml
-        cache-key: flatpak-builder-${{ github.sha }}
+        cache-key: flatpak-builder-${{ github.sha }}

src/Modbus_TCP_Slave.cpp

@@ -16,6 +16,8 @@
 #include <system_error>
 #include <unistd.h>
 
+#include <iostream>
+
 namespace Modbus {
 namespace TCP {
 
@@ -29,21 +31,74 @@ Slave::Slave(const std::string &ip, unsigned short port, modbus_mapping_t *mappi
         throw std::runtime_error("failed to create modbus instance: " + error_msg);
     }
 
+    modbus_mapping_t *mb_mapping;
+
     if (mapping == nullptr) {
         // create new mapping with the maximum number of registers
-        this->mapping = modbus_mapping_new(MAX_REGS, MAX_REGS, MAX_REGS, MAX_REGS);
-        if (this->mapping == nullptr) {
+        mb_mapping = modbus_mapping_new(MAX_REGS, MAX_REGS, MAX_REGS, MAX_REGS);
+        if (mb_mapping == nullptr) {
             const std::string error_msg = modbus_strerror(errno);
             modbus_free(modbus);
             throw std::runtime_error("failed to allocate memory: " + error_msg);
         }
-        delete_mapping = true;
+        delete_mapping = mapping;
     } else {
         // use the provided mapping object
-        this->mapping  = mapping;
-        delete_mapping = false;
+        mb_mapping     = mapping;
+        delete_mapping = nullptr;
+    }
+
+    // use mapping for all client ids
+    for (std::size_t i = 0; i < MAX_CLIENT_IDS; ++i) {
+        this->mappings[i] = mapping;
+    }
+
+    listen();
+
+#ifdef OS_LINUX
+    if (tcp_timeout) set_tcp_timeout(tcp_timeout);
+#else
+    static_cast<void>(tcp_timeout);
+#endif
+}
+
+Slave::Slave(const std::string &ip, unsigned short port, modbus_mapping_t **mappings, std::size_t tcp_timeout) {
+    // create modbus object
+    modbus = modbus_new_tcp(ip.c_str(), static_cast<int>(port));
+    if (modbus == nullptr) {
+        const std::string error_msg = modbus_strerror(errno);
+        throw std::runtime_error("failed to create modbus instance: " + error_msg);
     }
 
+    delete_mapping = nullptr;
+
+    for (std::size_t i = 0; i < MAX_CLIENT_IDS; ++i) {
+        if (mappings[i] == nullptr) {
+            if (delete_mapping == nullptr) {
+                delete_mapping = modbus_mapping_new(MAX_REGS, MAX_REGS, MAX_REGS, MAX_REGS);
+
+                if (delete_mapping == nullptr) {
+                    const std::string error_msg = modbus_strerror(errno);
+                    modbus_free(modbus);
+                    throw std::runtime_error("failed to allocate memory: " + error_msg);
+                }
+            }
+            this->mappings[i] = delete_mapping;
+        } else {
+            this->mappings[i] = mappings[i];
+        }
+    }
+
+    listen();
+
+#ifdef OS_LINUX
+    if (tcp_timeout) set_tcp_timeout(tcp_timeout);
+#else
+    static_cast<void>(tcp_timeout);
+#endif
+}
+
+void Slave::listen() {
     // create tcp socket
     socket = modbus_tcp_listen(modbus, 1);
     if (socket == -1) {
@@ -58,48 +113,47 @@ Slave::Slave(const std::string &ip, unsigned short port, modbus_mapping_t *mappi
     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");
-        }
+void Slave::set_tcp_timeout(std::size_t tcp_timeout) {
+    // set user timeout (~= timeout for tcp connection)
+    unsigned user_timeout = static_cast<unsigned>(tcp_timeout) * 1000;
+    int      tmp          = setsockopt(socket, IPPROTO_TCP, TCP_USER_TIMEOUT, &user_timeout, sizeof(tcp_timeout));
+    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");
-        }
+    // 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");
-        }
+    // 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");
-        }
+    // 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
 }
+#endif
+
 
 Slave::~Slave() {
     if (modbus != nullptr) {
         modbus_close(modbus);
         modbus_free(modbus);
     }
-    if (mapping != nullptr && delete_mapping) modbus_mapping_free(mapping);
+    if (delete_mapping) modbus_mapping_free(delete_mapping);
     if (socket != -1) { close(socket); }
 }
 
@@ -141,6 +195,11 @@ bool Slave::handle_request() {
     int     rc = modbus_receive(modbus, query);
 
     if (rc > 0) {
+        const auto CLIENT_ID = query[6];
+
+        // get mapping
+        auto mapping = mappings[CLIENT_ID];
+
         // handle request
         int ret = modbus_reply(modbus, query, rc, mapping);
         if (ret == -1) {

src/Modbus_TCP_Slave.hpp

@@ -7,30 +7,49 @@
 
 #include <modbus/modbus.h>
 #include <string>
+#include <unordered_map>
 
 namespace Modbus {
 namespace TCP {
 
+constexpr std::size_t MAX_CLIENT_IDS = 256;
+
 //! Modbus TCP slave
 class Slave {
 private:
-    modbus_t         *modbus;          //!< modbus object (see libmodbus library)
-    modbus_mapping_t *mapping;         //!< modbus data object (see libmodbus library)
-    bool              delete_mapping;  //!< indicates whether the mapping object was created by this instance
-    int               socket = -1;     //!< socket of the modbus connection
+    modbus_t *modbus;  //!< modbus object (see libmodbus library)
+    modbus_mapping_t
+            *mappings[MAX_CLIENT_IDS];  //!< modbus data objects (one per possible client id) (see libmodbus library)
+    modbus_mapping_t *delete_mapping;   //!< contains a pointer to a mapping that is to be deleted
+    int               socket = -1;      //!< socket of the modbus connection
 
 public:
     /*! \brief create modbus slave (TCP server)
      *
      * @param ip ip to listen for incoming connections (default 0.0.0.0 (any))
      * @param port port to listen  for incoming connections (default 502)
-     * @param mapping modbus mapping object (nullptr: an mapping object with maximum size is generated)
+     * @param mapping modbus mapping object for all client ids
+     *                nullptr: an mapping object with maximum size is generated
+     * @param tcp_timeout tcp timeout (currently only available on linux systems)
      */
     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 create modbus slave (TCP server) with dedicated mappings per client id
+     *
+     * @param ip ip to listen for incoming connections
+     * @param port port to listen  for incoming connections
+     * @param mappings modbus mappings (one for each possible id)
+     * @param tcp_timeout tcp timeout (currently only available on linux systems)
+     */
+    Slave(const std::string &ip,
+          short unsigned int port,
+          modbus_mapping_t  *mappings[MAX_CLIENT_IDS],
+          std::size_t        tcp_timeout = 5);
+
     /*! \brief destroy the modbus slave
      *
      */
@@ -89,6 +108,13 @@ class Slave {
      * @return socket of the modbus connection
      */
     [[nodiscard]] int get_socket() const noexcept { return socket; }
+
+private:
+#ifdef OS_LINUX
+    void set_tcp_timeout(std::size_t tcp_timeout);
+#endif
+
+    void listen();
 };
 
 }  // namespace TCP