Add Universal-Arduino-Telegram-Bot library and implement simple bot.

README.md

 
 You can of course also use pio to flash your targets.
 
+There is also an optional Telegram bot integration.
+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
+
 ## Hardware
 
 In general, the project consists of two parts, the controller and the ui.

include/Functionality.h

 #ifdef FUNCTION_CONTROL
 
 #include "Plants.h"
+#include "BoolField.h"
 
 void control_setup(void);
 void control_begin(void);
 
 Plants *get_plants(void);
 
+bool sm_is_idle(void);
+
+#ifdef TELEGRAM_TOKEN
+void sm_bot_abort(void);
+void sm_bot_start_auto(BoolField ferts, BoolField plants);
+#endif // TELEGRAM_TOKEN
+
 #endif // FUNCTION_CONTROL
 
 // ----------------------------------------------------------------------------
                   const char *c, const char *d, int num_input);
 void backspace(void);
 
-bool sm_is_idle(void);
-
 #endif // _FUNCTIONALITY_H_

include/Statemachine.h

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

include/WifiStuff.h

 void wifi_set_message_buffer(String a, String b, String c, String d);
 void wifi_schedule_websocket(void);
 void wifi_send_status_broadcast(void);
+void wifi_broadcast_state_change(const char *s);
 
 void wifi_send_websocket(String s);
 

include/config.h

 #define MAX_PUMP_RUNTIME 30
 #define MAX_VALVE_RUNTIME (45 * 60)
 #define MAX_AUX_RUNTIME (5 * 60)
-#define KICKSTART_RUNTIME 45
+#define KICKSTART_RUNTIME 60
 #define OVERRUN_RUNTIME 75
 #define PURGE_FILL_RUNTIME 20
 #define FULLAUTO_MIN_PLANT_COUNT 2
 #define FULLAUTO_END_PUMP_TIME 30
 
 // Sketch version
-#define FIRMWARE_VERSION "0.6"
+#define FIRMWARE_VERSION "0.7"
 
 // all given in milliseconds
-#define SERVER_HANDLE_INTERVAL 10
+#define SERVER_HANDLE_INTERVAL 0
 #define WEBSOCKET_UPDATE_INTERVAL 500
 #define LED_BLINK_INTERVAL 500
 #define LED_INIT_BLINK_INTERVAL 500
 #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)
 
 // each attempt takes LED_CONNECT_BLINK_INTERVAL ms
 #define MAX_WIFI_CONNECT_ATTEMPTS 40

platformio.ini

     https://github.com/rlogiacco/CircularBuffer
     https://github.com/tobiasschuerg/InfluxDB-Client-for-Arduino.git
     https://github.com/RobTillaart/PCF8574
+    https://github.com/bblanchon/ArduinoJson
+    https://github.com/witnessmenow/Universal-Arduino-Telegram-Bot
 
 [env:esp32_main]
 platform = platformio/espressif32@3.5.0
     https://github.com/rlogiacco/CircularBuffer
     https://github.com/tobiasschuerg/InfluxDB-Client-for-Arduino.git
     https://github.com/RobTillaart/PCF8574
+    https://github.com/bblanchon/ArduinoJson
+    https://github.com/witnessmenow/Universal-Arduino-Telegram-Bot
 
 [env:arduino_ui]
 platform = atmelavr

src/Functionality.cpp

 
 #include <Arduino.h>
 
+#include "wifi.h"
 #include "config.h"
 #include "config_pins.h"
 #include "DebugLog.h"
     return sm.isIdle();
 }
 
+#ifdef TELEGRAM_TOKEN
+
+void sm_bot_abort(void) {
+    sm.bot_abort();
+}
+
+void sm_bot_start_auto(BoolField ferts, BoolField plants) {
+    sm.bot_start_auto(ferts, plants);
+}
+
+#endif // TELEGRAM_TOKEN
+
 #endif // FUNCTION_CONTROL
 
 // ----------------------------------------------------------------------------

src/Statemachine.cpp

  * along with Giess-o-mat.  If not, see <https://www.gnu.org/licenses/>.
  */
 
+#include "wifi.h"
 #include "Plants.h"
 #include "DebugLog.h"
 #include "WifiStuff.h"
     switch_to(init);
 }
 
