Merge pull request #4 from davirxavier/feature/scheduling

Feature/scheduling

Author: davirxavier

EmberChannelDefinition.h

@@ -34,6 +34,10 @@
 #ifndef EMBERCHANNELDEF_H
 #define EMBERCHANNELDEF_H
 
+#define EMBER_BUTTON_OFF 0
+#define EMBER_BUTTON_ON 1
+#define EMBER_BUTTON_PUSH 2
+
 class EmberIotProp
 {
 public:
@@ -66,6 +70,15 @@ class EmberIotProp
         return this->data;
     }
 
+    bool toButtonIsOn() const
+    {
+        return toInt() == EMBER_BUTTON_ON;
+    }
+
+    bool toButtonIsPush() const {
+        return toInt() == EMBER_BUTTON_PUSH;
+    }
+
     /**
      * True if the value itself has changed from the last emitted value.
      */
@@ -987,7 +1000,9 @@ EmberIotUpdateCallback callbacks[EMBER_CHANNEL_COUNT] = {
 #endif
 };
 
-#define EMBER_CHANNEL_CB(channel) \
-    void ember_channel_cb_##channel (const EmberIotProp &prop)
+// Macro indirection for forcing expansion, so users are able to use macros as a parameter to EMBER_CHANNEL_CB
+#define EMBER_CH_CB_IN(x) void ember_channel_cb_##x (const EmberIotProp &prop)
+#define EMBER_CH_CB_IN_INDIR(x) EMBER_CH_CB_IN(x)
+#define EMBER_CHANNEL_CB(x) EMBER_CH_CB_IN_INDIR(x)
 
 #endif

EmberIot.h

@@ -38,14 +38,10 @@
 #include <EmberIotUtil.h>
 #include <WithSecureClient.h>
 #include <EmberIotAuth.h>
-#include <EmberIotShared.h>
 #include <EmberIotStream.h>
 #include <time.h>
 
 #define UPDATE_LAST_SEEN_INTERVAL 120000
-#define EMBER_BUTTON_OFF 0
-#define EMBER_BUTTON_ON 1
-#define EMBER_BUTTON_PUSH 2
 
 /**
  * @param dbUrl Realtime database URL, without protocol and slashes at the end. Example value: my-rtdb.firebaseio.com
@@ -172,6 +168,8 @@ class EmberIot : WithSecureClient
             return;
         }
 
+        runPendingSchedules();
+
         uint8_t updateCount = 0;
         for (const bool i : hasUpdateByChannel)
         {
@@ -192,6 +190,14 @@ class EmberIot : WithSecureClient
 #endif
             if (result)
             {
+                for (size_t i = 0; i < EMBER_CHANNEL_COUNT; i++)
+                {
+                    if (hasUpdateByChannel[i])
+                    {
+                        snprintf(EmberIotChannels::lastValues[i], EMBER_MAXIMUM_STRING_SIZE, "%s", updateDataByChannel[i]);
+                    }
+                }
+
                 for (bool& i : hasUpdateByChannel)
                 {
                     i = false;
@@ -206,14 +212,29 @@ class EmberIot : WithSecureClient
         lastUpdatedChannels = millis();
     }
 
+    EmberIotProp getChannelLastValue(const int channel)
+    {
+        return EmberIotProp(EmberIotChannels::lastValues[channel], false);
+    }
+
+    /**
+     * Sets a callback to be executed when a scheduled action runs.
+     * @param scheduleId schedule id.
+     * @param callback function to be executed.
+     */
+    void setScheduleCallback(int scheduleId, EmberIotChannels::ScheduleJobCallback callback)
+    {
+        EmberIotChannels::setScheduleCallback(scheduleId, callback);
+    }
+
     /**
      * Writes a string to a data channel.
      * @param channel Channel number.
      * @param value Value to be written.
      */
     void channelWrite(uint8_t channel, const char* value)
     {
-        if (!checkChannelChanged(updateDataByChannel[channel], value))
+        if (hasUpdateByChannel[channel] && !checkChannelChanged(updateDataByChannel[channel], value))
         {
             return;
         }
@@ -291,6 +312,73 @@ class EmberIot : WithSecureClient
     }
 
 private:
+    void runPendingSchedules()
+    {
+        time_t now = time(nullptr);
+
+        for (size_t i = 0; i < EMBER_MAX_SCHEDULES; i++)
+        {
+            EmberIotChannels::ScheduleJob *job = EmberIotChannels::jobs[i];
+            if (job == nullptr || job->nextExecution < 0 || job->nextExecution > now || job->dataChannel < 0 || job->dataChannel >= EMBER_CHANNEL_COUNT)
+            {
+                continue;
+            }
+
+            char writtenData[EMBER_MAXIMUM_STRING_SIZE]{};
+            switch (tolower(job->mode))
+            {
+                case EmberIotChannels::JOB_MODE_DECREMENT:
+                case EmberIotChannels::JOB_MODE_INCREMENT:
+                    {
+                        double out;
+                        FirePropUtil::str2int_errno ret = FirePropUtil::str2double(&out, job->value);
+                        if (ret != FirePropUtil::STR2INT_SUCCESS)
+                        {
+                            EMBER_DEBUGF("Error parsing job value/str: %d/%s\n", ret, job->value);
+                            break;
+                        }
+
+                        double dataChannelValue;
+                        FirePropUtil::str2int_errno retChannel = FirePropUtil::str2double(&dataChannelValue, EmberIotChannels::lastValues[job->dataChannel]);
+                        if (retChannel == FirePropUtil::STR2INT_INCONVERTIBLE)
+                        {
+                            EMBER_DEBUGN("Current data in channel is inconvertible to a number, setting to schedule value.");
+                            channelWrite(job->dataChannel, job->value);
+                            snprintf(writtenData, sizeof(writtenData), "%s", job->value);
+                            break;
+                        }
+                        else if (retChannel != FirePropUtil::STR2INT_SUCCESS)
+                        {
+                            EMBER_DEBUGF("Error parsing data channel value/str: %d/%s\n", ret, EmberIotChannels::lastValues[job->dataChannel]);
+                            break;
+                        }
+
+                        double newValue = job->mode == EmberIotChannels::JOB_MODE_INCREMENT ? dataChannelValue + out : dataChannelValue - out;
+                        channelWrite(job->dataChannel, newValue);
+                        snprintf(writtenData, sizeof(writtenData), "%lf", newValue);
+                        break;
+                    }
+            default:
+                {
+                    channelWrite(job->dataChannel, job->value);
+                    snprintf(writtenData, sizeof(writtenData), "%s", job->value);
+                }
+            }
+
+            EmberIotChannels::updateScheduleNextExecution(job->scheduleId);
+
+            if (EmberIotChannels::jobCallbacks[job->scheduleId] != nullptr)
+            {
+                EmberIotChannels::jobCallbacks[job->scheduleId](job);
+            }
+
+            if (strlen(writtenData) > 0)
+            {
+                EmberIotChannels::callChannelUpdate(job->dataChannel, writtenData, "sched");
+            }
+        }
+    }
+
     bool checkChannelChanged(const char *lastVal, const char *newVal)
     {
         if (lastVal != nullptr && newVal == nullptr)

EmberIotNotifications.h

@@ -197,7 +197,8 @@ class FCMEmberNotifications
             return;
         }
 
-        if (!FirePropUtil::isTimeInitialized() || clientPtr == nullptr)
+
+        if (WiFi.status() != WL_CONNECTED || !FirePropUtil::isTimeInitialized() || clientPtr == nullptr)
         {
             return;
         }
@@ -393,6 +394,7 @@ class FCMEmberNotifications
 #endif
 
         HTTP_LOGN("Send pending notifications.");
+        unsigned long timeCounter = 0;
 
         EmberIotNotification notif = notificationQueue[currentNotification-1];
 
@@ -503,7 +505,7 @@ class FCMEmberNotifications
 
         if (HTTP_UTIL::isSuccess(responseStatus))
         {
-            HTTP_LOGN("Notification sent successfully.");
+            HTTP_LOGF("Notification sent successfully, time taken: %lu\n", millis() - timeCounter);
             currentNotification--;
         }
         else