add support for kickstarting gravity-fed valves with a pump.

include/GPIOBank.h

     ~GPIOBank(void);
     
     void setPinNumbers(int _pins[]);
+    int getPinNumber(int pin);
     void setOutput(void);
     void setInput(bool pullup);
     

include/Plants.h

     void setPumpPins(int pins[]);
     void setSwitchPins(int pins[], bool pullup);
     void setAuxPins(int pins[]);
+    void setKickstartPins(int pins[]);
     
     void abort(void);
     
     void stopAllFertilizers(void);
     
     int countPlants(void);
-    void startPlant(int id);
+    void startPlant(int id, bool do_kickstart);
     void stopPlant(int id);
     void stopAllPlants(void);
 
     GPIOBank *getPumps(void);
     GPIOBank *getSwitches(void);
     GPIOBank *getAux(void);
+    GPIOBank *getKickstart(void);
     
 private:
     GPIOBank valves;
     GPIOBank pumps;
     GPIOBank switches;
     GPIOBank aux;
+    GPIOBank kickstart;
 };
 
 extern Plants plants;

include/Statemachine.h

         auto_tank_run,
         auto_stirr_run,
         auto_plant, // select plant
+        auto_plant_kickstart_run,
         auto_plant_run,
         auto_done,
 
         fillnwater_plant, // select plants
         fillnwater_tank_run,
+        fillnwater_kickstart_run,
         fillnwater_plant_run,
 
         automation_mode,

include/config.h

 #define MAX_PUMP_RUNTIME 30
 #define MAX_VALVE_RUNTIME (45 * 60)
 #define MAX_AUX_RUNTIME (5 * 60)
+#define KICKSTART_RUNTIME 10
 
 // Sketch version
-#define FIRMWARE_VERSION "0.4"
+#define FIRMWARE_VERSION "0.5"
 
 // all given in milliseconds
 #define SERVER_HANDLE_INTERVAL 10
 #define INFLUXDB_DATABASE "giessomat"
 
 #define DOOR_LOCK_PIN 4223
-#define DOOR_LOCK_ON_TIME 100 /* in ms */
 #define DOOR_LOCK_PIN_MAX_DIGITS 6
+#define DOOR_LOCK_ON_TIME 200 /* in ms */
+#define DOOR_LOCK_NEXT_DELAY 100 /* in ms */
 
 #endif // _CONFIG_H_

include/config_pins.h

  * PCF8574: 0x20 - 0x27
  * PCF8574A: 0x38 - 0x3F
  */
