periodic polling

protocol/artistic/artnet/controller.cpp

@@ -27,9 +27,50 @@
 namespace ARTNET {
 
 Controller::Controller()
+    : minimum_polling_interval(2500)
+    , _periodic_polling_enabled(true)
+    , _pollster(std::thread(&Controller::_periodic_polling, this))
+    , _talktome_request()
+    , _priority_request(DpCritial)
 {
 }
 
+Controller::~Controller()
+{
+    if (_pollster.joinable())
+    {
+        _periodic_polling_enabled = false;  // disable
+        {
+            std::shared_lock lk_ctl(_mtx_poll_control);
+            _poll_request.notify_all();     // wake-up
+        }
+        _pollster.join();
+    }
+}
+
+
+/**
+ * @brief Controller::setTalkToMeRequest
+ * @param talktome
+ */
+void Controller::setTalkToMeRequest(TalkToMe talktome)
+{
+    std::unique_lock lk_ctl(_mtx_poll_control);
+    _talktome_request = talktome;
+}
+
+
+/**
+ * @brief Controller::setPriorityRequest
+ * @param priority
+ */
+void Controller::setPriorityRequest(Priority priority)
+{
+    std::unique_lock lk_ctl(_mtx_poll_control);
+    _priority_request = priority;
+}
+
+
 /**
  * @brief Controller::txArtPoll
  * @param talkToMe
@@ -44,4 +85,32 @@ void Controller::txArtPoll(TalkToMe talkToMe, Priority priority) const
     send(packet, broadcastIp());
 }
 
+
+void Controller::_periodic_polling()
+{
+    std::chrono::system_clock::time_point last_send = std::chrono::system_clock::from_time_t(0);
+    std::chrono::nanoseconds elapsed;
+    std::unique_lock lk_thread(_mtx_poll_thread);
+    TalkToMe talktome;
+    Priority priority;
+
+    while (_periodic_polling_enabled) {
+        // enforce strict minimum update times
+        elapsed = std::chrono::system_clock::now() - last_send;
+        if (elapsed < minimum_polling_interval)
+            std::this_thread::sleep_for(minimum_polling_interval - elapsed);
+
+        {
+            std::unique_lock lk_ctl(_mtx_poll_control);
+            talktome = _talktome_request;
+            priority = _priority_request;
+        }
+        txArtPoll(talktome, priority);
+        last_send = std::chrono::system_clock::now();
+
+        // sleep before the next cycle
+        _poll_request.wait_for(lk_thread, minimum_polling_interval);
+    }
+}
+
 } // namespace ARTNET

protocol/artistic/artnet/controller.h

@@ -25,6 +25,10 @@
 
 #include "device.h"
 #include "gateway.h"
+#include <atomic>
+#include <condition_variable>
+#include <shared_mutex>
+#include <thread>
 
 namespace ARTNET {
 
@@ -39,10 +43,26 @@ class Controller
     , public InputGateway
 {
 public:
-  explicit Controller();
+    explicit Controller();
+    virtual ~Controller();
+
+    void setTalkToMeRequest(TalkToMe);
+    void setPriorityRequest(Priority);
 
 protected:
-  virtual void txArtPoll(TalkToMe = TalkToMe(), Priority = DpCritial) const;
+    virtual void txArtPoll(TalkToMe = TalkToMe(), Priority = DpCritial) const;
+
+private:
+    const std::chrono::milliseconds minimum_polling_interval;
+    mutable std::shared_mutex _mtx_poll_control;
+    mutable std::mutex _mtx_poll_thread;
+    std::atomic<bool> _periodic_polling_enabled;
+    std::condition_variable_any _poll_request;
+    std::thread _pollster;
+    void _periodic_polling();
+
+    TalkToMe _talktome_request;             //!< TalkToMe to be uses in the ArtPoll
+    Priority _priority_request;             //!< Priority to be used in the ArtPoll
 };
 
 } // namespace ARTNET