record times of filling and watering of single plants in db, to calibrate flowrates.

include/BoolField.h

     void clear(void);
     void set(int n);
     bool isSet(int n);
+    int countSet(void);
+    int getFirstSet(void);
     
 private:
     int size;

include/Statemachine.h

     unsigned long start_time, stop_time, last_animation_time;
     String error_condition;
     unsigned long into_state_time;
+
+    // used for calibrating, in fill'n'water mode
+    bool filling_started_empty;
+    bool watering_started_full;
 };
 
 #endif // _STATEMACHINE_H_

influx/influx-graph.py

 fig, ax = plt.subplots()
 
 for i in range(len(ids)):
+    cumulative = []
+    for j in range(len(durations[i])):
+        if j == 0:
+            cumulative.append(durations[i][j])
+        else:
+            cumulative.append(cumulative[j - 1] + durations[i][j])
+
     dates = matplotlib.dates.date2num(times[i])
-    ax.plot_date(dates, durations[i], '-', label='id ' + ids[i])
+    ax.plot_date(dates, cumulative, '-', label='id ' + ids[i])
 
     ax.set_xlabel('Time')
     ax.set_ylabel('Duration')
-    ax.set_title('Watering Durations')
+    ax.set_title('Cumulative Watering Durations')
     ax.legend()
 
 # ---------------------------
 
-fig, ax = plt.subplots()
-
-for i in range(len(ids)):
-    values = []
-    for j in range(len(times[i])):
-        if j == 0:
-            continue
-        delta = times[i][j] - times[i][j - 1]
-        values.append(delta.days)
-
-    ax.plot(range(len(values)), values, '-', label='id ' + ids[i])
-
-    ax.set_xlabel('Watering No.')
-    ax.set_ylabel('Time Difference')
-    ax.set_title('Time between Waterings')
-    ax.legend()
-
-# ---------------------------
+smoothing_value = 3.0
 
 fig, ax = plt.subplots()
 
 for i in range(len(ids)):
-    ax.plot(range(len(durations[i])), durations[i], '-', label='id ' + ids[i])
+    cumulative = []
+    for j in range(len(durations[i])):
+        if j == 0:
+            cumulative.append(durations[i][j])
+        else:
+            cumulative.append(cumulative[j - 1] + durations[i][j])
+
+    cumulative_clean = []
+    time_clean = []
+    xr = iter(range(len(durations[i]) - 1))
+    try:
+        for j in xr:
+            dx_dt = (times[i][j + 1] - times[i][j])
+            dx = dx_dt.seconds / 24 / 60 / 60 + dx_dt.days
+            if dx <= smoothing_value:
+                #print("combining diff=" + str(dx))
+                time_clean.append(times[i][j + 1])
+                cumulative_clean.append(cumulative[j + 1])
+                next(xr)
+            else:
+                time_clean.append(times[i][j])
+                cumulative_clean.append(cumulative[j])
+    except:
+        pass
+
+    cumulative_clean_2 = []
+    time_clean_2 = []
+    xr = iter(range(len(cumulative_clean) - 1))
+    try:
+        for j in xr:
+            dx_dt = (time_clean[j + 1] - time_clean[j])
+            dx = dx_dt.seconds / 24 / 60 / 60 + dx_dt.days
+            if dx <= smoothing_value:
+                #print("combining diff=" + str(dx))
+                time_clean_2.append(time_clean[j + 1])
+                cumulative_clean_2.append(cumulative_clean[j + 1])
+                next(xr)
+            else:
+                time_clean_2.append(time_clean[j])
+                cumulative_clean_2.append(cumulative_clean[j])
+    except:
+        pass
+
+    dates = matplotlib.dates.date2num(time_clean_2)
+    ax.plot_date(dates, cumulative_clean_2, '-', label='id ' + ids[i])
 
-    ax.set_xlabel('Watering No.')
+    ax.set_xlabel('Time')
     ax.set_ylabel('Duration')
-    ax.set_title('Duration per Watering')
+    ax.set_title('Smoothed Cumulative Watering Durations')
     ax.legend()
 
 # ---------------------------
 fig, ax = plt.subplots()
 
 for i in range(len(ids)):
