print set timeout values

Author: NikolasK-source

src/Modbus_TCP_Slave.cpp

@@ -92,19 +92,19 @@ struct timeout_t {
 };
 
 static inline timeout_t double_to_timeout_t(double timeout) {
-    timeout_t ret{};
+    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);
+    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);
+    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);
@@ -113,14 +113,40 @@ void Slave::set_byte_timeout(double timeout) {
 }
 
 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);
+    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

src/Modbus_TCP_Slave.hpp

@@ -14,7 +14,7 @@ namespace TCP {
 //! Modbus TCP slave
 class Slave {
 private:
-    modbus_t         *modbus;          //!< modbus object (see libmodbus library)
+    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
@@ -28,7 +28,7 @@ class Slave {
      */
     explicit Slave(const std::string &ip      = "0.0.0.0",
                    short unsigned int port    = 502,
-                   modbus_mapping_t  *mapping = nullptr);
+                   modbus_mapping_t * mapping = nullptr);
 
     /*! \brief destroy the modbus slave
      *
@@ -70,6 +70,18 @@ class Slave {
      */
     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

src/main.cpp

@@ -189,18 +189,18 @@ int main(int argc, char **argv) {
 
     // set timeouts if required
     try {
-        if (args.count("response-timeout")) {
-            slave->set_response_timeout(args["response-timeout"].as<double>());
-        }
+        if (args.count("response-timeout")) { slave->set_response_timeout(args["response-timeout"].as<double>()); }
 
-        if (args.count("byte-timeout")) {
-            slave->set_response_timeout(args["byte-timeout"].as<double>());
-        }
+        if (args.count("byte-timeout")) { slave->set_response_timeout(args["byte-timeout"].as<double>()); }
     } catch (const std::runtime_error &e) {
         std::cerr << e.what() << std::endl;
         exit(EX_SOFTWARE);
     }
 
+    // print timeouts
+    std::cerr << "    Byte timeout: " << slave->get_byte_timeout() << "s" << std::endl;
+    std::cerr << "Response timeout: " << slave->get_response_timeout() << "s" << std::endl;
+
     // connection loop
     do {
         // connect client

src/modbus_shm.hpp

@@ -26,7 +26,7 @@ class Shm_Mapping {
         std::string name = std::string();  //!< name of the object
         int         fd   = -1;             //!< file descriptor
         std::size_t size;                  //!< size in bytes
-        void       *addr = nullptr;        //!< mapped address
+        void *      addr = nullptr;        //!< mapped address
     };
 
     //! modbus lib storage object