add aux relais channels and fertilizer stirring menu.

include/Plants.h

     // 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);
+    Plants(int valve_count, int pump_count, int switch_count, int aux_count);
     
     void setValvePins(int pins[]);
     void setPumpPins(int pins[]);
     void setSwitchPins(int pins[], bool pullup);
+    void setAuxPins(int pins[]);
     
     void abort(void);
     
     void startPlant(int id);
     void stopPlant(int id);
     void stopAllPlants(void);
+
+    int countAux(void);
+    void startAux(int id);
+    void stopAux(int id);
+    void stopAllAux(void);
     
     GPIOBank *getValves(void);
     GPIOBank *getPumps(void);
     GPIOBank *getSwitches(void);
+    GPIOBank *getAux(void);
     
 private:
     GPIOBank valves;
     GPIOBank pumps;
     GPIOBank switches;
+    GPIOBank aux;
 };
 
 extern Plants plants;

include/Statemachine.h

         init = 0,
         menu_a, // manual, auto
         menu_b, // pumps, valves
+        menu_c, // aux
         
         auto_mode_a, // select mode 1
         auto_mode_b, // select mode 2
-        auto_fert, // select fertilizer
+        auto_fert_a, // select fertilizer 1
+        auto_fert_b, // select fertilizer 2
         auto_fert_run,
         auto_tank_run,
+        auto_stirr_run,
         auto_plant, // select plant
         auto_plant_run,
         auto_done,
         menu_valves_run,
         menu_valves_done,
         
+        menu_aux, // select aux channel
+        menu_aux_time, // set runtime
+        menu_aux_go, // running
+        menu_aux_run,
+        menu_aux_done,
+
         error
     };
     

include/config.h

 // in seconds
 #define MAX_TANK_FILL_TIME (67 + 3)
 #define AUTO_PUMP_RUNTIME 5
+#define AUTO_STIRR_RUNTIME 60
 #define MAX_AUTO_PLANT_RUNTIME (35 * 60)
 #define MAX_PUMP_RUNTIME 30
 #define MAX_VALVE_RUNTIME (45 * 60)
+#define MAX_AUX_RUNTIME (5 * 60)
 
 // Sketch version
 #define FIRMWARE_VERSION "0.2"

include/config_pins.h

 #define SWITCH_COUNT 2
 #define SWITCH_PINS 19, 20
 
+// stirrer
+#define AUX_COUNT 1
+#define AUX_PINS 21
+
 #endif // FUNCTION_CONTROL
 
 #endif // PLATFORM_AVR
 #define PUMP_COUNT 3
 #define PUMP_PINS 2, 0, 4
 
+// stirrer
+#define AUX_COUNT 1
+#define AUX_PINS 19
+
 // bottom, top
 #define SWITCH_COUNT 2
 #define SWITCH_PINS 26, 25

src/Functionality.cpp

 #include "Statemachine.h"
 #include "WifiStuff.h"
 
-Plants plants(VALVE_COUNT, PUMP_COUNT, SWITCH_COUNT);
+Plants plants(VALVE_COUNT, PUMP_COUNT, SWITCH_COUNT, AUX_COUNT);
 int valve_pins[VALVE_COUNT] = { VALVE_PINS };
 int pump_pins[PUMP_COUNT] = { PUMP_PINS };
 int switch_pins[SWITCH_COUNT] = { SWITCH_PINS };
+int aux_pins[AUX_COUNT] = { AUX_PINS };
 
 Statemachine sm(write_to_all, backspace);
 
     plants.setValvePins(valve_pins);
     plants.setPumpPins(pump_pins);
     plants.setSwitchPins(switch_pins, true);
+    plants.setAuxPins(aux_pins);
     
 #ifndef FUNCTION_UI
     

src/Plants.cpp

 // 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) {
+Plants::Plants(int valve_count, int pump_count, int switch_count, int aux_count) :
+        valves(valve_count), pumps(pump_count), switches(switch_count), aux(aux_count) {
 }
 
     
     return &switches;
 }
 
