add sleep mode code

mini-beieli-node.ino

@@ -25,7 +25,7 @@
 #include <cmath>
 #include <type_traits>
 
-#include <HX711.h>
+#include <Q2HX711.h>
 #include "mini_beieli_node.h"
 
 using namespace McciCatena;
@@ -132,7 +132,7 @@ Catena_Mx25v8035f gFlash;
 bool fFlash;
 
 // Scales
-HX711 LoadCell;
+Q2HX711 hx711(A1, A0);
 
 //  USB power
 bool fUsbPower;
@@ -144,6 +144,11 @@ bool g_fPrintedSleeping = false;
 static osjob_t iterationJob;
 static osjob_t sendJob;
 
+// the cycle time to use
+unsigned gTxCycle;
+// remaining before we reset to default
+unsigned gTxCycleCount;
+
 void setup(void)
 {
   gCatena.begin();
@@ -302,18 +307,8 @@ bool setup_scales(void)
   // Enable Power
   digitalWrite(D10, HIGH);
 
-  // Initialize library with data output pin, clock input pin and gain factor.
+  // we wait 400ms (settling time according HX711 datasheet @ 10 SPS
-  // Channel selection is made by passing the appropriate gain:
+  delay(400);
-  // - With a gain factor of 64 or 128, channel A is selected
-  // - With a gain factor of 32, channel B is selected
-  // By omitting the gain factor parameter, the library
-  // default "128" (Channel A) is used here.
-  LoadCell.begin(A1, A0, 32);
-
-  if (!(LoadCell.wait_ready_timeout(2000))) {
-    gCatena.SafePrintf("%010d - Scale not ready after Init.\n");
-    res = false;
-  }
 
   if (config_data.debug_level > 0) {
     gCatena.SafePrintf("%010d - setup_scale done\n", millis());
@@ -351,7 +346,7 @@ void setup_uplink(void)
     gCatena.SafePrintf("%010d - setup_uplink\n", millis());
   }
 
-  LMIC_setClockError(1*65536/100);  
+  LMIC_setClockError(1 * 65536 / 100);
 
   /* figure out when to reboot */
   gRebootMs = (CATCFG_T_REBOOT + os_getRndU2() - 32768) * 1000;
@@ -576,7 +571,7 @@ void bubbleSort(long A[], int len) {
 
 long my_read_average(byte gain, byte times) {
   long res;
-  int const num_scale_readings = 25; // number of instantaneous scale readings to calculate the median
+  int const num_scale_readings = 50; // number of instantaneous scale readings to calculate the median
 
   // we use the median, not the average, see https://community.particle.io/t/boron-gpio-provides-less-current-than-electrons-gpio/46647/13
   long readings[num_scale_readings];  // create arry to hold readings
@@ -585,12 +580,10 @@ long my_read_average(byte gain, byte times) {
     gCatena.SafePrintf("%010d - my_read_average, measurements: ", millis());
   }
 
-  LoadCell.set_gain(gain);
+  hx711.setGain(gain);
-  // we wait 400ms (settling time according HX711 datasheet @ 10 SPS
-  delay(400);
 
   for (int i = 0; i < num_scale_readings; i++) {
-    readings[i] = LoadCell.read();  // fill the array with instantaneous readings from the scale
+    readings[i] = hx711.read();  // fill the array with instantaneous readings from the scale
   }
 
   res = median(readings, num_scale_readings); // calculate median
@@ -906,6 +899,8 @@ static void txNotProvisionedCb(
 static void settleDoneCb(
   osjob_t* pSendJob)
 {
+  const bool fDeepSleep = checkDeepSleep();
+
   if (config_data.debug_level > 0) {
     gCatena.SafePrintf("%010d - settleDoneCb\n", millis());
   }
@@ -926,7 +921,186 @@ static void settleDoneCb(
     NVIC_SystemReset();
   }
 
-  sleepDoneCb(pSendJob);
+  if (! g_fPrintedSleeping)
+    doSleepAlert(fDeepSleep);
+
+  /* count what we're up to */
+  updateSleepCounters();
+
+  if (fDeepSleep)
+    doDeepSleep(pSendJob);
+  else
+    doLightSleep(pSendJob);
+}
+
+bool checkDeepSleep(void)
+{
+  bool const fDeepSleepTest = gCatena.GetOperatingFlags() &
+                              static_cast<uint32_t>(gCatena.OPERATING_FLAGS::fDeepSleepTest);
+  bool fDeepSleep;
+
+  if (fDeepSleepTest)
+  {
+    fDeepSleep = true;
+  }
+#ifdef USBCON
+  else if (Serial.dtr())
+  {
+    fDeepSleep = false;
+  }
+#endif
+  else if (gCatena.GetOperatingFlags() &
+           static_cast<uint32_t>(gCatena.OPERATING_FLAGS::fDisableDeepSleep))
+  {
+    fDeepSleep = false;
+  }
+  else if ((gCatena.GetOperatingFlags() &
+            static_cast<uint32_t>(gCatena.OPERATING_FLAGS::fUnattended)) != 0)
+  {
+    fDeepSleep = true;
+  }
+  else
+  {
+    fDeepSleep = false;
+  }
+
+  return fDeepSleep;
+}
+
+void doSleepAlert(const bool fDeepSleep)
+{
+  g_fPrintedSleeping = true;
+
+  if (fDeepSleep)
+  {
+    bool const fDeepSleepTest = gCatena.GetOperatingFlags() &
+                                static_cast<uint32_t>(gCatena.OPERATING_FLAGS::fDeepSleepTest);
+    const uint32_t deepSleepDelay = fDeepSleepTest ? 10 : 30;
+    if (config_data.debug_level > 2) {
+      gCatena.SafePrintf("using deep sleep in %u secs"
+#ifdef USBCON
+                         " (USB will disconnect while asleep)"
+#endif
+                         ": ",
+                         deepSleepDelay
+                        );
+
+    }
+    // sleep and print
+    if (config_data.debug_level > 2) {
+      gLed.Set(LedPattern::TwoShort);
+    }
+
+    for (auto n = deepSleepDelay; n > 0; --n)
+    {
+      uint32_t tNow = millis();
+
+      while (uint32_t(millis() - tNow) < 1000)
+      {
+        gCatena.poll();
+        yield();
+      }
+      if (config_data.debug_level > 2) {
+        gCatena.SafePrintf(".");
+      }
+    }
+    if (config_data.debug_level > 2) {
+      gCatena.SafePrintf("\nStarting deep sleep.\n");
+    }
+    uint32_t tNow = millis();
+    while (uint32_t(millis() - tNow) < 100)
+    {
+      gCatena.poll();
+      yield();
+    }
+  }
+  else if (config_data.debug_level > 2) {
+    gCatena.SafePrintf("using light sleep\n");
+  }
+}
+
+void updateSleepCounters(void)
+{
+  // update the sleep parameters
+  if (gTxCycleCount > 1)
+  {
+    // values greater than one are decremented and ultimately reset to default.
+    --gTxCycleCount;
+  }
+  else if (gTxCycleCount == 1)
+  {
+    // it's now one (otherwise we couldn't be here.)
+    if (config_data.debug_level > 2) {
+      gCatena.SafePrintf("resetting tx cycle to default: %u\n", CATCFG_T_CYCLE);
+    }
+
+    gTxCycleCount = 0;
+    gTxCycle = CATCFG_T_CYCLE;
+  }
+  else
+  {
+    // it's zero. Leave it alone.
+  }
+}
+
+void doDeepSleep(osjob_t *pJob)
+{
+  bool const fDeepSleepTest = gCatena.GetOperatingFlags() &
+                              static_cast<uint32_t>(gCatena.OPERATING_FLAGS::fDeepSleepTest);
+  uint32_t const sleepInterval = CATCFG_GetInterval(
+                                   fDeepSleepTest ? CATCFG_T_CYCLE_TEST : gTxCycle
+                                 );
+
+  /* ok... now it's time for a deep sleep */
+  gLed.Set(LedPattern::Off);
+  deepSleepPrepare();
+
+  /* sleep */
+  gCatena.Sleep(sleepInterval);
+
+  /* recover from sleep */
+  deepSleepRecovery();
+
+  /* and now... we're awake again. trigger another measurement */
+  sleepDoneCb(pJob);
+}
+
+void deepSleepPrepare(void)
+{
+  Serial.end();
+  Wire.end();
+  SPI.end();
+  if (fFlash)
+    gSPI2.end();
+}
+
+void deepSleepRecovery(void)
+{
+  Serial.begin();
+  Wire.begin();
+  SPI.begin();
+  if (fFlash)
+    gSPI2.begin();
+}
+
+void doLightSleep(osjob_t *pJob)
+{
+  uint32_t interval = sec2osticks(CATCFG_GetInterval(gTxCycle));
+
+  gLed.Set(LedPattern::Sleeping);
+
+  if (gCatena.GetOperatingFlags() &
+      static_cast<uint32_t>(gCatena.OPERATING_FLAGS::fQuickLightSleep))
+  {
+    interval = 1;
+  }
+
+  gLed.Set(LedPattern::Sleeping);
+  os_setTimedCallback(
+    &iterationJob,
+    os_getTime() + interval,
+    sleepDoneCb
+  );
 }
 
 static void sleepDoneCb(osjob_t* pJob)

mini_beieli_node.h

@@ -56,7 +56,7 @@ enum {
   |
   \****************************************************************************/
 
-static const int32_t fwVersion = 20200207;
+static const int32_t fwVersion = 20200211;
 
 static const byte INIT_PACKAGE_INTERVAL = 100;  // send an init package every 100 packages;
 static const byte MAX_VALUES_TO_SEND = 8;