add an offset and thus a global mesh time, schedule sleep and awake using global mesh time instead of local uptime

Author: jacobrosenthal

src/Shell.cpp

@@ -223,13 +223,16 @@ static StringBuffer uptimeReportHQ(void) {
   strncpy_P(reset, Scout.getLastResetCause(), sizeof(reset));
   reset[sizeof(reset) - 1] = 0; // ensure termination, strncpy is weird
 
-  report.appendSprintf("[%d,[%d,%d,%d,%d],[%ld,%ld,%d,",keyMap("uptime",0),
+  report.appendSprintf("[%d,[%d,%d,%d,%d,%d],[%ld,%ld,%ld,%d,",
+          keyMap("uptime",0),
           keyMap("total", 0),
           keyMap("sleep", 0),
+          keyMap("meshsleep", 0),
           keyMap("random", 0),
           keyMap("reset", 0),
           SleepHandler::uptime().seconds,
           SleepHandler::sleeptime().seconds,
+          SleepHandler::meshsleeptime().seconds,
           (int)random());
 
   report.appendJsonString(reset, true);
@@ -291,9 +294,40 @@ static numvar uptimeStatus(void) {
   appendTime(out, SleepHandler::sleeptime());
   speol(out.c_str());
 
+  out = F("Global: ");
+  appendTime(out, SleepHandler::meshtime());
+  speol(out.c_str());
   return true;
 }
 
+static numvar uptimeSetOffset(void) {
+  if (!checkArgs(3, F("usage: uptime.setoffset(seconds, micros, inFuture)"))) {
+    return 0;
+  }
+
+  uint32_t seconds = getarg(1);
+  uint32_t us = getarg(2);
+
+  Duration d;
+  d.seconds = seconds;
+  d.us = us;
+
+  bool future = getarg(3);
+
+  SleepHandler::setOffsetInFuture(future);
+  SleepHandler::setOffset(d);
+
+  return 1;
+}
+
+static numvar uptimeMeshOffsetMicros(void) {
+  return SleepHandler::getOffset().us;
+}
+
+static numvar uptimeMeshOffsetSeconds(void) {
+  return SleepHandler::getOffset().seconds;
+}
+
 static numvar uptimeMeshSleepingMicros(void) {
   return SleepHandler::meshsleeptime().us;
 }
@@ -2504,10 +2538,14 @@ void PinoccioShell::setup() {
   addFunction("uptime.getlastreset", getLastResetCause);
   addFunction("uptime.status", uptimeStatus);
   addFunction("uptime", uptimeStatus);
+  addFunction("uptime.setoffset", uptimeSetOffset);
 
   addFunction("uptime.meshsleeping.micros", uptimeMeshSleepingMicros);
   addFunction("uptime.meshsleeping.seconds", uptimeMeshSleepingSeconds);
 
+  addFunction("uptime.meshoffset.micros", uptimeMeshOffsetMicros);
+  addFunction("uptime.meshoffset.seconds", uptimeMeshOffsetSeconds);
+
   addFunction("led.on", ledTorch); // alias
   addFunction("led.off", ledOff);
   addFunction("led.red", ledRed);

src/SleepHandler.cpp

@@ -13,12 +13,26 @@ uint32_t SleepHandler::meshSleepStart = 0;
 radio_state_t SleepHandler::radioState = RF_AWAKE;
 uint32_t SleepHandler::sleepPeriod = 100;
 uint32_t SleepHandler::wakePeriod = 100;
+Duration SleepHandler::meshOffset = {0, 0};
+boolean SleepHandler::offsetInFuture = true;
 
 // Returns the time mesh slept since startup
 const Duration& SleepHandler::meshsleeptime() {
   return meshSleep;
 }
 
+const Duration& SleepHandler::getOffset(){
+  return meshOffset;
+}
+
+void SleepHandler::setOffset(Duration d){
+  meshOffset = d;
+}
+
+void SleepHandler::setOffsetInFuture(bool future){
+  offsetInFuture = future;
+}
+
 Pbbe::LogicalPin::mask_t SleepHandler::pinWakeups = 0;
 
 ISR(SCNT_CMP3_vect) {
@@ -116,11 +130,11 @@ void SleepHandler::loop() {
   switch (radioState) {
     case RF_SHOULD_SLEEP:
       sleepRadio();
-      scheduleWakeRadio(uptime() + (uint64_t)(sleepPeriod * 1000));
+      scheduleWakeRadio(meshtime() + (uint64_t)(sleepPeriod * 1000));
       break;
     case RF_SHOULD_WAKE:
       wakeRadio();
-      scheduleSleepRadio(uptime() + (uint64_t)(wakePeriod * 1000));
+      scheduleSleepRadio(meshtime() + (uint64_t)(wakePeriod * 1000));
       break;
     default:
       // RF_WILL_SLEEP, RF_WILL_WAKE, RF_SLEEPING, RF_AWAKE
@@ -231,15 +245,15 @@ void SleepHandler::scheduleSleepRadio(Duration future) {
   // todo handle microseconds too
   // todo calculate off of an uptime + offset
   radioState = RF_WILL_SLEEP;
-  setTimer2((future.seconds - uptime().seconds) * 1000);
+  setTimer2((future.seconds - meshtime().seconds) * 1000);
 }
 
 void SleepHandler::scheduleWakeRadio(Duration future) {
   // todo check its in the future
   // todo handle microseconds too
   // todo calculate off of an uptime + offset
   radioState = RF_WILL_WAKE;
-  setTimer2((future.seconds - uptime().seconds) * 1000);
+  setTimer2((future.seconds - meshtime().seconds) * 1000);
 }
 
 // TODO take a few ticks off the schedule as it takes us some amount of

src/SleepHandler.h

@@ -12,6 +12,11 @@ ISR(SCNT_OVFL_vect);
 
 class SleepHandler {
   public:
+
+    static void setOffset(Duration d);
+    static void setOffsetInFuture(bool future);
+
+    static const Duration& getOffset();
     static const Duration& meshsleeptime();
 
     static bool getMatch();
@@ -94,7 +99,21 @@ class SleepHandler {
       return uptime() - totalSleep;
     }
 
+    // Returns the local authority's time
+    static Duration meshtime() {
+      if(offsetInFuture)
+        return uptime() + meshOffset;
+      else
+        return uptime() - meshOffset;
+    }
+
   protected:
+
+    // The mesh offset
+    static Duration meshOffset;
+    // The offset direction, forward is true, backward is false
+    static bool offsetInFuture;
+
     static radio_state_t radioState;
     static uint32_t sleepPeriod;
     static uint32_t wakePeriod;

src/util/Duration.h

@@ -40,6 +40,18 @@ class Duration {
 
       return result;
     }
+
+    Duration operator +(Duration d) {
+      Duration result(*this);
+      result.seconds += d.seconds;
+      result.us += d.us;
+      if (result.us > 1000000) {
+        result.us -= 1000000;
+        result.seconds++;
+      }
+
+      return result;
+    }
 };
 
 #endif // LIB_PINOCCIO_DURATION_H