+GPIOBank *Plants::getAux(void) {
+    return &aux;
+}
+
 void Plants::setValvePins(int pins[]) {
     valves.setPinNumbers(pins);
     valves.setOutput();
     switches.setInput(pullup);
 }
 
+void Plants::setAuxPins(int pins[]) {
+    aux.setPinNumbers(pins);
+    aux.setOutput();
+    aux.setAll(false);
+}
+
 void Plants::abort(void) {
     closeWaterInlet();
     stopAllFertilizers();
     stopAllPlants();
+    stopAllAux();
 }
 
 Plants::Waterlevel Plants::getWaterlevel(void) {
         stopPlant(i);
     }
 }
+
+int Plants::countAux(void) {
+    return aux.getSize();
+}
+
+void Plants::startAux(int id) {
+    debug.print("Plants::startAux ");
+    debug.println(id);
+
+    if ((id >= 0) && (id < countAux())) {
+        aux.setPin(id, true);
+    }
+}
+
+void Plants::stopAux(int id) {
+    debug.print("Plants::stopAux ");
+    debug.println(id);
+
+    if ((id >= 0) && (id < countAux())) {
+        aux.setPin(id, false);
+    }
+}
+
+void Plants::stopAllAux(void) {
+    for (int i = 0; i < countAux(); i++) {
+        stopAux(i);
+    }
+}

src/Statemachine.cpp

     stringify(init),
     stringify(menu_a),
     stringify(menu_b),
+    stringify(menu_c),
     stringify(auto_mode_a),
     stringify(auto_mode_b),
-    stringify(auto_fert),
+    stringify(auto_fert_a),
+    stringify(auto_fert_b),
     stringify(auto_fert_run),
     stringify(auto_tank_run),
+    stringify(auto_stirr_run),
     stringify(auto_plant),
     stringify(auto_plant_run),
     stringify(auto_done),
     stringify(menu_valves_go),
     stringify(menu_valves_run),
     stringify(menu_valves_done),
