led class refactor

lib/GPIO/LED_Driver.cpp

@@ -10,8 +10,8 @@ namespace drivers
     {
         LOG_INFO("Inizializing RGB Led");
         pinMode(c_ledPin, OUTPUT);
-        m_lp.pin = c_ledPin;
+        m_blinkTask = NULL;
-        m_lp.blinkTask = NULL;
+        m_flashTimer = NULL;
     }
 
     Led::~Led()
@@ -22,54 +22,85 @@ namespace drivers
 
     void Led::setColor(const color_t color)
     {
+        std::lock_guard<std::mutex> lock(m_ledMutex);
         blinkStop();
+        m_colorDefault = color;
         rgbLedWrite(c_ledPin, color.g, color.r, color.b);
     }
 
+    void Led::flashHandle(TimerHandle_t th)
+    {
+        Led *led = (Led *)pvTimerGetTimerID(th);
+        std::lock_guard<std::mutex> lock(led->m_ledMutex);
+        rgbLedWrite(led->c_ledPin, led->m_colorDefault.g, led->m_colorDefault.r, led->m_colorDefault.b); // reset color to saved color
+        LOG_DEBUG("Led Flash timer expired");
+        xTimerDelete(th, 0);
+        led->m_flashTimer = NULL;
+    }
+
+    void Led::flashColor(const uint16_t tOn, const color_t color)
+    {
+        std::lock_guard<std::mutex> lock(m_ledMutex);
+        if (m_flashTimer == NULL)
+        {
+            blinkStop();
+            rgbLedWrite(c_ledPin, color.g, color.r, color.b); // set color to flash
+            m_flashTimer = xTimerCreate("flasher", pdMS_TO_TICKS(tOn), pdFALSE, this, flashHandle);
+            xTimerStart(m_flashTimer, 0);
+            LOG_DEBUG("Led Flash timer created");
+        }
+    }
+
     void Led::blinkColor(const uint16_t tOn, const uint16_t tOff, const color_t color)
     {
+        std::lock_guard<std::mutex> lock(m_ledMutex);
         blinkStop();
-        m_lp.color1 = color;
+        m_color1 = color;
-        m_lp.color2 = {0, 0, 0};
+        m_color2 = {0, 0, 0};
-        m_lp.tOn = tOn;
+        m_tOn = tOn;
-        m_lp.tOff = tOff;
+        m_tOff = tOff;
-        xTaskCreate(blinkTask, "blinker", TASK_STACK, static_cast<void *>(&m_lp), TASK_PRIORITY, &m_lp.blinkTask);
+        xTaskCreate(blinkTask, "blinker", TASK_STACK, this, TASK_PRIORITY, &m_blinkTask);
     }
 
     void Led::blinkAlternate(const uint16_t tOn, const uint16_t tOff, const color_t color1, const color_t color2)
     {
-        {
+        std::lock_guard<std::mutex> lock(m_ledMutex);
-            blinkStop();
+        blinkStop();
-            m_lp.color1 = color1;
+        m_color1 = color1;
-            m_lp.color2 = color2;
+        m_color2 = color2;
-            m_lp.tOn = tOn;
+        m_tOn = tOn;
-            m_lp.tOff = tOff;
+        m_tOff = tOff;
-            xTaskCreate(blinkTask, "blinker", TASK_STACK, static_cast<void *>(&m_lp), TASK_PRIORITY, &m_lp.blinkTask);
+        xTaskCreate(blinkTask, "blinker", TASK_STACK, this, TASK_PRIORITY, &m_blinkTask);
-        }
     }
 
     void Led::blinkStop()
     {
-        if (m_lp.blinkTask != NULL)
+        if (m_blinkTask != NULL)
-            vTaskDelete(m_lp.blinkTask);
+            vTaskDelete(m_blinkTask);
-        m_lp.blinkTask = NULL;
+        m_blinkTask = NULL;
     }
 
     void Led::blinkTask(void *params)
     {
+        Led *led = static_cast<Led *>(params);
         LOG_DEBUG("Blinker Task Created");
-        led_params_t *lPar = static_cast<led_params_t *>(params);
         while (true)
         {
-            rgbLedWrite(lPar->pin, lPar->color1.g, lPar->color1.r, lPar->color1.b);
+            {
-            delay(lPar->tOn);
+                std::lock_guard<std::mutex> lock(led->m_ledMutex);
-            rgbLedWrite(lPar->pin, lPar->color2.g, lPar->color2.r, lPar->color2.b); // off
+                rgbLedWrite(led->c_ledPin, led->m_color1.g, led->m_color1.r, led->m_color1.b);
-            if (lPar->tOff == 0)
+            }
+            delay(led->m_tOn);
+            {
+                std::lock_guard<std::mutex> lock(led->m_ledMutex);
+                rgbLedWrite(led->c_ledPin, led->m_color2.g, led->m_color2.r, led->m_color2.b); // off
+            }
+            if (led->m_tOff == 0)
                 break;
-            delay(lPar->tOff);
+            delay(led->m_tOff);
         }
         LOG_DEBUG("Blinker Task Ended");
-        lPar->blinkTask = NULL;
+        led->m_blinkTask = NULL;
         vTaskDelete(NULL);
     }
 }

