various fixes. return to init screen on idle. missing fillnwater case. added some influx export scripts for testing. prepared for automation menu.

.gitignore

 .pio
 include/wifi.h
+.directory

include/Functionality.h

                   const char *c, const char *d, int num_input);
 void backspace(void);
 
+bool sm_is_idle(void);
+
 #endif // _FUNCTIONALITY_H_

include/Statemachine.h

 public:
     enum States {
         init = 0,
-        menu, // auto, pumps, valves
+        menu_a, // manual, auto
+        menu_b, // pumps, valves
         
         auto_mode_a, // select mode 1
         auto_mode_b, // select mode 2
         fillnwater_plant, // select plants
         fillnwater_tank_run,
         fillnwater_plant_run,
+
+        automation_mode,
         
         menu_pumps, // selet pump
         menu_pumps_time, // set runtime
     void act(void);
     
     const char *getStateName(void);
+    bool isIdle(void);
     
 private:
     void switch_to(States s);
     uint32_t selected_time; // runtime
     unsigned long start_time, stop_time, last_animation_time;
     String error_condition;
+    unsigned long into_state_time;
 };
 
 #endif // _STATEMACHINE_H_

include/config.h

 
 // in milliseconds
 #define DISPLAY_BACKLIGHT_TIMEOUT (5UL * 60UL * 1000UL)
+#define BACK_TO_IDLE_TIMEOUT (5UL * 60UL * 1000UL)
 
 // in seconds
 #define MAX_TANK_FILL_TIME (67 + 3)
 #define AUTO_PUMP_RUNTIME 5
-#define MAX_AUTO_PLANT_RUNTIME (30 * 60)
+#define MAX_AUTO_PLANT_RUNTIME (35 * 60)
 #define MAX_PUMP_RUNTIME 30
 #define MAX_VALVE_RUNTIME (45 * 60)
 

influx/influx-export.py

+#!/usr/bin/env python
+
+from influxdb import InfluxDBClient
+from datetime import datetime
+import xlsxwriter
+
+# config
+host = '10.23.42.14'
+port = 8086
+user = 'root'
+password = 'root'
+dbname = 'giessomat'
+
+# data
+client = InfluxDBClient(host, port, user, password, dbname)
+print("Querying DB " + dbname + " on " + host)
+result = client.query('SELECT "id", "duration" FROM "plant";')
+#print("Result: {0}".format(result))
+
+data = list(result.get_points())
+print("Got " + str(len(data)) + " datapoints")
+#print(data)
+
+ids = list(set([ d['id'] for d in data ]))
+ids.sort()
+#ids = ['1']
+print("IDs found: " + str(ids))
+
+values = []
+times = []
+durations = []
+for id in ids:
+    values.append([d for d in data if d['id'] == id])
+    times.append([datetime.strptime(d['time'], '%Y-%m-%dT%H:%M:%S.%fZ') for d in data if d['id'] == id])
+    durations.append([d['duration'] for d in data if d['id'] == id])
+
+workbook = xlsxwriter.Workbook('InfluxExport.xlsx')
+worksheet = workbook.add_worksheet()
+
+bold = workbook.add_format({'bold': 1})
+date_format = workbook.add_format({'num_format': 'dd.mm.yyyy hh:mm'})
+
+for i in range(len(ids)):
+    worksheet.write_string(0, (i * 3) + 0, "ID", bold)
+    worksheet.write_number(0, (i * 3) + 1, int(ids[i]))
+
+    worksheet.write_string(1, (i * 3) + 0, "Time", bold)
+    worksheet.set_column((i * 3) + 0, (i * 3) + 0, 20)
+    for j in range(len(times[i])):
+        worksheet.write_datetime(j + 2, (i * 3) + 0, times[i][j], date_format)
+
+    worksheet.write_string(1, (i * 3) + 1, "Duration", bold)
+    for j in range(len(durations[i])):
+        worksheet.write_number(j + 2, (i * 3) + 1, durations[i][j])
+
+workbook.close()

influx/influx-graph.py

