add ability to trigger watering cycles via MQTT

README.md

 You can of course also use pio to flash your targets.
 
 There is also an optional Telegram bot integration.
+
+## Optional Networking Interfaces
+
+There are both a Telegram bot implementation, as well as an MQTT client implemented in Giess-o-mat.
+Telegram allows control even from the Internet, but unfortunately polling for new messages is very time consuming.
+So I would not recommend enabling it if you also want to use the I2C UI.
+
 Register a new bot with the Telegram botfather and put the token into wifi.h as TELEGRAM_TOKEN.
 Compile and run the project, then send a message to the bot.
 Look for the chat ID in the log and put it into wifi.h in TRUSTED_IDS.
     echo '#define TELEGRAM_TOKEN "XXXXXXXXX:XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"' >> include/wifi.h
     echo '#define TRUSTED_IDS { "1234", "5678" }' >> include/wifi.h
 
+MQTT is far less resource intensive, but also does not provide a bridge to the Internet.
+Enable it like this.
+The last two parameters are optional.
+
+    echo '#define MQTT_HOST "192.168.0.100"' >> include/wifi.h
+    echo '#define MQTT_PORT 1883' >> include/wifi.h
+    echo '#define MQTT_USER "USERNAME"' >> include/wifi.h
+    echo '#define MQTT_PASS "PASSWORD"' >> include/wifi.h
+
 ## Hardware
 
 In general, the project consists of two parts, the controller and the ui.

include/Functionality.h

 
 bool sm_is_idle(void);
 
-#ifdef TELEGRAM_TOKEN
+#if defined(TELEGRAM_TOKEN) || defined(MQTT_HOST)
 void sm_bot_abort(void);
 void sm_bot_start_auto(BoolField ferts, BoolField plants);
-#endif // TELEGRAM_TOKEN
+#endif // TELEGRAM_TOKEN || MQTT_HOST
 
 #endif // FUNCTION_CONTROL
 

include/Statemachine.h

     const char *getStateName(void);
     bool isIdle(void);
 
-#ifdef TELEGRAM_TOKEN
+#if defined(TELEGRAM_TOKEN) || defined(MQTT_HOST)
     void bot_abort(void);
     void bot_start_auto(BoolField ferts, BoolField plants);
-#endif // TELEGRAM_TOKEN
+#endif // TELEGRAM_TOKEN || MQTT_HOST
     
 private:
     void switch_to(States s);

include/config.h

 #define LED_CONNECT_BLINK_INTERVAL 250
 #define LED_ERROR_BLINK_INTERVAL 100
 #define TELEGRAM_UPDATE_INTERVAL_SLOW (10 * 1000)
-#define TELEGRAM_UPDATE_INTERVAL_FAST (3 * 1000)
+#define TELEGRAM_UPDATE_INTERVAL_FAST (2 * 1000)
+#define MQTT_RECONNECT_INTERVAL (5 * 1000)
 
 // each attempt takes LED_CONNECT_BLINK_INTERVAL ms
 #define MAX_WIFI_CONNECT_ATTEMPTS 40

platformio.ini

     https://github.com/RobTillaart/PCF8574
     https://github.com/bblanchon/ArduinoJson
     https://github.com/witnessmenow/Universal-Arduino-Telegram-Bot
+    https://github.com/knolleary/pubsubclient.git#2d228f2f862a95846c65a8518c79f48dfc8f188c
 
 [env:esp32_main]
 platform = platformio/espressif32@3.5.0
     https://github.com/RobTillaart/PCF8574
     https://github.com/bblanchon/ArduinoJson
     https://github.com/witnessmenow/Universal-Arduino-Telegram-Bot
+    https://github.com/knolleary/pubsubclient.git#2d228f2f862a95846c65a8518c79f48dfc8f188c
 
 [env:arduino_ui]
 platform = atmelavr

src/Functionality.cpp

     return sm.isIdle();
 }
 