lib/GPIO/LED_Driver.h

@@ -5,21 +5,22 @@
 #define DEBUGLOG_DEFAULT_LOG_LEVEL_INFO
 #include <DebugLog.h>
 
+#include <mutex>
+
 namespace drivers
 {
 
     class Led
     {
-        const uint8_t c_ledPin = 38;
+        
-
+        public:
-    public:
         typedef struct
         {
             uint8_t r;
             uint8_t g;
             uint8_t b;
         } color_t;
-
+        
         const color_t COLOR_RED = {255, 0, 0};
         const color_t COLOR_ORANGE = {255, 127, 0};
         const color_t COLOR_YELLOW = {255, 255, 0};
@@ -30,32 +31,35 @@ namespace drivers
         const color_t COLOR_BLUE = {0, 0, 255};
         const color_t COLOR_VIOLET = {127, 0, 255};
         const color_t COLOR_MAGENTA = {255, 0, 255};
-
+        
-    private:
+        public:
-        typedef struct
-        {
-            color_t color1;
-            color_t color2;
-            uint8_t pin;
-            uint16_t tOn;
-            uint16_t tOff;
-            TaskHandle_t blinkTask;
-        } led_params_t;
-
-    public:
         Led();
         ~Led();
-
+        
         void setColor(const color_t color);
+        void flashColor(const uint16_t tOn, const color_t color);
         void blinkColor(const uint16_t tOn, const uint16_t tOff, const color_t color);
         void blinkAlternate(const uint16_t tOn, const uint16_t tOff, const color_t color1, const color_t color2);
         void blinkStop();
-
+        
-    private:
+        private:
+        static void flashHandle(TimerHandle_t th);
         static void blinkTask(void *params);
+        
+        private:
+        const uint8_t c_ledPin = 38;
+        
+        color_t m_color1;
+        color_t m_color2;
+        color_t m_colorDefault;
 
-    private:
+        uint16_t m_tOn;
-        led_params_t m_lp;
+        uint16_t m_tOff;
+
+        TaskHandle_t m_blinkTask;
+        TimerHandle_t m_flashTimer;
+
+        std::mutex m_ledMutex;
     };
 
 }

src/main.cpp

@@ -83,12 +83,14 @@ void loop()
 
   MQTTwrapper::MessageCallback onMessage = [&devices](const MQTTwrapper::Topic &topic, const MQTTwrapper::Message &message)
   {
-    // devices.led.flashColor(250, devices.led.COLOR_BLUE);
+    LOG_INFO("onMessage callback [", topic.c_str(),"]");
+    devices.led.flashColor(250, devices.led.COLOR_YELLOW);
   };
-
+  
   MQTTwrapper::MessageCallback onPublish = [&devices](const MQTTwrapper::Topic &topic, const MQTTwrapper::Message &message)
   {
-    // devices.led.flashColor(250, devices.led.COLOR_ORANGE);
+    LOG_INFO("onPublish callback [", topic.c_str(),"]");
+    devices.led.flashColor(250, devices.led.COLOR_BLUE);
   };
 
   /////////////   CRONJOB  //////////////