+#!/usr/bin/env python
+
+from influxdb import InfluxDBClient
+import matplotlib.pyplot as plt
+import matplotlib
+from datetime import datetime
+
+# config
+host = '10.23.42.14'
+port = 8086
+user = 'root'
+password = 'root'
+dbname = 'giessomat'
+
+# data
+client = InfluxDBClient(host, port, user, password, dbname)
+print("Querying DB " + dbname + " on " + host)
+result = client.query('SELECT "id", "duration" FROM "plant";')
+#print("Result: {0}".format(result))
+
+data = list(result.get_points())
+print("Got " + str(len(data)) + " datapoints")
+#print(data)
+
+ids = list(set([ d['id'] for d in data ]))
+ids.sort()
+#ids = ['1']
+print("IDs found: " + str(ids))
+
+values = []
+times = []
+durations = []
+for id in ids:
+    values.append([d for d in data if d['id'] == id])
+    times.append([datetime.strptime(d['time'], '%Y-%m-%dT%H:%M:%S.%fZ') for d in data if d['id'] == id])
+    durations.append([d['duration'] for d in data if d['id'] == id])
+
+s1 = 0.0
+s2 = 0.0
+c2 = 0
+for i in range(len(ids)):
+    s = 0.0
+    for j in range(len(durations[i])):
+        s += durations[i][j]
+        s2 += durations[i][j]
+        c2 += 1
+    avg = s / len(durations[i])
+    print("ID=" + ids[i] + " sum=" + str(s) + " len=" + str(len(durations[i])) + " avg=" + str(avg))
+    s1 += avg
+avg1 = s1 / len(ids)
+avg2 = s2 / c2
+print("avg1=" + str(avg1) + " avg2=" + str(avg2))
+
+# plot results
+plt.ioff()
+
+# ---------------------------
+
+fig, ax = plt.subplots()
+
+for i in range(len(ids)):
+    dates = matplotlib.dates.date2num(times[i])
+    ax.plot_date(dates, durations[i], '-', label='id ' + ids[i])
+
+    ax.set_xlabel('Time')
+    ax.set_ylabel('Duration')
+    ax.set_title('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()
+
+# ---------------------------
+
+fig, ax = plt.subplots()
+
+for i in range(len(ids)):
+    ax.plot(range(len(durations[i])), durations[i], '-', label='id ' + ids[i])
+
+    ax.set_xlabel('Watering No.')
+    ax.set_ylabel('Duration')
+    ax.set_title('Duration per Watering')
+    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')
+    ax.legend()
+
+# ---------------------------
+
+plt.show()

src/Functionality.cpp

 CircularBuffer<int, I2C_BUF_SIZE> keybuffer;
 String linebuffer[4];
 
+bool sm_is_idle(void) {
+    return true;
+}
+
 #endif // ! FUNCTION_CONTROL
 
 #include "SerialLCD.h"
 
 Statemachine sm(write_to_all, backspace);
 
+bool sm_is_idle(void) {
+    return sm.isIdle();
+}
+
 #endif // FUNCTION_CONTROL
 
 // ----------------------------------------------------------------------------
                   const char *c, const char *d, int num_input) {
     const char *lines[4] = { a, b, c, d };
     
-    debug.println("write_to_all i2c");
+    //debug.println("write_to_all i2c");
     
     for (int i = 0; i < 4; i++) {
         Wire.beginTransmission(OWN_I2C_ADDRESS);

src/Statemachine.cpp

 
 static const char *state_names[] = {
     stringify(init),
-    stringify(menu),
+    stringify(menu_a),
+    stringify(menu_b),
     stringify(auto_mode_a),
     stringify(auto_mode_b),
     stringify(auto_fert),
     stringify(fillnwater_plant),
     stringify(fillnwater_tank_run),
     stringify(fillnwater_plant_run),
+    stringify(automation_mode),
     stringify(menu_pumps),
     stringify(menu_pumps_time),
     stringify(menu_pumps_go),
     return state_names[state];
 }
 
+bool Statemachine::isIdle(void) {
+    return state == init;
+}
+
 Statemachine::Statemachine(print_fn _print, backspace_fn _backspace)
         : db(7), selected_plants(plants.countPlants()) {
     state = init;
     stop_time = 0;
     last_animation_time = 0;
     error_condition = "";
+    into_state_time = 0;
 }
 
 void Statemachine::begin(void) {
 
 void Statemachine::input(int n) {
     if (state == init) {
-        switch_to(menu);
-    } else if (state == menu) {
+        switch_to(menu_a);
+    } else if ((state == menu_a) || (state == menu_b)) {
         if (n == 1) {
             switch_to(auto_mode_a);
         } else if (n == 2) {
-            switch_to(menu_pumps);
+            switch_to(automation_mode);
         } else if (n == 3) {
+            switch_to(menu_pumps);
+        } else if (n == 4) {
             switch_to(menu_valves);
-        } else if ((n == -1) || (n == -2)) {
+        } else if (n == -1) {
             switch_to(init);
+        } else if (n == -2) {
+            switch_to((state == menu_a) ? menu_b : menu_a);
         }
+    } else if (state == automation_mode) {
+        // TODO
+        switch_to(menu_a);
     } else if ((state == auto_mode_a) || (state == auto_mode_b)) {
         if (n == 1) {
             switch_to(auto_fert);
             selected_plants.clear();
             switch_to(auto_plant);
         } else if (n == -1) {
-            switch_to(menu);
+            switch_to(menu_a);
         } else if (n == -2) {
             switch_to((state == auto_mode_a) ? auto_mode_b : auto_mode_a);
         }
                 backspace();
                 db.removeDigit();
             } else {
-                switch_to(menu);
+                switch_to(menu_b);
             }
         } else if (n == -2) {
             if (!db.hasDigits()) {
             start_time = millis();
             switch_to(fillnwater_plant_run);
         } else if (wl == Plants::empty) {
-            stop_time = millis();
             switch_to(auto_mode_a);
         } else if (wl == Plants::invalid) {
             error_condition = "Invalid sensor state";
         stop_time = millis();
         switch_to(menu_pumps_done);
     } else if (state == menu_pumps_done) {
-        switch_to(menu);
+        switch_to(menu_b);
     } else if (state == menu_valves) {
         if (n == -1) {
             if (db.hasDigits()) {
                 backspace();
                 db.removeDigit();
             } else {
-                switch_to(menu);
+                switch_to(menu_b);
             }
         } else if (n == -2) {
             if (!db.hasDigits()) {
             stop_time = millis();
             switch_to(menu_valves_done);
     } else if (state == menu_valves_done) {
-        switch_to(menu);
+        switch_to(menu_b);
     } else if (state == error) {
         if (old_state != error) {
             switch_to(old_state);
         } else {
-            switch_to(menu);
+            switch_to(menu_a);
         }
     }
 }
             // stop if timeout has been reached
             plants.abort();
             stop_time = millis();
-            switch_to(auto_done);
+            if (state == fillnwater_tank_run) {
+                auto wl = plants.getWaterlevel();
+                if ((wl != Plants::empty) && (wl != Plants::invalid)) {
+                    for (int i = 0; i < plants.countPlants(); i++) {
+                        if (selected_plants.isSet(i)) {
+                            plants.startPlant(i);
+                        }
+                    }
+
+                    selected_time = MAX_AUTO_PLANT_RUNTIME;
+                    start_time = millis();
+                    switch_to(fillnwater_plant_run);
+                } else if (wl == Plants::empty) {
+                    stop_time = millis();
+                    switch_to(auto_done);
+                } else if (wl == Plants::invalid) {
+                    error_condition = "Invalid sensor state";
+                    state = auto_mode_a;
+                    switch_to(error);
+                }
+            } else {
+                switch_to(auto_done);
+            }
         } else if ((millis() - last_animation_time) >= 500) {
             // update animation if needed
             last_animation_time = millis();
             switch_to(error);
         }
     }
+
+    if ((state == menu_a) || (state == menu_b) || (state == automation_mode)
+            || (state == auto_mode_a) || (state == auto_mode_b)
+            || (state == auto_fert) || (state == auto_done)
+            || (state == auto_plant) || (state == fillnwater_plant)
+            || (state == menu_pumps) || (state == menu_pumps_time)
+            || (state == menu_pumps_go) || (state == menu_pumps_done)
+            || (state == menu_valves) || (state == menu_valves_time)
+            || (state == menu_valves_go) || (state == menu_valves_done)) {
+        unsigned long runtime = millis() - into_state_time;
+        if (runtime >= BACK_TO_IDLE_TIMEOUT) {
+            debug.print("Idle timeout reached in state ");
+            debug.println(state_names[state]);
+            switch_to(init);
+        }
+    }
 }
 
 void Statemachine::switch_to(States s) {
     old_state = state;
     state = s;
+    into_state_time = millis();
+
+    if (old_state != state) {
+        // don't spam log with every animation state "change"
+        debug.print("switch_to ");
+        debug.print(state_names[old_state]);
+        debug.print(" --> ");
+        debug.println(state_names[state]);
+    }
     
     if (s == init) {
         String a = String("- Giess-o-mat V") + FIRMWARE_VERSION + String(" -");
               "* Delete prev. digit",
               "# Execute input num.",
               -1);
-    } else if (s == menu) {
-        print("------- Menu -------",
-              "1: Automatic program",
-              "2: Fertilizer pumps",
-              "3: Outlet valves",
+    } else if (s == menu_a) {
+        print("----- Menu 1/2 -----",
+              "1: Manual Operation",
+              "2: Automation",
+              "#: Go to page 2/2...",
+              -1);
+    } else if (s == menu_b) {
+        print("----- Menu 2/2 -----",
+              "3: Fertilizer pumps",
+              "4: Outlet valves",
+              "#: Go to page 1/2...",
+              -1);
+    } else if (state == automation_mode) {
+        // TODO
+        print("---- Automation ----",
+              "TODO NOT IMPLEMENTED",
+              "TODO NOT IMPLEMENTED",
+              "TODO NOT IMPLEMENTED",
               -1);
     } else if (s == auto_mode_a) {
-        print("----- Auto 1/2 -----",
+        print("---- Manual 1/2 ----",
               "1: Add Fertilizer",
               "2: Fill 'n' Water",
               "#: Go to page 2/2...",
               -1);
     } else if (s == auto_mode_b) {
-        print("----- Auto 2/2 -----",
+        print("---- Manual 2/2 ----",
               "3: Fill Reservoir",
               "4: Water a plant",
               "#: Go to page 1/2...",

src/WifiStuff.cpp

     }
     
     // reset ESP every 6h to be safe
-    if (millis() >= (6 * 60 * 60 * 1000)) {
+    if ((millis() >= (6UL * 60UL * 60UL * 1000UL)) && (sm_is_idle())) {
         ESP.restart();
     }