-#ifdef TELEGRAM_TOKEN
+#if defined(TELEGRAM_TOKEN) || defined(MQTT_HOST)
 
 void sm_bot_abort(void) {
     sm.bot_abort();
     sm.bot_start_auto(ferts, plants);
 }
 
-#endif // TELEGRAM_TOKEN
+#endif // TELEGRAM_TOKEN || MQTT_HOST
 
 #endif // FUNCTION_CONTROL
 

src/Statemachine.cpp

     switch_to(init);
 }
 
-#ifdef TELEGRAM_TOKEN
+#if defined(TELEGRAM_TOKEN) || defined(MQTT_HOST)
 
 void Statemachine::bot_abort(void) {
     plants.abort();
     }
 }
 
-#endif // TELEGRAM_TOKEN
+#endif // TELEGRAM_TOKEN || MQTT_HOST
 
 void Statemachine::input(int n) {
     if (state == init) {

src/WifiStuff.cpp

 unsigned long last_telegram_time = 0;
 String trusted_chat_ids[] = TRUSTED_IDS;
 
+enum telegram_state {
+    BOT_IDLE,
+    BOT_ASKED_FERT,
+    BOT_ASKED_PLANTS,
+    BOT_ASKED_CONFIRM
+};
+
+enum telegram_state bot_state = BOT_IDLE;
+String bot_lock = "";
+BoolField bot_plants(VALVE_COUNT - 1);
+BoolField bot_ferts(PUMP_COUNT);
+
 #endif // TELEGRAM_TOKEN
 
+#ifdef MQTT_HOST
+#include <PubSubClient.h>
+WiFiClient mqttClient;
+PubSubClient mqtt(mqttClient);
+unsigned long last_mqtt_reconnect_time = 0;
+BoolField mqtt_plants(VALVE_COUNT - 1);
+BoolField mqtt_ferts(PUMP_COUNT);
+#endif // MQTT_HOST
+
 UPDATE_WEB_SERVER server(80);
 WebSocketsServer socket = WebSocketsServer(81);
 SimpleUpdater updater;
         bot.sendMessage(trusted_chat_ids[n], "New state: " + String(s), "");
     }
 #endif // TELEGRAM_TOKEN
+
+#ifdef MQTT_HOST
+    mqtt.publish("giessomat", s);
+#endif // MQTT_HOST
 }
 
 #ifdef TELEGRAM_TOKEN
