implemented manual modes

include/GPIOBank.h

     
     int getSize(void);
     void setPin(int n, bool state);
+    void setAll(bool state);
     bool getPin(int n);
     
 private:

include/Plants.h

+#ifndef _PLANTS_H_
+#define _PLANTS_H_
+
+#include "GPIOBank.h"
+
+class Plants {
+public:
+    enum Waterlevel {
+        empty,
+        inbetween,
+        full,
+        invalid
+    };
+    
+    // valves: no of plants + 1 for water inlet
+    // pumps: no of fertilizers
+    // switches: 2, low and high level
+    Plants(int valve_count, int pump_count, int switch_count);
+    
+    void setValvePins(int pins[]);
+    void setPumpPins(int pins[]);
+    void setSwitchPins(int pins[], bool pullup);
+    
+    void abort(void);
+    
+    Waterlevel getWaterlevel(void);
+    void openWaterInlet(void);
+    void closeWaterInlet(void);
+    
+    int countFertilizers(void);
+    void startFertilizer(int id);
+    void stopFertilizer(int id);
+    void stopAllFertilizers(void);
+    
+    int countPlants(void);
+    void startPlant(int id);
+    void stopPlant(int id);
+    void stopAllPlants(void);
+    
+private:
+    GPIOBank valves;
+    GPIOBank pumps;
+    GPIOBank switches;
+};
+
+extern Plants plants;
+
+#endif // _PLANTS_H_

include/Statemachine.h

 #ifndef _STATEMACHINE_H_
 #define _STATEMACHINE_H_
 
+#include <Arduino.h>
+
 class Statemachine {
 public:
     enum States {
         menu_valves_time, // set runtime
         menu_valves_go, // running
         menu_valves_running,
-        menu_valves_done
+        menu_valves_done,
+        
+        error
     };
     
     class DigitBuffer {
     uint32_t number_input(void);
     
     DigitBuffer db;
-    States state;
+    States state, old_state;
     print_fn print;
     backspace_fn backspace;
     
     uint32_t selected_id; // pump or valve id
     uint32_t selected_time; // runtime
+    unsigned long start_time, stop_time, last_animation_time;
+    String error_condition;
 };
 
 #endif // _STATEMACHINE_H_

src/GPIOBank.cpp

     }
 }
 
