new version (no other change, but updated libs)

mini-beieli-node.ino

@@ -99,6 +99,7 @@ long package_counter = 0; // sent package counter
 bool send_in_progress = false;
 bool stop_iterations = false;
 bool next_package_is_init_package = true;
+uint32_t gRebootMs;
 
 // generic timer
 long t_cur;
@@ -350,12 +351,11 @@ void setup_uplink(void)
     gCatena.SafePrintf("%010d - setup_uplink\n", millis());
   }
 
-#if defined(_mcci_arduino_version) && _mcci_arduino_version >= _mcci_arduino_version_calc(2,4,0,90) && \
+  LMIC_setClockError(1*65536/100);  
-    defined(CATENA_ARDUINO_PLATFORM_VERSION_CALC) && CATENA_ARDUINO_PLATFORM_VERSION >= CATENA_ARDUINO_PLATFORM_VERSION_CALC(0,17,0,10)
+
-  LMIC_setClockError(5 * 65536 / 100);
+  /* figure out when to reboot */
-#else
+  gRebootMs = (CATCFG_T_REBOOT + os_getRndU2() - 32768) * 1000;
-  LMIC_setClockError(10 * 65536 / 100);
+
-#endif
 
   // Do an unjoin, so every reboot will trigger a join
   if (config_data.debug_level > 0) {
@@ -536,36 +536,67 @@ void DoDeepSleep(uint32_t sleep_time)
   }
 }
 
-// highest and lowest value will be ignored
+//Following functions are based on "https://github.com/dndubins/QuickStats", by David Dubins
+
+long median(long samples[], int m) //calculate the median
+{
+  //First bubble sort the values: https://en.wikipedia.org/wiki/Bubble_sort
+  long sorted[m];   // Define and initialize sorted array.
+  long temp = 0;    // Temporary float for swapping elements
+
+  for (int i = 0; i < m; i++) {
+    sorted[i] = samples[i];
+  }
+  bubbleSort(sorted, m); // Sort the values
+
+  if (bitRead(m, 0) == 1) { //If the last bit of a number is 1, it's odd. This is equivalent to "TRUE". Also use if m%2!=0.
+    return sorted[m / 2]; //If the number of data points is odd, return middle number.
+  } else {
+    return (sorted[(m / 2) - 1] + sorted[m / 2]) / 2; //If the number of data points is even, return avg of the middle two numbers.
+  }
+}
+
+void bubbleSort(long A[], int len) {
+  unsigned long newn;
+  unsigned long n = len;
+  long temp = 0;
+  do {
+    newn = 1;
+    for (int p = 1; p < len; p++) {
+      if (A[p - 1] > A[p]) {
+        temp = A[p];         //swap places in array
+        A[p] = A[p - 1];
+        A[p - 1] = temp;
+        newn = p;
+      } //end if
+    } //end for
+    n = newn;
+  } while (n > 1);
+}
+
 long my_read_average(byte gain, byte times) {
-  // highest and lowest value will be ignored
-  long sum = 0;
-  long v = 0;
-  long L = 2147483647;
-  long H = -2147483648;
   long res;
+  int const num_scale_readings = 25; // 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
+
   if (config_data.debug_level > 0) {
     gCatena.SafePrintf("%010d - my_read_average, measurements: ", millis());
   }
-  for (byte i = 0; i < times; i++) {
-    delay(WAITTIMELOADSAMPLES * 1000);
-    LoadCell.power_up();
-    LoadCell.set_gain(gain);
-    delay(2);  // wait for stabilizing
-    v = LoadCell.read();
-    LoadCell.power_down();
 
-    if (L > v) L = v; // find lowest value
+  LoadCell.set_gain(gain);
-    if (H < v) H = v; // find highest value
+  // we wait 400ms (settling time according HX711 datasheet @ 10 SPS
-    sum += v;
+  delay(400);
-    if (config_data.debug_level > 0) {
+
-      gCatena.SafePrintf("%d ", v);
+  for (int i = 0; i < num_scale_readings; i++) {
+    readings[i] = LoadCell.read();  // fill the array with instantaneous readings from the scale
   }
-    gCatena.poll();
+
-  }
+  res = median(readings, num_scale_readings); // calculate median
-  res = (sum - L - H) / (times - 2);
+
   if (config_data.debug_level > 0) {
-    gCatena.SafePrintf("; average (without highest [%d] and lowest [%d] value): %d\n", H, L, res);
+    gCatena.SafePrintf("; median of %d samples: %d\n", num_scale_readings, res);
   }
 
   return res;
@@ -614,7 +645,9 @@ void ReadSensors(SENSOR_data &sensor_data) {
   if (weight_current32 < 0) {
     weight_current32 = 0;
   } else if (weight_current32 > UINT16_MAX) {
-    weight_current32 = UINT16_MAX;
+    //weight_current32 = UINT16_MAX;
+    // we set the weight to 0, as such high values are not realistic and probably a sign for bad calibration...
+    weight_current32 = 0;
   }
   res.weight = (uint16_t)weight_current32;
 
@@ -888,6 +921,11 @@ static void settleDoneCb(
     // Terry ^^
   }
 
+  if (uint32_t(millis()) > gRebootMs) {
+    // time to reboot
+    NVIC_SystemReset();
+  }
+
   sleepDoneCb(pSendJob);
 }
 

mini_beieli_node.h

@@ -19,6 +19,7 @@ enum {
   CATCFG_T_CYCLE_TEST = 30, // every 10 seconds
   CATCFG_T_CYCLE_INITIAL = 30,    // every 30 seconds initially
   CATCFG_INTERVAL_COUNT_INITIAL = 30,     // repeat for 15 minutes
+  CATCFG_T_REBOOT = 30 * 24 * 60 * 60,    // reboot every 30 days
 };
 
 /* additional timing parameters; ususually you don't change these. */
@@ -55,13 +56,7 @@ enum {
   |
   \****************************************************************************/
 
-static const int32_t fwVersion = 20191220;
+static const int32_t fwVersion = 20200207;
-
-// wait between samples
-// 3 sec is a good delay so that load cell did not warm up
-// too much and external random influences like wind has time
-// to go so that the next sample is more valid
-const int WAITTIMELOADSAMPLES = 3;
 
 static const byte INIT_PACKAGE_INTERVAL = 100;  // send an init package every 100 packages;
 static const byte MAX_VALUES_TO_SEND = 8;