-enum telegram_state {
-    BOT_IDLE,
-    BOT_ASKED_FERT,
-    BOT_ASKED_PLANTS,
-    BOT_ASKED_CONFIRM
-};
-
-enum telegram_state bot_state = BOT_IDLE;
-String bot_lock = "";
-BoolField bot_plants(VALVE_COUNT - 1);
-BoolField bot_ferts(PUMP_COUNT);
 
 unsigned long telegram_update_interval() {
     if (bot_state == BOT_IDLE) {
 }
 #endif // TELEGRAM_TOKEN
 
+#ifdef MQTT_HOST
+
+static void mqttCallback(char* topic, byte* payload, unsigned int length) {
+    String ts(topic), ps;
+    for (unsigned int i = 0; i < length; i++) {
+        char c = payload[i];
+        ps += c;
+    }
+
+    debug.println("MQTT Rx @ " + ts + ": " + ps);
+
+    if (ts != "giessomat") {
+        debug.println("MQTT: invalid topic");
+        return;
+    }
+
+    if (ps == "abort") {
+        if (sm_is_idle()) {
+            debug.println("MQTT: nothing to abort");
+        } else {
+            sm_bot_abort();
+            debug.println("MQTT: user abort");
+        }
+    } else {
+        if (ps.substring(0, 4) != "auto") {
+            debug.println("MQTT: invalid payload");
+            return;
+        }
+
+        mqtt_ferts.clear();
+        mqtt_plants.clear();
+
+        String buff;
+        bool at_plants = false;
+        for (int i = 5; i < ps.length() + 1; i++) {
+            if ((i == ps.length()) || (ps[i] == ' ') || (ps[i] == ',')) {
+                if (buff != "none") {
+                    int n = buff.toInt() - 1;
+                    if (!at_plants) {
+                        mqtt_ferts.set(n);
+                    } else {
+                        mqtt_plants.set(n);
+                    }
+                }
+                buff = "";
+
+                if ((i < ps.length()) && (ps[i] == ' ')) {
+                    at_plants = true;
+                }
+            } else {
+                buff += ps[i];
+            }
+        }
+
+        String s = "MQTT: fertilizers:";
+        for (int i = 0; i < PUMP_COUNT; i++) {
+            if (mqtt_ferts.isSet(i)) {
+                s += " " + String(i + 1);
+            }
+        }
+        debug.println(s);
+
+        s = "MQTT: plants:";
+        for (int i = 0; i < (VALVE_COUNT - 1); i++) {
+            if (mqtt_plants.isSet(i)) {
+                s += " " + String(i + 1);
+            }
+        }
+        debug.println(s);
+
+        if (mqtt_plants.countSet() <= 0) {
+            debug.println("MQTT: no plants selected");
+            return;
+        }
+
+#ifdef FULLAUTO_MIN_PLANT_COUNT
+        if (mqtt_plants.countSet() < FULLAUTO_MIN_PLANT_COUNT) {
+            debug.println("MQTT: not enough plants selected");
+            return;
+        }
+#endif
+
+        sm_bot_start_auto(mqtt_ferts, mqtt_plants);
+    }
+}
+
+static void mqttReconnect() {
+    // Create a random client ID
+    String clientId = F("giessomat-");
+    clientId += String(random(0xffff), HEX);
+
+    // Attempt to connect
+#if defined(MQTT_USER) && defined(MQTT_PASS)
+    if (mqtt.connect(clientId.c_str(), MQTT_USER, MQTT_PASS)) {
+#else
+    if (mqtt.connect(clientId.c_str())) {
+#endif
+        mqtt.subscribe("giessomat");
+    }
+}
+
+#endif // MQTT_HOST
+
 bool wifi_write_database(int duration, const char *type, int id) {
     bool success = false;
 
     message += F("</p>\n");
 
     message += F("<p>\n");
+#ifdef MQTT_HOST
+    message += F("MQTT: ");
+    message += MQTT_HOST;
+    message += F(":");
+    message += String(MQTT_PORT);
+    message += F("\n");
+#else
+    message += F("MQTT not enabled!\n");
+#endif
+    message += F("</p>\n");
+
+    message += F("<p>\n");
 #ifdef ENABLE_INFLUXDB_LOGGING
     message += F("InfluxDB: ");
     message += INFLUXDB_DATABASE;
     telegram_hello();
 #endif // TELEGRAM_TOKEN
 
+#ifdef MQTT_HOST
+    debug.println("WiFi: initializing MQTT");
+    mqtt.setServer(MQTT_HOST, MQTT_PORT);
+    mqtt.setCallback(mqttCallback);
+#endif // MQTT_HOST
+
     server.begin();
     MDNS.addService("http", "tcp", 80);
     MDNS.addService("http", "tcp", 81);
 }
 
 void wifi_run() {
-    // reset ESP every 6h to be safe
-    if ((millis() >= (6UL * 60UL * 60UL * 1000UL)) && (sm_is_idle())) {
-        ESP.restart();
-    }
-
     if (!wifi_ok) {
         // nothing to handle
         return;
         last_telegram_time = millis();
     }
 #endif // TELEGRAM_TOKEN
+
+#ifdef MQTT_HOST
+    if (!mqtt.connected() && ((millis() - last_mqtt_reconnect_time) >= MQTT_RECONNECT_INTERVAL)) {
+        last_mqtt_reconnect_time = millis();
+        mqttReconnect();
+    }
+
+    mqtt.loop();
+#endif // MQTT_HOST
 }
 
 #endif // PLATFORM_ESP