-    values = []
-    s = 0
-    for j in range(len(times[i]) - 1):
-        t_delta = times[i][j + 1] - times[i][j]
-        dur = (durations[i][j] + durations[i][j + 1]) / 2.0
-        #dur = durations[i][j + 1]
-        #dur = durations[i][j]
-        avg_per_sec = dur / t_delta.total_seconds()
-        #if i == 2:
-        #    print()
-        #    print(dur)
-        #    print(t_delta.total_seconds())
-        #    print(avg_per_sec)
-        avg_per_day = avg_per_sec * 60.0 * 60.0 * 24.0
-        values.append(avg_per_day)
-        s += avg_per_sec
-    #print(s / (len(times[i]) - 1))
-
-    ax.plot(range(len(values)), values, '-', label='id ' + ids[i])
-
-    ax.set_xlabel('Watering No.')
-    ax.set_ylabel('Duration per Day')
-    ax.set_title('Watering Duration per Day')
+    cumulative = []
+    for j in range(len(durations[i])):
+        if j == 0:
+            cumulative.append(durations[i][j])
+        else:
+            cumulative.append(cumulative[j - 1] + durations[i][j])
+
+    cumulative_clean = []
+    time_clean = []
+    xr = iter(range(len(durations[i]) - 1))
+    try:
+        for j in xr:
+            dx_dt = (times[i][j + 1] - times[i][j])
+            dx = dx_dt.seconds / 24 / 60 / 60 + dx_dt.days
+            if dx <= smoothing_value:
+                #print("combining diff=" + str(dx))
+                time_clean.append(times[i][j + 1])
+                cumulative_clean.append(cumulative[j + 1])
+                next(xr)
+            else:
+                time_clean.append(times[i][j])
+                cumulative_clean.append(cumulative[j])
+    except:
+        pass
+
+    cumulative_clean_2 = []
+    time_clean_2 = []
+    xr = iter(range(len(cumulative_clean) - 1))
+    try:
+        for j in xr:
+            dx_dt = (time_clean[j + 1] - time_clean[j])
+            dx = dx_dt.seconds / 24 / 60 / 60 + dx_dt.days
+            if dx <= smoothing_value:
+                #print("combining diff=" + str(dx))
+                time_clean_2.append(time_clean[j + 1])
+                cumulative_clean_2.append(cumulative_clean[j + 1])
+                next(xr)
+            else:
+                time_clean_2.append(time_clean[j])
+                cumulative_clean_2.append(cumulative_clean[j])
+    except:
+        pass
+
+    rate_of_change = []
+    for j in range(len(cumulative_clean_2)):
+        if j < len(cumulative_clean_2) - 1:
+            dy = cumulative_clean_2[j + 1] - cumulative_clean_2[j]
+            dx_dt = (time_clean_2[j + 1] - time_clean_2[j])
+            dx = dx_dt.seconds / 24 / 60 / 60 + dx_dt.days
+            roc = dy / dx
+            #print(str(time_clean_2[j]) + " " + str(dy) + " / " + str(dx) + " = " + str(roc))
+            rate_of_change.append(roc)
+
+    dates = matplotlib.dates.date2num(time_clean_2)
+    ax.plot_date(dates[:-1], rate_of_change, '-', label='id ' + ids[i])
+
+    ax.set_xlabel('Time')
+    ax.set_ylabel('Rate of Change')
+    ax.set_title('RoC of Cumulative Watering Durations')
     ax.legend()
 
 # ---------------------------

src/BoolField.cpp

 bool BoolField::isSet(int n) {
     return field[n];
 }
+
+int BoolField::countSet(void) {
+    int c = 0;
+    for (int i = 0; i < size; i++) {
+        if (field[i]) {
+            c++;
+        }
+    }
+    return c;
+}
+
+int BoolField::getFirstSet(void) {
+    for (int i = 0; i < size; i++) {
+        if (field[i]) {
+            return i;
+        }
+    }
+    return -1;
+}

src/Statemachine.cpp

     last_animation_time = 0;
     error_condition = "";
     into_state_time = 0;