+#ifdef TELEGRAM_TOKEN
+
+void Statemachine::bot_abort(void) {
+    plants.abort();
+    stop_time = millis();
+    switch_to(auto_done);
+}
+
+void Statemachine::bot_start_auto(BoolField _ferts, BoolField _plants) {
+    selected_ferts = _ferts;
+    selected_plants = _plants;
+
+    // check if we need to run fertilizers
+    if (selected_ferts.countSet() > 0) {
+        // stirr before pumping fertilizers
+        for (int i = 0; i < STIRRER_COUNT; i++) {
+            plants.startAux(i);
+        }
+        selected_id = 1;
+        selected_time = AUTO_STIRR_RUNTIME;
+        start_time = millis();
+        switch_to(fullauto_stirr_run);
+    } else {
+        // immediately continue with filling tank
+        auto wl = plants.getWaterlevel();
+        if ((wl != Plants::full) && (wl != Plants::invalid)) {
+            // if the waterlevel is currently empty, we
+            // set a flag to record the time to fill
+            filling_started_empty = (wl == Plants::empty);
+
+            plants.openWaterInlet();
+            selected_id = plants.countPlants() + 1;
+            selected_time = MAX_TANK_FILL_TIME;
+            start_time = millis();
+            switch_to(fullauto_tank_run);
+        } else if (wl == Plants::full) {
+            // 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, need_kickstart);
+                }
+            }
+
+            // for recording the flowrate
+            watering_started_full = (wl == Plants::full);
+
+            selected_time = MAX_AUTO_PLANT_RUNTIME;
+            start_time = millis();
+            if (need_kickstart) {
+                switch_to(fullauto_kickstart_run);
+            } else {
+                switch_to(fullauto_plant_run);
+            }
+        } else if (wl == Plants::invalid) {
+            error_condition = F("Invalid sensor state");
+            state = auto_mode_a;
+            switch_to(error);
+        }
+    }
+}
+
+#endif // TELEGRAM_TOKEN
+
 void Statemachine::input(int n) {
     if (state == init) {
 #if (LOCK_COUNT > 0) && defined(DOOR_LOCK_PIN)
         debug.println(state_names[state]);
 
         menu_entered_digits = "";
+
+#ifdef PLATFORM_ESP
+        wifi_broadcast_state_change(state_names[state]);
+#endif
     }
     
     if (s == init) {

src/WifiStuff.cpp

 #include "Functionality.h"
 #include "SimpleUpdater.h"
 #include "DebugLog.h"
+#include "BoolField.h"
 #include "WifiStuff.h"
 
+#ifdef TELEGRAM_TOKEN
+
+#include <WiFiClientSecure.h>
+#include <UniversalTelegramBot.h>
+
+//#define TELEGRAM_LOG_TIMINGS
+
+#if defined(ARDUINO_ARCH_ESP8266)
+X509List cert(TELEGRAM_CERTIFICATE_ROOT);
+#endif
+
+WiFiClientSecure secured_client;
+UniversalTelegramBot bot(TELEGRAM_TOKEN, secured_client);
+unsigned long last_telegram_time = 0;
+String trusted_chat_ids[] = TRUSTED_IDS;
+
+#endif // TELEGRAM_TOKEN
+
 UPDATE_WEB_SERVER server(80);
 WebSocketsServer socket = WebSocketsServer(81);
 SimpleUpdater updater;
 
 #endif // ENABLE_GPIO_TEST
 
+void wifi_broadcast_state_change(const char *s) {
+#ifdef TELEGRAM_TOKEN
+    for (int n = 0; n < (sizeof(trusted_chat_ids) / sizeof(trusted_chat_ids[0])); n++) {
+        bot.sendMessage(trusted_chat_ids[n], "New state: " + String(s), "");
+    }
+#endif // TELEGRAM_TOKEN
+}
+
+#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) {
+        return TELEGRAM_UPDATE_INTERVAL_SLOW;
+    } else {
+        return TELEGRAM_UPDATE_INTERVAL_FAST;
+    }
+}
+
+String telegram_help() {
+    String s = "Usage:\n";
+    s += "Send /auto and follow prompts.\n";
+    s += "Send /abort to cancel menus.\n";
+    s += "Send /none to skip menus.\n";
+    s += "Send /begin to confirm menus.";
+    return s;
+}
+
+void telegram_handle_message(int message_id) {
+    if (!sm_is_idle()) {
+        debug.println("Telegram: message while machine in use");
+
+        if (bot.messages[message_id].text == "/abort") {
+            sm_bot_abort();
+            bot.sendMessage(bot.messages[message_id].chat_id, "Aborted current cycle!", "");
+        } else {
+            bot.sendMessage(bot.messages[message_id].chat_id, "Machine is already in use.\nPlease try again later.", "");
+        }
+
+        return;
+    }
+
+    if ((bot_state == BOT_IDLE) && (bot_lock == "")) {
+        bot_lock = bot.messages[message_id].chat_id;
+        debug.println("Telegram: locked to " + bot_lock);
+    }
+
+    if (bot_lock != bot.messages[message_id].chat_id) {
+        debug.println("Telegram: bot locked. abort for chat " + bot.messages[message_id].chat_id);
+        bot.sendMessage(bot.messages[message_id].chat_id, "Bot is already in use.\nPlease try again later.", "");
+        return;
+    }
+
+    if (bot_state == BOT_IDLE) {
+        if (bot.messages[message_id].text == "/auto") {
+            String s = "Please enter fertilizer numbers.\n";
+            s += "Valid numbers: 1 to " + String(PUMP_COUNT) + "\n";
+            s += "Send /none to skip.\n";
+            s += "Send /abort to cancel.";
+            bot_ferts.clear();
+            bot_state = BOT_ASKED_FERT;
+            bot.sendMessage(bot.messages[message_id].chat_id, s, "");
+        } else if (bot.messages[message_id].text == "/abort") {
+            bot_lock = "";
+            bot.sendMessage(bot.messages[message_id].chat_id, "Nothing to abort.", "");
+        } else {
+            bot_lock = "";
+            bot.sendMessage(bot.messages[message_id].chat_id, telegram_help(), "");
+        }
+    } else if (bot_state == BOT_ASKED_FERT) {
+        if (bot.messages[message_id].text == "/abort") {
+            bot_state = BOT_IDLE;
+            bot_lock = "";
+            bot.sendMessage(bot.messages[message_id].chat_id, "Aborted.", "");
+            return;
+        } else if (bot.messages[message_id].text != "/none") {
+            String buff;
+            for (int i = 0; i < bot.messages[message_id].text.length() + 1; i++) {
+                if ((i == bot.messages[message_id].text.length()) || (bot.messages[message_id].text[i] == ' ')) {
+                    if (buff.length() > 0) {
+                        int n = buff.toInt() - 1;
+                        buff = "";
+                        bot_ferts.set(n);
+                    }
+                } else if ((bot.messages[message_id].text[i] >= '0') && (bot.messages[message_id].text[i] <= '9')) {
+                    buff += bot.messages[message_id].text[i];
+                } else {
+                    bot_state = BOT_IDLE;
+                    bot_lock = "";
+                    bot.sendMessage(bot.messages[message_id].chat_id, "Invalid input.\nAborted.", "");
+                    return;
+                }
+            }
+        }
+
+        String s = "Please enter plant numbers.\n";
+        s += "Valid numbers: 1 to " + String(VALVE_COUNT - 1) + "\n";
+        s += "Send /abort to cancel.";
+        bot_plants.clear();
+        bot_state = BOT_ASKED_PLANTS;
+        bot.sendMessage(bot.messages[message_id].chat_id, s, "");
+    } else if (bot_state == BOT_ASKED_PLANTS) {
+        if (bot.messages[message_id].text == "/abort") {
+            bot_state = BOT_IDLE;
+            bot_lock = "";
+            bot.sendMessage(bot.messages[message_id].chat_id, "Aborted.", "");
+            return;
+        }
+
+        String buff;
+        for (int i = 0; i < bot.messages[message_id].text.length() + 1; i++) {
+            if ((i == bot.messages[message_id].text.length()) || (bot.messages[message_id].text[i] == ' ')) {
+                if (buff.length() > 0) {
+                    int n = buff.toInt() - 1;
+                    buff = "";
+                    bot_plants.set(n);
+                }
+            } else if ((bot.messages[message_id].text[i] >= '0') && (bot.messages[message_id].text[i] <= '9')) {
+                buff += bot.messages[message_id].text[i];
+            } else {
+                bot_state = BOT_IDLE;
+                bot_lock = "";
+                bot.sendMessage(bot.messages[message_id].chat_id, "Invalid input.\nAborted.", "");
+                return;
+            }
+        }
+
+        if (bot_plants.countSet() <= 0) {
+            bot_state = BOT_IDLE;
+            bot_lock = "";
+            bot.sendMessage(bot.messages[message_id].chat_id, "No plants selected.\nAborted.", "");
+            return;
+        }
+
+#ifdef FULLAUTO_MIN_PLANT_COUNT
+        if (bot_plants.countSet() < FULLAUTO_MIN_PLANT_COUNT) {
+            bot_state = BOT_IDLE;
+            bot_lock = "";
+            bot.sendMessage(bot.messages[message_id].chat_id, "Select at least " + String(FULLAUTO_MIN_PLANT_COUNT) + " plants.\nAborted.", "");
+            return;
+        }
+#endif
+
+        String s = "Input accepted.\nFertilizers:";
+        for (int i = 0; i < PUMP_COUNT; i++) {
+            if (bot_ferts.isSet(i)) {
+                s += " " + String(i + 1);
+            }
+        }
+        s += "\nPlants:";
+        for (int i = 0; i < (VALVE_COUNT - 1); i++) {
+            if (bot_plants.isSet(i)) {
+                s += " " + String(i + 1);
+            }
+        }
+        s += "\nOk? Send /begin to start or /abort to cancel.";
+        bot_state = BOT_ASKED_CONFIRM;
+        bot.sendMessage(bot.messages[message_id].chat_id, s, "");
+    } else if (bot_state == BOT_ASKED_CONFIRM) {
+        if (bot.messages[message_id].text == "/abort") {
+            bot_state = BOT_IDLE;
+            bot_lock = "";
+            bot.sendMessage(bot.messages[message_id].chat_id, "Aborted.", "");
+        } else if (bot.messages[message_id].text == "/begin") {
+            bot_state = BOT_IDLE;
+            bot_lock = "";
+            bot.sendMessage(bot.messages[message_id].chat_id, "Auto watering cycle started.", "");
+            sm_bot_start_auto(bot_ferts, bot_plants);
+        } else {
+            bot_state = BOT_IDLE;
+            bot_lock = "";
+            bot.sendMessage(bot.messages[message_id].chat_id, "Unknown message.\nAborted.", "");
+        }
+    } else {
+        debug.println("Telegram: invalid state");
+        bot_state = BOT_IDLE;
+        bot_lock = "";
+        bot.sendMessage(bot.messages[message_id].chat_id, "Internal error.\nPlease try again.", "");
+    }
+}
+
+void telegram_handler(int message_id) {
+    debug.println("Telegram: rx " + bot.messages[message_id].chat_id + " \"" + bot.messages[message_id].text + "\"");
+
+    bool found = false;
+    for (int n = 0; n < (sizeof(trusted_chat_ids) / sizeof(trusted_chat_ids[0])); n++) {
+        if (trusted_chat_ids[n] == bot.messages[message_id].chat_id) {
+            found = true;
+            break;
+        }
+    }
+    if (!found) {
+        bot.sendMessage(bot.messages[message_id].chat_id, "Sorry, not authorized!", "");
+        return;
+    }
+
+    telegram_handle_message(message_id);
+}
+
+void telegram_poll() {
+#ifdef TELEGRAM_LOG_TIMINGS
+    unsigned long start = millis();
+#endif // TELEGRAM_LOG_TIMINGS
+
+    while (int count = bot.getUpdates(bot.last_message_received + 1)) {
+        for (int i = 0; i < count; i++) {
+            telegram_handler(i);
+        }
+    }
+
+#ifdef TELEGRAM_LOG_TIMINGS
+    unsigned long end = millis();
+    debug.println("Telegram: took " + String(end - start) + "ms");
+#endif // TELEGRAM_LOG_TIMINGS
+}
+
+void telegram_hello() {
+    for (int n = 0; n < (sizeof(trusted_chat_ids) / sizeof(trusted_chat_ids[0])); n++) {
+        bot.sendMessage(trusted_chat_ids[n], "Giess-o-mat v" FIRMWARE_VERSION " initialized.\nSend /auto to begin.", "");
+    }
+}
+#endif // TELEGRAM_TOKEN
+
 bool wifi_write_database(int duration, const char *type, int id) {
     bool success = false;
 
 #endif
 
     message += F("<p>\n");
+#ifdef TELEGRAM_TOKEN
+    message += F("Telegram: ");
+    message += TELEGRAM_UPDATE_INTERVAL_SLOW;
+    message += F("ms / ");
+    message += TELEGRAM_UPDATE_INTERVAL_FAST;
+    message += F("ms\n");
+#else
+    message += F("Telegram bot not enabled!\n");
+#endif
+    message += F("</p>\n");
+
+    message += F("<p>\n");
 #ifdef ENABLE_INFLUXDB_LOGGING
     message += F("InfluxDB: ");
     message += INFLUXDB_DATABASE;
 
 void webSocketEvent(uint8_t num, WStype_t type, uint8_t *payload, size_t length) {
     if ((type != WStype_TEXT) || (length != 1)) {
+        debug.println("Websocket: invalid type=" + String(type) + " len=" + String(length) + " data=" + String((char *)payload));
         return;
     }
     
     debug.print("WiFi: connecting");
     WiFi.begin(WIFI_SSID, WIFI_PW);
 
+#ifdef TELEGRAM_TOKEN
+    secured_client.setTrustAnchors(&cert);
+#endif // TELEGRAM_TOKEN
+
     while (((ws = WiFi.status()) != WL_CONNECTED) && (connect_attempts < MAX_WIFI_CONNECT_ATTEMPTS)) {
         connect_attempts++;
         debug.print(String(" ") + String(ws));
     WiFi.mode(WIFI_STA);
     WiFi.begin(WIFI_SSID, WIFI_PW);
 
+#ifdef TELEGRAM_TOKEN
+    secured_client.setCACert(TELEGRAM_CERTIFICATE_ROOT);
+#endif // TELEGRAM_TOKEN
+
     while (((ws = WiFi.status()) != WL_CONNECTED) && (connect_attempts < MAX_WIFI_CONNECT_ATTEMPTS)) {
         connect_attempts++;
         debug.print(String(" ") + String(ws));
 #ifdef ENABLE_GPIO_TEST
     server.on("/gpiotest", handleGpioTest);
 #endif // ENABLE_GPIO_TEST
-    
+
+#ifdef TELEGRAM_TOKEN
+    debug.print("WiFi: getting NTP time");
+    configTime(0, 0, "pool.ntp.org");
+    time_t now = time(nullptr);
+    while (now < 24 * 60 * 60) {
+        debug.print(".");
+        delay(100);
+        now = time(nullptr);
+    }
+    debug.println(" done!");
+    debug.println("WiFi: time is " + String(now));
+
+    debug.println("WiFi: initializing Telegram");
+    const String commands = F("["
+        "{\"command\":\"auto\", \"description\":\"Start automatic watering cycle\"},"
+        "{\"command\":\"confirm\", \"description\":\"Proceed with any menu inputs\"},"
+        "{\"command\":\"none\", \"description\":\"Proceed without menu input\"},"
+        "{\"command\":\"abort\", \"description\":\"Cancel any menu inputs\"}"
+    "]");
+    bot.setMyCommands(commands);
+    telegram_hello();
+#endif // TELEGRAM_TOKEN
+
     server.begin();
     MDNS.addService("http", "tcp", 80);
-    
+    MDNS.addService("http", "tcp", 81);
+
     socket.begin();
     socket.onEvent(webSocketEvent);
     
         runGpioTest(gpioTestState);
     }
 #endif // ENABLE_GPIO_TEST
+
+#ifdef TELEGRAM_TOKEN
+    if ((millis() - last_telegram_time) >= telegram_update_interval()) {
+        telegram_poll();
+        last_telegram_time = millis();
+    }
+#endif // TELEGRAM_TOKEN
 }
 
 #endif // PLATFORM_ESP