+void GPIOBank::setAll(bool state) {
+    for (int i = 0; i < size; i++) {
+        setPin(i, state);
+    }
+}
+
 bool GPIOBank::getPin(int n) {
     if ((n >= 0) && (n < size)) {
         return digitalRead(pins[n]);

src/Plants.cpp

+#include <Arduino.h>
+#include "Plants.h"
+    
+// valves: no of plants + 1 for water inlet
+// pumps: no of fertilizers
+// switches: 2, low and high level
+Plants::Plants(int valve_count, int pump_count, int switch_count) :
+        valves(valve_count), pumps(pump_count), switches(switch_count) {
+}
+
+void Plants::setValvePins(int pins[]) {
+    valves.setPinNumbers(pins);
+    valves.setOutput();
+    valves.setAll(false);
+}
+
+void Plants::setPumpPins(int pins[]) {
+    pumps.setPinNumbers(pins);
+    pumps.setOutput();
+    pumps.setAll(false);
+}
+
+void Plants::setSwitchPins(int pins[], bool pullup) {
+    switches.setPinNumbers(pins);
+    switches.setInput(pullup);
+}
+
+void Plants::abort(void) {
+    closeWaterInlet();
+    stopAllFertilizers();
+    stopAllPlants();
+}
+
+Plants::Waterlevel Plants::getWaterlevel(void) {
+    bool low = !switches.getPin(0);
+    bool high = !switches.getPin(1);
+    
+    if ((!low) && (!high)) {
+        return empty;
+    } else if (low && (!high)) {
+        return inbetween;
+    } else if (low && high) {
+        return full;
+    } else {
+        return invalid;
+    }
+}
+
+void Plants::openWaterInlet(void) {
+    valves.setPin(countPlants(), true);
+}
+
+void Plants::closeWaterInlet(void) {
+    valves.setPin(countPlants(), false);
+}
+
+int Plants::countFertilizers(void) {
+    return pumps.getSize();
+}
+
+void Plants::startFertilizer(int id) {
+    if ((id >= 0) && (id < countFertilizers())) {
+        pumps.setPin(id, true);
+    }
+}
+
+void Plants::stopFertilizer(int id) {
+    if ((id >= 0) && (id < countFertilizers())) {
+        pumps.setPin(id, false);
+    }
+}
+
+void Plants::stopAllFertilizers(void) {
+    for (int i = 0; i < countFertilizers(); i++) {
+        stopFertilizer(i);
+    }
+}
+
+int Plants::countPlants(void) {
+    return valves.getSize() - 1;
+}
+
+void Plants::startPlant(int id) {
+    if ((id >= 0) && (id < countPlants())) {
+        valves.setPin(id, true);
+    }
+}
+
+void Plants::stopPlant(int id) {
+    if ((id >= 0) && (id < countPlants())) {
+        valves.setPin(id, false);
+    }
+}
+
+void Plants::stopAllPlants(void) {
+    for (int i = 0; i < countPlants(); i++) {
+        stopPlant(i);
+    }
+}

src/Statemachine.cpp

-#include <Arduino.h>
+#include "Plants.h"
 #include "Statemachine.h"
 
 Statemachine::DigitBuffer::DigitBuffer(int _size) {
 Statemachine::Statemachine(print_fn _print, backspace_fn _backspace)
         : db(7) {
     state = init;
+    old_state = init;
     print = _print;
     backspace = _backspace;
     
     selected_id = 0;
     selected_time = 0;
+    start_time = 0;
+    stop_time = 0;
+    last_animation_time = 0;
+    error_condition = "";
 }
 
 void Statemachine::begin(void) {
             switch_to(init);
         }
     } else if (state == menu_auto) {
-        if ((n == -1) || (n == -2)) {
-            switch_to(menu);
-        } else if (n == 1) {
-            // water only
-            
-        } else if (n == 2) {
-            // with fertilizer
-            
-        }
+        switch_to(menu);
     } else if (state == menu_auto_mode) {
         switch_to(menu);
     } else if (state == menu_auto_go) {
             
             selected_id = number_input();
             
-            // TODO validate
-            switch_to(menu_pumps_time);
+            if ((selected_id <= 0) || (selected_id > plants.countFertilizers())) {
+                error_condition = "Invalid pump ID!";
+                switch_to(error);
+            } else {
+                switch_to(menu_pumps_time);
+            }
         } else {
             if (db.spaceLeft()) {
                 db.addDigit(n);
             
             selected_time = number_input();
             
-            // TODO validate
-            switch_to(menu_pumps_go);
+            if ((selected_time <= 0) || (selected_time > 120)) {
+                error_condition = "Invalid time range!";
+                switch_to(error);
+            } else {
+                switch_to(menu_pumps_go);
+            }
         } else {
             if (db.spaceLeft()) {
                 db.addDigit(n);
             }
         }
     } else if (state == menu_pumps_go) {
-        switch_to(menu);
+        if (n == -2) {
+            start_time = millis();
+            last_animation_time = start_time;
+            
+            auto wl = plants.getWaterlevel();
+            if ((wl != Plants::full) && (wl != Plants::invalid)) {
+                plants.startFertilizer(selected_id - 1);
+                switch_to(menu_pumps_running);
+            } else if (wl == Plants::full) {
+                stop_time = millis();
+                switch_to(menu_pumps_done);
+            } else if (wl == Plants::invalid) {
+                error_condition = "Invalid sensor state";
+                state = menu_pumps;
+                switch_to(error);
+            }
+        } else {
+            switch_to(menu_pumps_time);
+        }
     } else if (state == menu_pumps_running) {
-        switch_to(menu);
+            plants.abort();
+            stop_time = millis();
+            switch_to(menu_pumps_done);
     } else if (state == menu_pumps_done) {
         switch_to(menu);
     } else if (state == menu_valves) {
             
             selected_id = number_input();
             
-            // TODO validate
-            switch_to(menu_valves_time);
+            if ((selected_id <= 0) || (selected_id > (plants.countPlants() + 1))) {
+                error_condition = "Invalid valve ID!";
+                switch_to(error);
+            } else {
+                switch_to(menu_valves_time);
+            }
         } else {
             if (db.spaceLeft()) {
                 db.addDigit(n);
             
             selected_time = number_input();
             
-            // TODO validate
-            switch_to(menu_valves_go);
+            if ((selected_time <= 0) || (selected_time > 120)) {
+                error_condition = "Invalid time range!";
+                switch_to(error);
+            } else {
+                switch_to(menu_valves_go);
+            }
         } else {
             if (db.spaceLeft()) {
                 db.addDigit(n);
             }
         }
     } else if (state == menu_valves_go) {
-        switch_to(menu);
+        if (n == -2) {
+            start_time = millis();
+            last_animation_time = start_time;
+            
+            auto wl = plants.getWaterlevel();
+            if ((wl != Plants::full) && (wl != Plants::invalid)) {
+                if (selected_id >= (plants.countPlants() + 1)) {
+                    plants.openWaterInlet();
+                } else {
+                    plants.startPlant(selected_id - 1);
+                }
+                
+                switch_to(menu_valves_running);
+            } else if (wl == Plants::full) {
+                stop_time = millis();
+                switch_to(menu_valves_done);
+            } else if (wl == Plants::invalid) {
+                error_condition = "Invalid sensor state";
+                state = menu_valves;
+                switch_to(error);
+            }
+        } else {
+            switch_to(menu_valves_time);
+        }
     } else if (state == menu_valves_running) {
-        switch_to(menu);
+            plants.abort();
+            stop_time = millis();
+            switch_to(menu_valves_done);
     } else if (state == menu_valves_done) {
         switch_to(menu);
+    } else if (state == error) {
+        if (old_state != error) {
+            switch_to(old_state);
+        } else {
+            switch_to(menu);
+        }
     }
 }
 
 }
 
 void Statemachine::act(void) {
+    if ((state == menu_pumps_running) || (state == menu_valves_running)) {
+        unsigned long runtime = millis() - start_time;
+        if ((runtime / 1000UL) >= selected_time) {
+            // stop if timeout has been reached
+            plants.abort();
+            stop_time = millis();
+            switch_to((state == menu_pumps_running) ? menu_pumps_done : menu_valves_done);
+        } else if ((millis() - last_animation_time) >= 500) {
+            // update animation if needed
+            last_animation_time = millis();
+            switch_to(state);
+        }
+    }
     
+    if ((state == menu_pumps_running) || ((state == menu_valves_running) && (selected_id == (plants.countPlants() + 1)))) {
+        // check water level state
+        auto wl = plants.getWaterlevel();
+        if (wl == Plants::full) {
+            plants.abort();
+            stop_time = millis();
+            switch_to((state == menu_pumps_running) ? menu_pumps_done : menu_valves_done);
+        } else if (wl == Plants::invalid) {
+            plants.abort();
+            error_condition = "Invalid sensor state";
+            state = (state == menu_pumps_running) ? menu_pumps : menu_valves;
+            switch_to(error);
+        }
+    }
 }
 
 void Statemachine::switch_to(States s) {
+    if (s == error) {
+        old_state = state;
+    }
+    
     state = s;
     
     if (s == init) {
               -1);
     } else if (s == menu_auto) {
         print("------- Auto -------",
-              "1: Water only",
-              "2: With fertilizer",
+              "",
+              "TODO not implemented",
               "",
               -1);
     } else if (s == menu_auto_mode) {
-        print("",
-              "",
+        print("menu_auto_mode",
               "",
+              "TODO not implemented",
               "",
               -1);
     } else if (s == menu_auto_go) {
-        print("",
-              "",
+        print("menu_auto_go",
               "",
+              "TODO not implemented",
               "",
               -1);
     } else if (s == menu_auto_done) {
-        print("",
-              "",
+        print("menu_auto_done",
               "",
+              "TODO not implemented",
               "",
               -1);
     } else if (s == menu_pumps) {
+        String a = String("(Input 1 to ") + String(plants.countFertilizers()) + String(")");
+        
         print("------- Pump -------",
               "Please select pump",
-              "(Input 1 to 3)",
+              a.c_str(),
               "Pump: ",
               3);
     } else if (s == menu_pumps_time) {
-        print("------ Pump X ------",
+        String header = String("------ Pump ") + String(selected_id) + String(" ------");
+        
+        print(header.c_str(),
               "Please set runtime",
               "(Input in seconds)",
               "Runtime: ",
               3);
     } else if (s == menu_pumps_go) {
-        print("",
-              "",
-              "",
-              "",
+        String a = String("Pump No. ") + String(selected_id);
+        String b = String("Runtime ") + String(selected_time) + String('s');
+        
+        print("----- Confirm? -----",
+              a.c_str(),
+              b.c_str(),
+              "           # Confirm",
               -1);
     } else if (s == menu_pumps_running) {
-        print("",
-              "",
-              "",
-              "",
+        unsigned long runtime = millis() - start_time;
+        String a = String("Runtime: ") + String(runtime / 1000UL) + String("s / ") + String(selected_time) + String('s');
+        
+        unsigned long anim = runtime * 20UL / (selected_time * 1000UL);
+        String b;
+        for (unsigned long i = 0; i < anim; i++) {
+            b += '#';
+        }
+        
+        print("---- Dispensing ----",
+              a.c_str(),
+              b.c_str(),
+              "Hit any key to stop!",
               -1);
     } else if (s == menu_pumps_done) {
-        print("",
-              "",
-              "",
-              "",
+        String a = String("after ") + String((stop_time - start_time) / 1000UL) + String("s.");
+        
+        print("------- Done -------",
+              "Dispensing finished",
+              a.c_str(),
+              "Hit any key for menu",
               -1);
     } else if (s == menu_valves) {
+        String a = String("(Input 1 to ") + String(plants.countPlants() + 1) + String(")");
+        
         print("------ Valves ------",
               "Please select valve",
-              "(Input 1 to 5)",
+              a.c_str(),
               "Valve: ",
               3);
     } else if (s == menu_valves_time) {
-        print("----- Valve XX -----",
+        String header = String("----- Valve  ") + String(selected_id) + String(" -----");
+        
+        print(header.c_str(),
               "Please set runtime",
               "(Input in seconds)",
               "Runtime: ",
               3);
     } else if (s == menu_valves_go) {
-        print("",
-              "",
-              "",
-              "",
+        String a = String("Valve No. ") + String(selected_id);
+        String b = String("Runtime ") + String(selected_time) + String('s');
+        
+        print("----- Confirm? -----",
+              a.c_str(),
+              b.c_str(),
+              "           # Confirm",
               -1);
     } else if (s == menu_valves_running) {
-        print("",
-              "",
-              "",
-              "",
+        unsigned long runtime = millis() - start_time;
+        String a = String("Runtime: ") + String(runtime / 1000UL) + String("s / ") + String(selected_time) + String('s');
+        
+        unsigned long anim = runtime * 20UL / (selected_time * 1000UL);
+        String b;
+        for (unsigned long i = 0; i <= anim; i++) {
+            b += '#';
+        }
+        
+        print("---- Dispensing ----",
+              a.c_str(),
+              b.c_str(),
+              "Hit any key to stop!",
               -1);
     } else if (s == menu_valves_done) {
-        print("",
-              "",
-              "",
-              "",
+        String a = String("after ") + String((stop_time - start_time) / 1000UL) + String("s.");
+        
+        print("------- Done -------",
+              "Dispensing finished",
+              a.c_str(),
+              "Hit any key for menu",
+              -1);
+    } else if (s == error) {
+        print("------ Error! ------",
+              "There is a problem:",
+              error_condition.c_str(),
+              "    Press any key...",
               -1);
     }
 }

src/main.cpp

 #include "Keymatrix.h"
 #include "SerialLCD.h"
 #include "Statemachine.h"
-#include "GPIOBank.h"
+#include "Plants.h"
 
 //#define DEBUG_WAIT_FOR_SERIAL_CONN
 
 Keymatrix keys(4, 3);
 int keymatrix_pins[4 + 3] = { 5, 6, 7, 8, 2, 3, 4 };
 
-GPIOBank valves(5);
-int valve_pins[5] = { 9, 10, 11, 12, 13 };
-
-GPIOBank pumps(3);
-int pump_pins[5] = { 14, 15, 16 };
+Plants plants(5, 3, 2);
+int valve_pins[5] = { 10, 11, 12, 13, 14 };
+int pump_pins[3] = { 15, 16, 17 };
+int switch_pins[2] = { 18, 19 };
 
 #define DISPLAY_BACKLIGHT_TIMEOUT (5UL * 60UL * 1000UL)
 unsigned long last_input_time = 0;
     Serial.println("Initializing Giess-o-mat");
     
     keys.setPins(keymatrix_pins);
-    
-    valves.setPinNumbers(valve_pins);
-    valves.setOutput();
-    
-    pumps.setPinNumbers(pump_pins);
-    pumps.setOutput();
+    plants.setValvePins(valve_pins);
+    plants.setPumpPins(pump_pins);
+    plants.setSwitchPins(switch_pins, true);
 
     Serial.println("Setting up LCD, please wait");
     delay(1000); // give LCD some time to boot