-#define I2C_GPIO_EXPANDER_COUNT 1
-#define I2C_GPIO_EXPANDER_ADDR 0x20
+#define I2C_GPIO_EXPANDER_COUNT 2
+#define I2C_GPIO_EXPANDER_ADDR 0x20, 0x21
 
 /*
  * GPIO Numbering Scheme
 #define VALVE_COUNT (PLANT_COUNT + 1)
 #define VALVE_PINS PLANT_PINS, INLET_PIN
 
+// kickstarting pumps, same count as plants!
+// set pin to -1 to disable kickstart for this plant.
+#define KICKSTART_PINS -1, -1, -1, -1, 108, 109, 110, 111
+
 // a, b, c
 #define PUMP_COUNT 3
 #define PUMP_PINS 2, 0, 4

src/Functionality.cpp

 int pump_pins[PUMP_COUNT] = { PUMP_PINS };
 int switch_pins[SWITCH_COUNT] = { SWITCH_PINS };
 int aux_pins[AUX_COUNT] = { AUX_PINS };
+int kickstart_pins[VALVE_COUNT - 1] = { KICKSTART_PINS };
 
 Statemachine sm(write_to_all, backspace);
 
     plants.setPumpPins(pump_pins);
     plants.setSwitchPins(switch_pins, true);
     plants.setAuxPins(aux_pins);
+    plants.setKickstartPins(kickstart_pins);
 }
 
 void control_begin(void) {

src/GPIOBank.cpp

 // ----------------------------------------------------------------------------
 
 #if (I2C_GPIO_EXPANDER_COUNT > 0)
+static uint8_t expand_addr[I2C_GPIO_EXPANDER_COUNT] = { I2C_GPIO_EXPANDER_ADDR };
 static PCF8574 expand[I2C_GPIO_EXPANDER_COUNT];
 #endif
 
 void gpio_i2c_init(void) {
 #if (I2C_GPIO_EXPANDER_COUNT > 0)
     for (int i = 0; i < I2C_GPIO_EXPANDER_COUNT; i++) {
+        expand[i].setAddress(expand_addr[i]);
         expand[i].begin(0xFF);
     }
 #endif
 static void gpio_pinMode(int pin, int value) {
     if (pin < 100) {
         pinMode(pin, value);
+    } else if (pin < 0) {
+        // ignore negative pin numbers
     } else {
         pin -= 100;
         int ex = pin / 8;
 static void gpio_digitalWrite(int pin, int value) {
     if (pin < 100) {
         digitalWrite(pin, value);
+    } else if (pin < 0) {
+        // ignore negative pin numbers
     } else {
         pin -= 100;
         int ex = pin / 8;
 static int gpio_digitalRead(int pin) {
     if (pin < 100) {
         return digitalRead(pin);
+    } else if (pin < 0) {
+        // ignore negative pin numbers
+        return 0;
     } else {
         pin -= 100;
         int ex = pin / 8;
     }
 }
 
+int GPIOBank::getPinNumber(int pin) {
+    if ((pin >= 0) && (pin < size)) {
+        return pins[pin];
+    } else {
+        return -1;
+    }
+}
+
 void GPIOBank::setOutput(void) {
     for (int i = 0; i < size; i++) {
 #ifdef GPIO_HIGH_AS_INPUT

src/Plants.cpp

 // pumps: no of fertilizers
 // switches: 2, low and high level
 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) {
+        valves(valve_count), pumps(pump_count), switches(switch_count), aux(aux_count),
+        kickstart(valve_count - 1) {
 }
-
     
 GPIOBank *Plants::getValves(void) {
     return &valves;
     return &aux;
 }
 
+GPIOBank *Plants::getKickstart(void) {
+    return &kickstart;
+}
+
 void Plants::setValvePins(int pins[]) {
     valves.setPinNumbers(pins);
     valves.setOutput();
     aux.setAll(false);
 }
 
+void Plants::setKickstartPins(int pins[]) {
+    kickstart.setPinNumbers(pins);
+    kickstart.setOutput();
+    kickstart.setAll(false);
+}
+
 void Plants::abort(void) {
     closeWaterInlet();
     stopAllFertilizers();
     return valves.getSize() - 1;
 }
 
-void Plants::startPlant(int id) {
+void Plants::startPlant(int id, bool do_kickstart) {
     debug.print("Plants::startPlant ");
-    debug.println(id);
+    debug.print(id);
+    debug.print(", ");
+    debug.println(do_kickstart);
     
     if ((id >= 0) && (id < countPlants())) {
-        valves.setPin(id, true);
+        if (do_kickstart) {
+            valves.setPin(id, false);
+            kickstart.setPin(id, true);
+        } else {
+            kickstart.setPin(id, false);
+            valves.setPin(id, true);
+        }
     }
 }
 
     
     if ((id >= 0) && (id < countPlants())) {
         valves.setPin(id, false);
+        kickstart.setPin(id, false);
     }
 }
 

src/Statemachine.cpp

     stringify(auto_tank_run),
     stringify(auto_stirr_run),
     stringify(auto_plant),
+    stringify(auto_plant_kickstart_run),
     stringify(auto_plant_run),
     stringify(auto_done),
     stringify(fillnwater_plant),
     stringify(fillnwater_tank_run),
+    stringify(fillnwater_kickstart_run),
     stringify(fillnwater_plant_run),
     stringify(automation_mode),
     stringify(menu_pumps),
                         plants.startAux(STIRRER_COUNT + i);
                         delay(DOOR_LOCK_ON_TIME);
                         plants.stopAux(STIRRER_COUNT + i);
+                        delay(DOOR_LOCK_NEXT_DELAY);
                     }
                 }
                 plants.stopAllAux();
             switch_to((state == auto_fert_a) ? auto_fert_b : auto_fert_a);
         }
     } else if ((state == auto_fert_run) || (state == auto_tank_run)
-            || (state == auto_stirr_run)) {
+            || (state == auto_stirr_run) || (state == auto_plant_run)
+            || (state == auto_plant_kickstart_run)
+            || (state == fillnwater_kickstart_run)) {
         plants.abort();
         stop_time = millis();
         switch_to(auto_done);
             if (!db.hasDigits()) {
                 auto wl = plants.getWaterlevel();
                 if ((wl != Plants::empty) && (wl != Plants::invalid)) {
+                    // check if kickstart is required for this
+                    bool need_kickstart = false;
+                    for (int i = 0; i < plants.countPlants(); i++) {
+                        if (selected_plants.isSet(i)) {
+                            if (plants.getKickstart()->getPinNumber(i) >= 0) {
+                                need_kickstart = true;
+                            }
+                        }
+                    }
+
+                    // start kickstart/valve as needed
                     for (int i = 0; i < plants.countPlants(); i++) {
                         if (selected_plants.isSet(i)) {
-                            plants.startPlant(i);
+                            plants.startPlant(i, need_kickstart);
                         }
                     }
                     
                     selected_time = MAX_AUTO_PLANT_RUNTIME;
                     start_time = millis();
-                    switch_to(auto_plant_run);
+                    if (need_kickstart) {
+                        switch_to(auto_plant_kickstart_run);
+                    } else {
+                        switch_to(auto_plant_run);
+                    }
                 } else if (wl == Plants::empty) {
                     stop_time = millis();
                     switch_to(auto_mode_b);
                 backspace();
             }
         }
-    } else if (state == auto_plant_run) {
-        plants.abort();
-        stop_time = millis();
-        switch_to(auto_done);
     } else if (state == auto_done) {
         switch_to(auto_mode_a);
     } else if (state == menu_pumps) {
                         stop_time = millis();
                         auto wl = plants.getWaterlevel();
                         if ((wl != Plants::empty) && (wl != Plants::invalid)) {
+                            // check if kickstart is required for this
+                            bool need_kickstart = false;
                             for (int i = 0; i < plants.countPlants(); i++) {
                                 if (selected_plants.isSet(i)) {
-                                    plants.startPlant(i);
+                                    if (plants.getKickstart()->getPinNumber(i) >= 0) {
+                                        need_kickstart = true;
+                                    }
+                                }
+                            }
+
+                            // start kickstart/valve as needed
+                            for (int i = 0; i < plants.countPlants(); i++) {
+                                if (selected_plants.isSet(i)) {
+                                    plants.startPlant(i, need_kickstart);
                                 }
                             }
 
 
                             selected_time = MAX_AUTO_PLANT_RUNTIME;
                             start_time = millis();
-                            switch_to(fillnwater_plant_run);
+                            if (need_kickstart) {
+                                switch_to(fillnwater_kickstart_run);
+                            } else {
+                                switch_to(fillnwater_plant_run);
+                            }
                         } else if (wl == Plants::empty) {
                             stop_time = millis();
                             switch_to(auto_mode_a);
         stop_time = millis();
         auto wl = plants.getWaterlevel();
         if ((wl != Plants::empty) && (wl != Plants::invalid)) {
+            // check if kickstart is required for this
+            bool need_kickstart = false;
             for (int i = 0; i < plants.countPlants(); i++) {
                 if (selected_plants.isSet(i)) {
-                    plants.startPlant(i);
+                    if (plants.getKickstart()->getPinNumber(i) >= 0) {
+                        need_kickstart = true;
+                    }
+                }
+            }
+
+            // start kickstart/valve as needed
+            for (int i = 0; i < plants.countPlants(); i++) {
+                if (selected_plants.isSet(i)) {
+                    plants.startPlant(i, need_kickstart);
                 }
             }
 
 
             selected_time = MAX_AUTO_PLANT_RUNTIME;
             start_time = millis();
-            switch_to(fillnwater_plant_run);
+            if (need_kickstart) {
+                switch_to(fillnwater_kickstart_run);
+            } else {
+                switch_to(fillnwater_plant_run);
+            }
         } else if (wl == Plants::empty) {
             switch_to(auto_mode_a);
         } else if (wl == Plants::invalid) {
                 if (selected_id >= (plants.countPlants() + 1)) {
                     plants.openWaterInlet();
                 } else {
-                    plants.startPlant(selected_id - 1);
+                    // TODO support testing kickstart
+                    plants.startPlant(selected_id - 1, false);
                 }
                 
                 switch_to(menu_valves_run);
             switch_to(state);
         }
     }
-    
+
 #ifdef CHECK_SENSORS_VALVE_PUMP_MENU_FULL
     if ((state == menu_pumps_run) || ((state == menu_valves_run) && (selected_id == (plants.countPlants() + 1)))) {
         // check water level state
         }
     }
 #endif // CHECK_SENSORS_VALVE_PUMP_MENU_FULL
-    
+
 #ifdef CHECK_SENSORS_VALVE_PUMP_MENU_EMPTY
     if ((state == menu_valves_run) && (selected_id <= plants.countPlants())) {
         // check water level state
         }
     }
 #endif // CHECK_SENSORS_VALVE_PUMP_MENU_EMPTY
-    
+
+    if ((state == auto_plant_kickstart_run) || (state == fillnwater_kickstart_run)) {
+        unsigned long runtime = millis() - start_time;
+        if ((runtime / 1000UL) >= KICKSTART_RUNTIME) {
+            // kickstart is done, switch over to valves
+            plants.abort();
+            start_time = millis();
+
+            // start required valves
+            for (int i = 0; i < plants.countPlants(); i++) {
+                if (selected_plants.isSet(i)) {
+                    plants.startPlant(i, false);
+                }
+            }
+
+            if (state == auto_plant_kickstart_run) {
+                switch_to(auto_plant_run);
+            } else {
+                switch_to(fillnwater_plant_run);
+            }
+        } else if ((millis() - last_animation_time) >= 500) {
+            // update animation if needed
+            last_animation_time = millis();
+            switch_to(state);
+        }
+    }
+
     if ((state == auto_fert_run) || (state == auto_tank_run) || (state == fillnwater_tank_run)) {
         unsigned long runtime = millis() - start_time;
         if ((runtime / 1000UL) >= selected_time) {
             if (state == fillnwater_tank_run) {
                 auto wl = plants.getWaterlevel();
                 if ((wl != Plants::empty) && (wl != Plants::invalid)) {
+                    // check if kickstart is required for this
+                    bool need_kickstart = false;
                     for (int i = 0; i < plants.countPlants(); i++) {
                         if (selected_plants.isSet(i)) {
-                            plants.startPlant(i);
+                            if (plants.getKickstart()->getPinNumber(i) >= 0) {
+                                need_kickstart = true;
+                            }
+                        }
+                    }
+
+                    // start kickstart/valve as needed
+                    for (int i = 0; i < plants.countPlants(); i++) {
+                        if (selected_plants.isSet(i)) {
+                            plants.startPlant(i, need_kickstart);
                         }
                     }
 
 
                     selected_time = MAX_AUTO_PLANT_RUNTIME;
                     start_time = millis();
-                    switch_to(fillnwater_plant_run);
+                    if (need_kickstart) {
+                        switch_to(fillnwater_kickstart_run);
+                    } else {
+                        switch_to(fillnwater_plant_run);
+                    }
                 } else if (wl == Plants::empty) {
                     stop_time = millis();
                     switch_to(auto_done);
 
                 auto wl = plants.getWaterlevel();
                 if ((wl != Plants::empty) && (wl != Plants::invalid)) {
+                    // check if kickstart is required for this
+                    bool need_kickstart = false;
                     for (int i = 0; i < plants.countPlants(); i++) {
                         if (selected_plants.isSet(i)) {
-                            plants.startPlant(i);
+                            if (plants.getKickstart()->getPinNumber(i) >= 0) {
+                                need_kickstart = true;
+                            }
+                        }
+                    }
+
+                    // start kickstart/valve as needed
+                    for (int i = 0; i < plants.countPlants(); i++) {
+                        if (selected_plants.isSet(i)) {
+                            plants.startPlant(i, need_kickstart);
                         }
                     }
 
 
                     selected_time = MAX_AUTO_PLANT_RUNTIME;
                     start_time = millis();
-                    switch_to(fillnwater_plant_run);
+                    if (need_kickstart) {
+                        switch_to(fillnwater_kickstart_run);
+                    } else {
+                        switch_to(fillnwater_plant_run);
+                    }
                 } else if (wl == Plants::empty) {
                     stop_time = millis();
                     switch_to(auto_mode_a);
               a.c_str(),
               b.c_str(),
               3);
+    } else if ((s == auto_plant_kickstart_run) || (s == fillnwater_kickstart_run)) {
+        unsigned long runtime = millis() - start_time;
+        String a = String("Time: ") + String(runtime / 1000UL) + String("s / ") + String(KICKSTART_RUNTIME) + String('s');
+
+        unsigned long anim = runtime * 20UL / (KICKSTART_RUNTIME * 1000UL);
+        String b;
+        for (unsigned long i = 0; i < anim; i++) {
+            b += '#';
+        }
+
+        print("---- Kick-Start ----",
+              a.c_str(),
+              b.c_str(),
+              "Hit any key to stop!",
+              -1);
     } else if ((s == auto_plant_run) || (s == fillnwater_plant_run)) {
         unsigned long runtime = millis() - start_time;
         String a = String("Time: ") + String(runtime / 1000UL) + String("s / ") + String(selected_time) + String('s');

src/WifiStuff.cpp

         }
     }
     ws += " ],\n";
+
+    ws += F("\"kickstart\": [ ");
+    for (int i = 0; i < VALVE_COUNT - 1; i++) {
+        ws += "\"";
+        ws += get_plants()->getKickstart()->getPin(i) ? "1" : "0";
+        ws += "\"";
+
+        if (i < (VALVE_COUNT - 2)) {
+            ws += ", ";
+        }
+    }
+    ws += " ],\n";
     
     ws += "\"switchstate\": \"";
     Plants::Waterlevel wl = get_plants()->getWaterlevel();
     message += F("font-family: monospace;\n");
     message += F("}\n");
     
-    message += F(".switch {\n");
-    message += F("width: max-content;\n");
-    message += F("border: 1px solid black;\n");
-    message += F("border-radius: 50%;\n");
-    message += F("padding: 2em;\n");
-    message += F("margin: 1em;\n");
-    message += F("}\n");
-    
-    message += F(".valve {\n");
-    message += F("width: max-content;\n");
-    message += F("border: 1px solid black;\n");
-    message += F("border-radius: 50%;\n");
-    message += F("padding: 2em;\n");
-    message += F("margin: 1em;\n");
-    message += F("}\n");
-    
-    message += F(".pump {\n");
-    message += F("width: max-content;\n");
-    message += F("border: 1px solid black;\n");
-    message += F("border-radius: 50%;\n");
-    message += F("padding: 2em;\n");
-    message += F("margin: 1em;\n");
-    message += F("}\n");
-
-    message += F(".aux {\n");
+    message += F(".ioelem {\n");
     message += F("width: max-content;\n");
     message += F("border: 1px solid black;\n");
     message += F("border-radius: 50%;\n");
     
     message += F("<div class='container'>\n");
     for (int i = 0; i < SWITCH_COUNT; i++) {
-        message += F("<div class='switch' style='background-color: ");
+        message += F("<div class='ioelem switch' style='background-color: ");
         bool v = get_plants()->getSwitches()->getPin(i);
         
 #ifdef INVERT_SENSOR_BOTTOM
     message += F("Valves:\n");
     message += F("<div class='container'>\n");
     for (int i = 0; i < VALVE_COUNT; i++) {
-        message += F("<div class='valve' style='background-color: ");
+        message += F("<div class='ioelem valve' style='background-color: ");
         if (get_plants()->getValves()->getPin(i)) {
             message += F("red");
         } else {
     message += F("Pumps:\n");
     message += F("<div class='container'>\n");
     for (int i = 0; i < PUMP_COUNT; i++) {
-        message += F("<div class='pump' style='background-color: ");
+        message += F("<div class='ioelem pump' style='background-color: ");
         if (get_plants()->getPumps()->getPin(i)) {
             message += F("red");
         } else {
     message += F("Aux:\n");
     message += F("<div class='container'>\n");
     for (int i = 0; i < AUX_COUNT; i++) {
-        message += F("<div class='aux' style='background-color: ");
+        message += F("<div class='ioelem aux' style='background-color: ");
         if (get_plants()->getAux()->getPin(i)) {
             message += F("red");
         } else {
     }
     message += F("</div><hr>\n");
 
+    message += F("Kickstart:\n");
+    message += F("<div class='container'>\n");
+    for (int i = 0; i < VALVE_COUNT - 1; i++) {
+        message += F("<div class='ioelem kickstart' style='background-color: ");
+        if (get_plants()->getKickstart()->getPin(i)) {
+            message += F("red");
+        } else {
+            message += F("green");
+        }
+        message += F(";'>A");
+        message += String(i + 1);
+        message += F("</div>");
+    }
+    message += F("</div><hr>\n");
+
     message += F("Green means valve is closed / pump is off / switch is not submersed.\n");
     message += F("<br>\n");
     message += F("Red means valve is open / pump is running / switch is submersed.</div>\n");
     message += F(           "aux[i].style = 'background-color: red;';\n");
     message += F(       "}\n");
     message += F(    "}\n");
+
+    message += F(    "for (let i = 0; i < ");
+    message += String(VALVE_COUNT - 1);
+    message += F("; i++) {\n");
+    message += F(       "var kickstart = document.getElementsByClassName('kickstart');\n");
+    message += F(       "if (msg.kickstart[i] == '0') {\n");
+    message += F(           "kickstart[i].style = 'background-color: green;';\n");
+    message += F(       "} else {\n");
+    message += F(           "kickstart[i].style = 'background-color: red;';\n");
+    message += F(       "}\n");
+    message += F(    "}\n");
     
     message += F(    "var switchstate = document.getElementById('switchstate');\n");
     message += F(    "switchstate.innerHTML = msg.switchstate;\n");