+    stringify(menu_aux),
+    stringify(menu_aux_time),
+    stringify(menu_aux_go),
+    stringify(menu_aux_run),
+    stringify(menu_aux_done),
     stringify(error)
 };
 
 void Statemachine::input(int n) {
     if (state == init) {
         switch_to(menu_a);
-    } else if ((state == menu_a) || (state == menu_b)) {
+    } else if ((state == menu_a) || (state == menu_b) || (state == menu_c)) {
         if (n == 1) {
             switch_to(auto_mode_a);
         } else if (n == 2) {
             switch_to(menu_pumps);
         } else if (n == 4) {
             switch_to(menu_valves);
+        } else if (n == 5) {
+            switch_to(menu_aux);
         } else if (n == -1) {
             switch_to(init);
         } else if (n == -2) {
-            switch_to((state == menu_a) ? menu_b : menu_a);
+            switch_to((state == menu_a) ? menu_b : ((state == menu_b) ? menu_c : 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);
+            switch_to(auto_fert_a);
         } else if (n == 2) {
             selected_plants.clear();
             switch_to(fillnwater_plant);
         } else if (n == -2) {
             switch_to((state == auto_mode_a) ? auto_mode_b : auto_mode_a);
         }
-    } else if (state == auto_fert) {
+    } else if ((state == auto_fert_a) || (state == auto_fert_b)) {
         if ((n >= 1) && (n <= 3)) {
             auto wl = plants.getWaterlevel();
             if ((wl != Plants::full) && (wl != Plants::invalid)) {
                 state = auto_mode_a;
                 switch_to(error);
             }
-        } else if ((n == -1) || (n == -2)) {
+        } else if (n == 4) {
+            plants.startAux(0);
+            selected_id = 1;
+            selected_time = AUTO_STIRR_RUNTIME;
+            start_time = millis();
+            switch_to(auto_stirr_run);
+        } else if (n == -1) {
             switch_to(auto_mode_a);
+        } else if (n == -2) {
+            switch_to((state == auto_fert_a) ? auto_fert_b : auto_fert_a);
         }
-    } else if (state == auto_fert_run) {
-            plants.abort();
-            stop_time = millis();
-            switch_to(auto_done);
-    } else if (state == auto_tank_run) {
-            plants.abort();
-            stop_time = millis();
-            switch_to(auto_done);
+    } else if ((state == auto_fert_run) || (state == auto_tank_run)
+            || (state == auto_stirr_run)) {
+        plants.abort();
+        stop_time = millis();
+        switch_to(auto_done);
     } else if (state == auto_plant) {
         if (n == -1) {
             if (db.hasDigits()) {
             switch_to(menu_valves_time);
         }
     } else if (state == menu_valves_run) {
-            plants.abort();
-            stop_time = millis();
-            switch_to(menu_valves_done);
+        plants.abort();
+        stop_time = millis();
+        switch_to(menu_valves_done);
     } else if (state == menu_valves_done) {
         switch_to(menu_b);
+    } else if (state == menu_aux) {
+        if (n == -1) {
+            if (db.hasDigits()) {
+                backspace();
+                db.removeDigit();
+            } else {
+                switch_to(menu_c);
+            }
+        } else if (n == -2) {
+            if (!db.hasDigits()) {
+                return;
+            }
+
+            selected_id = number_input();
+
+            if ((selected_id <= 0) || (selected_id > plants.countAux())) {
+                error_condition = "Invalid valve ID!";
+                switch_to(error);
+            } else {
+                switch_to(menu_aux_time);
+            }
+        } else {
+            if (db.spaceLeft()) {
+                db.addDigit(n);
+            } else {
+                backspace();
+            }
+        }
+    } else if (state == menu_aux_time) {
+        if (n == -1) {
+            if (db.hasDigits()) {
+                backspace();
+                db.removeDigit();
+            } else {
+                switch_to(menu_aux);
+            }
+        } else if (n == -2) {
+            if (!db.hasDigits()) {
+                return;
+            }
+
+            selected_time = number_input();
+
+            if ((selected_time <= 0) || (selected_time > MAX_AUX_RUNTIME)) {
+                error_condition = "Invalid time range!";
+                switch_to(error);
+            } else {
+                switch_to(menu_aux_go);
+            }
+        } else {
+            if (db.spaceLeft()) {
+                db.addDigit(n);
+            } else {
+                backspace();
+            }
+        }
+    } else if (state == menu_aux_go) {
+        if (n == -2) {
+            start_time = millis();
+            last_animation_time = start_time;
+            plants.startAux(selected_id - 1);
+            switch_to(menu_aux_run);
+        } else {
+            switch_to(menu_aux_time);
+        }
+    } else if (state == menu_aux_run) {
+        plants.abort();
+        stop_time = millis();
+        switch_to(menu_aux_done);
+    } else if (state == menu_aux_done) {
+        switch_to(menu_c);
     } else if (state == error) {
         if (old_state != error) {
             switch_to(old_state);
 }
 
 void Statemachine::act(void) {
-    if ((state == menu_pumps_run) || (state == menu_valves_run)) {
+    if ((state == menu_pumps_run) || (state == menu_valves_run)
+            || (state == menu_aux_run)
+            || (state == auto_stirr_run)) {
         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_run) ? menu_pumps_done : menu_valves_done);
+            switch_to((state == menu_pumps_run) ? menu_pumps_done : ((state == menu_valves_run) ? menu_valves_done : ((state == menu_aux_run) ? menu_aux_done : auto_done)));
         } else if ((millis() - last_animation_time) >= 500) {
             // update animation if needed
             last_animation_time = millis();
         }
     }
 
-    if ((state == menu_a) || (state == menu_b) || (state == automation_mode)
+    if ((state == menu_a) || (state == menu_b) || (state == menu_c)
+            || (state == automation_mode) || (state == auto_done)
             || (state == auto_mode_a) || (state == auto_mode_b)
-            || (state == auto_fert) || (state == auto_done)
+            || (state == auto_fert_a) || (state == auto_fert_b)
             || (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)) {
+            || (state == menu_valves_go) || (state == menu_valves_done)
+            || (state == menu_aux) || (state == menu_aux_time)
+            || (state == menu_aux_go) || (state == menu_aux_done)) {
         unsigned long runtime = millis() - into_state_time;
         if (runtime >= BACK_TO_IDLE_TIMEOUT) {
             debug.print("Idle timeout reached in state ");
               "# Execute input num.",
               -1);
     } else if (s == menu_a) {
-        print("----- Menu 1/2 -----",
+        print("----- Menu 1/3 -----",
               "1: Manual Operation",
               "2: Automation",
-              "#: Go to page 2/2...",
+              "#: Go to page 2/3...",
               -1);
     } else if (s == menu_b) {
-        print("----- Menu 2/2 -----",
+        print("----- Menu 2/3 -----",
               "3: Fertilizer pumps",
               "4: Outlet valves",
-              "#: Go to page 1/2...",
+              "#: Go to page 3/3...",
+              -1);
+    } else if (s == menu_c) {
+        print("----- Menu 3/3 -----",
+              "5: Aux. Outputs",
+              "",
+              "#: Go to page 1/3...",
               -1);
     } else if (state == automation_mode) {
         // TODO
               "4: Water a plant",
               "#: Go to page 1/2...",
               -1);
-    } else if (s == auto_fert) {
-        print("---- Fertilizer ----",
+    } else if (s == auto_fert_a) {
+        print("-- Fertilizer 1/2 --",
               "1: Vegetation Phase",
               "2: Bloom Phase",
-              "3: Special",
+              "#: Go to page 2/2...",
+              -1);
+    } else if (s == auto_fert_b) {
+        print("-- Fertilizer 2/2 --",
+              "3: Special Fert.",
+              "4: Run Stirrer",
+              "#: Go to page 1/2...",
               -1);
     } else if (s == auto_fert_run) {
         unsigned long runtime = millis() - start_time;
               b.c_str(),
               "Hit any key to stop!",
               -1);
+    } else if (s == auto_stirr_run) {
+        unsigned long runtime = millis() - start_time;
+        String a = String("Time: ") + 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("----- Stirring -----",
+              a.c_str(),
+              b.c_str(),
+              "Hit any key to stop!",
+              -1);
     } else if ((s == auto_tank_run) || (s == fillnwater_tank_run)) {
         unsigned long runtime = millis() - start_time;
         String a = String("Time: ") + String(runtime / 1000UL) + String("s / ") + String(selected_time) + String('s');
             }
         }
 #endif // PLATFORM_ESP
+    } else if (s == menu_aux) {
+        String a = String("(Input 1 to ") + String(plants.countAux()) + String(")");
+
+        print("------- Aux. -------",
+              "Please select aux.",
+              a.c_str(),
+              "Aux.: ",
+              3);
+    } else if (s == menu_aux_time) {
+        String header = String("------ Aux  ") + String(selected_id) + String(" ------");
+
+        print(header.c_str(),
+              "Please set runtime",
+              "(Input in seconds)",
+              "Runtime: ",
+              3);
+    } else if (s == menu_aux_go) {
+        String a = String("Aux 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_aux_run) {
+        unsigned long runtime = millis() - start_time;
+        String a = String("Time: ") + 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("----- Stirring -----",
+              a.c_str(),
+              b.c_str(),
+              "Hit any key to stop!",
+              -1);
+    } else if (s == menu_aux_done) {
+        String a = String("after ") + String((stop_time - start_time) / 1000UL) + String("s.");
+
+        print("------- Done -------",
+              "Stirring finished",
+              a.c_str(),
+              "Hit any key for menu",
+              -1);
     } else if (s == error) {
         print("------ Error! ------",
               "There is a problem:",