+    filling_started_empty = false;
+    watering_started_full = false;
 }
 
 void Statemachine::begin(void) {
                 if (found != 0) {
                     auto wl = plants.getWaterlevel();
                     if ((wl != Plants::full) && (wl != Plants::invalid)) {
+                        // if the waterlevel is currently empty, we
+                        // set a flag to record the time to fill
+                        filling_started_empty = (wl == Plants::empty);
+
                         plants.openWaterInlet();
                         selected_id = plants.countPlants() + 1;
                         selected_time = MAX_TANK_FILL_TIME;
                                 }
                             }
 
+                            // for recording the flowrate
+                            watering_started_full = (wl == Plants::full);
+
                             selected_time = MAX_AUTO_PLANT_RUNTIME;
                             start_time = millis();
                             switch_to(fillnwater_plant_run);
                 }
             }
 
+            watering_started_full = (wl == Plants::full);
+
             selected_time = MAX_AUTO_PLANT_RUNTIME;
             start_time = millis();
             switch_to(fillnwater_plant_run);
                         }
                     }
 
+                    watering_started_full = (wl == Plants::full);
+
                     selected_time = MAX_AUTO_PLANT_RUNTIME;
                     start_time = millis();
                     switch_to(fillnwater_plant_run);
             plants.abort();
             stop_time = millis();
             if (state == fillnwater_tank_run) {
+                // record time to fill here, if we started with
+                // an empty tank at the start of filling
+                if (filling_started_empty) {
+                    unsigned long time_to_fill = stop_time - start_time;
+                    debug.print("Filling tank took ");
+                    debug.print(String(time_to_fill));
+                    debug.println("ms");
+
+#if defined(PLATFORM_ESP)
+                    bool success = wifi_write_database(time_to_fill, "calibrated_filling", -1);
+                    if (!success) {
+                        debug.print("Error writing to InfluxDB ");
+                        debug.print(INFLUXDB_HOST);
+                        debug.print(":");
+                        debug.print(INFLUXDB_PORT);
+                        debug.print("/");
+                        debug.print(INFLUXDB_DATABASE);
+                        debug.println("/calibrated_filling");
+                    }
+#endif // PLATFORM_ESP
+                }
+
                 auto wl = plants.getWaterlevel();
                 if ((wl != Plants::empty) && (wl != Plants::invalid)) {
                     for (int i = 0; i < plants.countPlants(); i++) {
                         }
                     }
 
+                    watering_started_full = (wl == Plants::full);
+
                     selected_time = MAX_AUTO_PLANT_RUNTIME;
                     start_time = millis();
                     switch_to(fillnwater_plant_run);
         if (wl == Plants::empty) {
             plants.abort();
             stop_time = millis();
+
+            // if we started watering with a full tank
+            // and then finished watering when it was empty
+            // and we were only watering a single plant
+            // look at this as a "calibration run" and record
+            // the time it took to empty the tank
+            if ((state == fillnwater_plant_run) && watering_started_full && (selected_plants.countSet() == 1)) {
+                unsigned long time_to_water = stop_time - start_time;
+                debug.print("Watering plant ");
+                debug.print(selected_plants.getFirstSet() + 1);
+                debug.print(" with the complete tank took ");
+                debug.print(String(time_to_water));
+                debug.println("ms");
+
+#if defined(PLATFORM_ESP)
+                bool success = wifi_write_database(time_to_water, "calibrated_watering", selected_plants.getFirstSet() + 1);
+                if (!success) {
+                    debug.print("Error writing to InfluxDB ");
+                    debug.print(INFLUXDB_HOST);
+                    debug.print(":");
+                    debug.print(INFLUXDB_PORT);
+                    debug.print("/");
+                    debug.print(INFLUXDB_DATABASE);
+                    debug.println("/calibrated_watering");
+                }
+#endif // PLATFORM_ESP
+            }
+
             switch_to(auto_done);
         } else if (wl == Plants::invalid) {
             plants.abort();

src/WifiStuff.cpp

     bool success = false;
 
 #ifdef ENABLE_INFLUXDB_LOGGING
+    // we still want to be locally usable / have a snappy ui
+    // even when the wifi connection is broken.
+    if (WiFi.status() != WL_CONNECTED) {
+        debug.println("Won't attempt db write, no WiFi connection.");
+        return success;
+    }
+
     InfluxData measurement(type);
     measurement.addTag("version", FIRMWARE_VERSION);
     measurement.addTag("device", WiFi.macAddress());