Now works with two distributed units connected via i2c

include/Functionality.h

+#ifndef _FUNCTIONALITY_H_
+#define _FUNCTIONALITY_H_
+
+#ifdef FUNCTION_UI
+
+void ui_setup(void);
+void ui_run(void);
+
+#endif // FUNCTION_UI
+
+// ----------------------------------------------------------------------------
+
+#ifdef FUNCTION_CONTROL
+
+void control_setup(void);
+void control_begin(void);
+void control_run(void);
+
+#endif // FUNCTION_CONTROL
+
+// ----------------------------------------------------------------------------
+
+void blink_lcd(int n, int wait = 200);
+void write_to_all(const char *a, const char *b,
+                  const char *c, const char *d, int num_input);
+void backspace(void);
+
+#endif // _FUNCTIONALITY_H_

include/Keymatrix.h

 #ifndef _KEYMATRIX_H_
 #define _KEYMATRIX_H_
 
+#ifdef FUNCTION_UI
+
 #include <CircularBuffer.h>
 
 class Keymatrix {
     CircularBuffer<Event *, 32> events;
 };
 
+#endif // FUNCTION_UI
+
 #endif // _KEYMATRIX_H_

include/SerialLCD.h

 #ifndef _SERIAL_LCD_H_
 #define _SERIAL_LCD_H_
 
+#ifdef FUNCTION_UI
+
 #if defined(PLATFORM_AVR)
 #include <SendOnlySoftwareSerial.h>
 #elif defined(PLATFORM_ESP)
 #endif
 };
 
+#endif // FUNCTION_UI
+
 #endif // _SERIAL_LCD_H_

include/WifiStuff.h

 #ifndef _WIFI_STUFF_H_
 #define _WIFI_STUFF_H_
 
+#ifdef PLATFORM_ESP
+
 void wifi_setup();
 void wifi_run();
 
+#endif
+
 #endif // _WIFI_STUFF_H_

include/config.h

 
 // all given in milliseconds
 #define SERVER_HANDLE_INTERVAL 10
-#define LED_BLINK_INTERVAL (2 * 1000)
+#define LED_BLINK_INTERVAL 500
 #define LED_INIT_BLINK_INTERVAL 500
 #define LED_CONNECT_BLINK_INTERVAL 250
 #define LED_ERROR_BLINK_INTERVAL 100
 
+#define OWN_I2C_ADDRESS 0x42
+#define I2C_BUF_SIZE 32
+
 #endif // _CONFIG_H_

include/config_pins.h

+#ifndef _CONFIG_PINS_H_
+#define _CONFIG_PINS_H_
+
+// ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+#ifdef PLATFORM_AVR
+
+#define BUILTIN_LED_PIN 13
+
+// ----------------------------------------------------------------------------
+
+#ifdef FUNCTION_UI
+
+#define SERIAL_LCD_TX_PIN 10
+
+#define KEYMATRIX_ROWS 4
+#define KEYMATRIX_COLS 3
+#define KEYMATRIX_ROW_PINS 5, 6, 7, 8
+#define KEYMATRIX_COL_PINS 2, 3, 4
+
+#endif // FUNCTION_UI
+
+// ----------------------------------------------------------------------------
+
+#ifdef FUNCTION_CONTROL
+
+#define VALVE_COUNT 5
+#define VALVE_PINS 10, 11, 12, 14, 15
+
+#define PUMP_COUNT 3
+#define PUMP_PINS 16, 17, 18
+
+#define SWITCH_COUNT 2
+#define SWITCH_PINS 19, 20
+
+#endif // FUNCTION_CONTROL
+
+#endif // PLATFORM_AVR
+
+// ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+#ifdef PLATFORM_ESP
+
+#define BUILTIN_LED_PIN 1
+
+// ----------------------------------------------------------------------------
+
+#ifdef FUNCTION_UI
+
+#error configuration not supported
+
+#endif // FUNCTION_UI
+
+// ----------------------------------------------------------------------------
+
+#ifdef FUNCTION_CONTROL
+
+#ifdef FUNCTION_UI
+
+#define VALVE_COUNT 5
+#define VALVE_PINS 9, 11, 12, 13, 14
+
+#define PUMP_COUNT 3
+#define PUMP_PINS 15, 16, 17
+
+#define SWITCH_COUNT 2
+#define SWITCH_PINS 18, 19
+
+#else
+
+#define VALVE_COUNT 5
+#define VALVE_PINS 9, 11, 12, 13, 14
+
+#define PUMP_COUNT 3
+#define PUMP_PINS 15, 16, 17
+
+#define SWITCH_COUNT 2
+#define SWITCH_PINS 18, 19
+
+#endif
+
+#endif // FUNCTION_CONTROL
+
+#endif // PLATFORM_ESP
+
+// ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+#endif // _CONFIG_PINS_H_

platformio.ini

 ; https://docs.platformio.org/page/projectconf.html
 
 [platformio]
-default_envs = esp32_main, arduino_ui
+default_envs = esp8266_main, esp32_main, arduino_ui, arduino_test, leonardo_main, leonardo_test
 
 [env:esp8266_main]
 platform = espressif8266
 framework = arduino
 build_flags = -D PLATFORM_ESP -D FUNCTION_CONTROL
 lib_deps =
-    https://github.com/rlogiacco/CircularBuffer
-    https://github.com/plerup/espsoftwareserial
+    Wire
 
 [env:esp32_main]
 platform = espressif32
 upload_protocol = esptool
 upload_port = /dev/ttyUSB1
 lib_deps =
-    https://github.com/rlogiacco/CircularBuffer
-    https://github.com/plerup/espsoftwareserial
+    Wire
 
 [env:arduino_ui]
 platform = atmelavr
 monitor_port = /dev/ttyUSB1
 monitor_speed = 115200
 lib_deps =
-  https://github.com/nickgammon/SendOnlySoftwareSerial
-  https://github.com/rlogiacco/CircularBuffer
+    Wire
+    https://github.com/nickgammon/SendOnlySoftwareSerial
+    https://github.com/rlogiacco/CircularBuffer
+
+[env:arduino_test]
+platform = atmelavr
+board = pro16MHzatmega328
+framework = arduino
+build_flags = -D PLATFORM_AVR -D FUNCTION_CONTROL -D FUNCTION_UI
+upload_port = /dev/ttyUSB1
+monitor_port = /dev/ttyUSB1
+monitor_speed = 115200
+lib_deps =
+    https://github.com/nickgammon/SendOnlySoftwareSerial
+    https://github.com/rlogiacco/CircularBuffer
 
-[env:leonardo_ui]
+[env:leonardo_main]
 platform = atmelavr
 board = leonardo
 framework = arduino
-build_flags = -D PLATFORM_AVR -D FUNCTION_UI
+build_flags = -D PLATFORM_AVR -D FUNCTION_CONTROL
 upload_port = /dev/ttyACM0
 monitor_port = /dev/ttyACM0
 monitor_speed = 115200
 lib_deps =
-  https://github.com/nickgammon/SendOnlySoftwareSerial
-  https://github.com/rlogiacco/CircularBuffer
+    Wire
+    https://github.com/rlogiacco/CircularBuffer
+
+[env:leonardo_test]
+platform = atmelavr
+board = leonardo
+framework = arduino
+build_flags = -D PLATFORM_AVR -D FUNCTION_CONTROL -D FUNCTION_UI
+upload_port = /dev/ttyACM0
+monitor_port = /dev/ttyACM0
+monitor_speed = 115200
+lib_deps =
+    https://github.com/nickgammon/SendOnlySoftwareSerial
+    https://github.com/rlogiacco/CircularBuffer

src/Functionality.cpp

+#include <Arduino.h>
+
+#include "config.h"
+#include "config_pins.h"
+#include "Functionality.h"
+
+#ifdef FUNCTION_UI
+
+#ifndef FUNCTION_CONTROL
+
+#include <Wire.h>
+#include <CircularBuffer.h>
+
+CircularBuffer<int, I2C_BUF_SIZE> keybuffer;
+String linebuffer[4];
+
+#endif // ! FUNCTION_CONTROL
+
+#include "SerialLCD.h"
+#include "Keymatrix.h"
+
+SerialLCD lcd(SERIAL_LCD_TX_PIN);
+
+Keymatrix keys(KEYMATRIX_ROWS, KEYMATRIX_COLS);
+int keymatrix_pins[KEYMATRIX_ROWS + KEYMATRIX_COLS] = { KEYMATRIX_ROW_PINS, KEYMATRIX_COL_PINS };
+
+unsigned long last_input_time = 0;
+bool backlight_state = true;
+bool doing_multi_input = false;
+
+#endif // FUNCTION_UI
+
+#ifdef FUNCTION_CONTROL
+
+#ifndef FUNCTION_UI
+#include <Wire.h>
+#endif // ! FUNCTION_UI
+
+#include "Plants.h"
+#include "Statemachine.h"
+
+Plants plants(VALVE_COUNT, PUMP_COUNT, SWITCH_COUNT);
+int valve_pins[VALVE_COUNT] = { VALVE_PINS };
+int pump_pins[PUMP_COUNT] = { PUMP_PINS };
+int switch_pins[SWITCH_COUNT] = { SWITCH_PINS };
+
+Statemachine sm(write_to_all, backspace);
+
+#endif // FUNCTION_CONTROL
+
+// ----------------------------------------------------------------------------
+
+#ifdef FUNCTION_UI
+
+#ifndef FUNCTION_CONTROL
+
+void ui_i2c_request(void) {
+    if (keybuffer.isEmpty()) {
+        Wire.write(-4);
+        return;
+    }
+    
+    Serial.print("ui_i2c_request: ");
+    
+    while (!keybuffer.isEmpty()) {
+        int n = keybuffer.shift();
+        
+        // for some reason it seems as if we always get -1 here,
+        // so we cant send our input (-2 to 9) as is.
+        // so -4 is no-data, -3 is -1, and the rest as-is.
+        if (n == -1) {
+            n = -3;
+        }
+        
+        Serial.print(n);
+        Serial.print(", ");
+        
+        Wire.write(n);
+    }
+    
+    Serial.println();
+}
+
+void ui_i2c_receive(int count) {
+    char buff[I2C_BUF_SIZE];
+    for (int i = 0; i < I2C_BUF_SIZE; i++) {
+        buff[i] = 0;
+    }
+    
+    for (int i = 0; (i < count) && (Wire.available()); i++) {
+        buff[i] = Wire.read();
+    }
+    
+    if (count <= 0) {
+        Serial.println("ui_i2c_receive: count is 0");
+        return;
+    }
+    
+    if (buff[0] == 0x01) {
+        if (count < 3) {
+            Serial.println("ui_i2c_receive: blink lcd too short");
+            return;
+        }
+        
+        int n = buff[1];
+        int wait = buff[2] * 10;
+        
+        Serial.println("ui_i2c_receive: blink lcd command");
+        blink_lcd(n, wait);
+    } else if (buff[0] == 0x02) {
+        Serial.println("ui_i2c_receive: backspace command");
+        backspace();
+    } else if (buff[0] == 0x03) {
+        if (count < 3) {
+            Serial.println("ui_i2c_receive: display far too short");
+            return;
+        }
+        
+        int line = buff[1];
+        int len = buff[2];
+        String s;
+        for (int i = 0; i < len; i++) {
+            s += buff[3 + i];
+        }
+        
+        Serial.println("ui_i2c_receive: display command");
+        linebuffer[line] = s;
+    } else if (buff[0] == 0x04) {
+        if (count < 2) {
+            Serial.println("ui_i2c_receive: num input too short");
+            return;
+        }
+        
+        int8_t num_input = buff[1];
+        
+        Serial.println("ui_i2c_receive: num input");
+        write_to_all(linebuffer[0].c_str(), linebuffer[1].c_str(),
+                     linebuffer[2].c_str(), linebuffer[3].c_str(),
+                     num_input);
+    } else {
+        Serial.println("ui_i2c_receive: unknown command");
+        return;
+    }
+}
+
+#endif // ! FUNCTION_CONTROL
+
+void ui_setup(void) {
+    keys.setPins(keymatrix_pins);
+    
+    Serial.println("Setting up LCD, please wait");
+    delay(1000); // give LCD some time to boot
+    lcd.init();
+    
+#ifdef DEBUG_WAIT_FOR_SERIAL_CONN
+    lcd.write(0, "Waiting for serial");
+    lcd.write(1, "connection on debug");
+    lcd.write(2, "USB port...");
+    while (!Serial);
+    lcd.clear();
+#endif // DEBUG_WAIT_FOR_SERIAL_CONN
+    
+#ifndef FUNCTION_CONTROL
+    Serial.println("Initializing I2C Slave");
+    Wire.begin(OWN_I2C_ADDRESS);
+    Wire.onReceive(ui_i2c_receive);
+    Wire.onRequest(ui_i2c_request);
+    
+    String a = String("- Giess-o-mat V") + FIRMWARE_VERSION + String(" -");
+    String b = String("    Address 0x") + String(OWN_I2C_ADDRESS, HEX) + String("    ");
+    
+    lcd.write(0, a.c_str());
+    lcd.write(1, "    I2C UI Panel    ");
+    lcd.write(2, "Waiting for data....");
+    lcd.write(3, b.c_str());
+#endif // ! FUNCTION_CONTROL
+}
+
+void handle_input(int n) {
+#ifdef FUNCTION_CONTROL
+    
+    sm.input(n);
+    
+#else
+    
+    keybuffer.push(n);
+    
+#endif // FUNCTION_CONTROL
+}
+
+void input_keypad(void) {
+    keys.scan();
+    while (keys.hasEvent()) {
+        auto ke = keys.getEvent();
+        if (ke.getType() == Keymatrix::Event::button_down) {
+            last_input_time = millis();
+            if (!backlight_state) {
+                backlight_state = true;
+                lcd.setBacklight(255);
+                
+                // swallow input when used to activate light
+                continue;
+            }
+            
+            int n = ke.getNum();
+            Serial.print("Got keypad input: \"");
+            
+            if (n < 0) {
+                Serial.print((n == -1) ? '*' : '#');
+            } else {
+                Serial.print(n);
+                
+                if (doing_multi_input) {
+                    char s[2] = { (char)(n + '0'), '\0' };
+                    lcd.write(s);
+                }
+            }
+            
+            Serial.println("\"");
+            
+            blink_lcd(1, 100);
+            handle_input(n);
+        }
+    }
+}
+
+void input_serial(void) {
+#ifdef DEBUG_ENABLE_KEYPAD_INPUT_ON_SERIAL
+    if (Serial.available() > 0) {
+        last_input_time = millis();
+        if (!backlight_state) {
+            backlight_state = true;
+            lcd.setBacklight(255);
+        }
+        
+        int c = Serial.read();
+        if (c == '*') {
+            Serial.write(c);
+            Serial.write('\n');
+            
+            if (doing_multi_input) {
+                char s[2] = { (char)(c), '\0' };
+                lcd.write(s);
+            }
+            
+            handle_input(-1);
+        } else if  (c == '#') {
+            Serial.write(c);
+            Serial.write('\n');
+            
+            if (doing_multi_input) {
+                char s[2] = { (char)(c), '\0' };
+                lcd.write(s);
+            }
+            
+            handle_input(-2);
+        } else if  (c == '\n') {
+            Serial.write('#');
+            Serial.write('\n');
+            
+            if (doing_multi_input) {
+                char s[2] = { '#', '\0' };
+                lcd.write(s);
+            }
+            
+            handle_input(-2);
+        } else if (c == '\b') {
+            Serial.write(c);
+            handle_input(-1);
+        } else if ((c >= '0') && (c <= '9')) {
+            Serial.write(c);
+            if (!doing_multi_input) {
+                Serial.write('\n');
+            }
+            
+            if (doing_multi_input) {
+                char s[2] = { (char)(c), '\0' };
+                lcd.write(s);
+            }
+            
+            handle_input(c - '0');
+        }
+    }
+#endif // DEBUG_ENABLE_KEYPAD_INPUT_ON_SERIAL
+}
+
+void ui_run(void) {
+    input_keypad();
+    input_serial();
+    
+    if (backlight_state && (millis() >= (last_input_time + DISPLAY_BACKLIGHT_TIMEOUT))) {
+        backlight_state = false;
+        lcd.setBacklight(0);
+    }
+}
+
+void write_to_all(const char *a, const char *b,
+                  const char *c, const char *d, int num_input) {
+    lcd.clear();
+    
+    if (num_input >= 0) {
+        lcd.write(0, a);
+        if (num_input >= 1) {
+            lcd.write(1, b);
+        }
+        if (num_input >= 2) {
+            lcd.write(2, c);
+        }
+        if (num_input >= 3) {
+            lcd.write(3, d);
+        }
+        
+        lcd.cursor(3);
+        doing_multi_input = true;
+    } else {
+        lcd.write(0, a);
+        lcd.write(1, b);
+        lcd.write(2, c);
+        lcd.write(3, d);
+        
+        lcd.cursor(0);
+        doing_multi_input = false;
+    }
+    
+#ifdef DEBUG_ENABLE_LCD_OUTPUT_ON_SERIAL
+    int la = strlen(a);
+    int lb = strlen(b);
+    int lc = strlen(c);
+    int ld = strlen(d);
+    
+    Serial.println();
+    Serial.println(" ----------------------");
+    
+    Serial.print("| ");
+    Serial.print(a);
+    if (la < 20) {
+        for (int i = 0; i < (20 - la); i++) {
+            Serial.print(' ');
+        }
+    }
+    Serial.println(" |");
+    
+    Serial.print("| ");
+    Serial.print(b);
+    if (lb < 20) {
+        for (int i = 0; i < (20 - lb); i++) {
+            Serial.print(' ');
+        }
+    }
+    Serial.println(" |");
+    
+    Serial.print("| ");
+    Serial.print(c);
+    if (lc < 20) {
+        for (int i = 0; i < (20 - lc); i++) {
+            Serial.print(' ');
+        }
+    }
+    Serial.println(" |");
+    
+    Serial.print("| ");
+    Serial.print(d);
+    if (ld < 20) {
+        for (int i = 0; i < (20 - ld); i++) {
+            Serial.print(' ');
+        }
+    }
+    Serial.println(" |");
+    
+    Serial.println(" ----------------------");
+    Serial.println("Please provide keypad input:");
+#endif // DEBUG_ENABLE_LCD_OUTPUT_ON_SERIAL
+}
+
+void backspace(void) {
+    lcd.write("\b");
+}
+
+void blink_lcd(int n, int wait) {
+    for (int i = 0; i < n; i++) {
+        lcd.setBacklight(0);
+        delay(wait);
+        
+        lcd.setBacklight(255);
+        if (i < (n - 1))
+            delay(wait);
+    }
+}
+
+#endif // FUNCTION_UI
+
+// ----------------------------------------------------------------------------
+
+#ifdef FUNCTION_CONTROL
+
+void control_setup(void) {
+    plants.setValvePins(valve_pins);
+    plants.setPumpPins(pump_pins);
+    plants.setSwitchPins(switch_pins, true);
+    
+#ifndef FUNCTION_UI
+    
+    Serial.println("Initializing I2C Master");
+    Wire.begin();
+    
+#ifdef DEBUG_WAIT_FOR_SERIAL_CONN
+    while (!Serial);
+#endif // DEBUG_WAIT_FOR_SERIAL_CONN
+    
+#endif // ! FUNCTION_UI
+}
+
+void control_begin(void) {
+    sm.begin();
+}
+
+void control_run(void) {
+#ifndef FUNCTION_UI
+    
+    Wire.requestFrom(OWN_I2C_ADDRESS, I2C_BUF_SIZE);
+    while (Wire.available()) {
+        char c = Wire.read();
+        
+        // for some reason it seems as if we always get -1 here,
+        // so we cant send our input (-2 to 9) as is.
+        // so -4 is no-data, -3 is -1, and the rest as-is.
+        if ((c >= -3) && (c <= 9) && (c != -1)) {
+            if (c == -3) {
+                c = -1;
+            }
+        
+            Serial.print("control_run: got input '");
+            Serial.print((int)c);
+            Serial.println("'");
+        
+            sm.input(c);
+        }
+    }
+
+#endif // ! FUNCTION_UI
+    
+    sm.act();
+}
+
+#ifndef FUNCTION_UI
+
+void blink_lcd(int n, int wait) {
+    Serial.println("blink_lcd i2c");
+    
+    Wire.beginTransmission(OWN_I2C_ADDRESS);
+    Wire.write(0x01); // blink command
+    Wire.write(n); // count
+    Wire.write(wait / 10); // time
+    Wire.endTransmission();
+}
+
+void backspace(void) {
+    Serial.println("backspace i2c");
+    
+    Wire.beginTransmission(OWN_I2C_ADDRESS);
+    Wire.write(0x02); // backspace command
+    Wire.endTransmission();
+}
+
+void write_to_all(const char *a, const char *b,
+                  const char *c, const char *d, int num_input) {
+    const char *lines[4] = { a, b, c, d };
+    
+    Serial.println("write_to_all i2c");
+    
+    for (int i = 0; i < 4; i++) {
+        Wire.beginTransmission(OWN_I2C_ADDRESS);
+        Wire.write(0x03); // display command
+    
+        Wire.write(i);
+        
+        int l = strlen(lines[i]);
+        Wire.write(l);
+        
+        for (int n = 0; n < l; n++) {
+            Wire.write(lines[i][n]);
+        }
+    
+        Wire.endTransmission();
+    }
+    
+    Wire.beginTransmission(OWN_I2C_ADDRESS);
+    Wire.write(0x04); // display command
+    Wire.write((int8_t)num_input);
+    Wire.endTransmission();
+}
+
+#endif // ! FUNCTION_UI
+
+#endif // FUNCTION_CONTROL

src/Keymatrix.cpp

 #include <Arduino.h>
 #include "Keymatrix.h"
 
+#ifdef FUNCTION_UI
+
 //#define DEBUG_PRINT_MATRIX_STATE
 
 Keymatrix::Event::Event(EventType _type, int _row, int _col) {
         return Keymatrix::Event(Event::no_event, -1, -1);
     }
 }
+
+#endif // FUNCTION_UI

src/SerialLCD.cpp

 #include <Arduino.h>
 #include "SerialLCD.h"
 
+#ifdef FUNCTION_UI
+
 #define LCD_DELAY 3 // 3
 
 SerialLCD::SerialLCD(int tx_pin) {
     position(line, col);
     write(text);
 }
+
+#endif // FUNCTION_UI

src/WifiStuff.cpp

 #include <Arduino.h>
 
+#ifdef PLATFORM_ESP
+
 #if defined(ARDUINO_ARCH_ESP8266)
 
 #include <ESP8266WiFi.h>
 
 #endif
 
-#if defined(ARDUINO_ARCH_ESP8266) || defined(ARDUINO_ARCH_ESP32)
-
 #include "wifi.h"
 #include "config.h"
+#include "config_pins.h"
 #include "SimpleUpdater.h"
 #include "WifiStuff.h"
 
-#define BUILTIN_LED_PIN 1
-
 UPDATE_WEB_SERVER server(80);
 SimpleUpdater updater;
 unsigned long last_server_handle_time = 0;
-unsigned long last_led_blink_time = 0;
 
 String message_buffer_a;
 String message_buffer_b;
     if ((millis() - last_server_handle_time) >= SERVER_HANDLE_INTERVAL) {
         last_server_handle_time = millis();
         server.handleClient();
-#if defined(ARDUINO_ARCH_ESP8266)
+        
+#ifdef ARDUINO_ARCH_ESP8266
         MDNS.update();
-#endif
-    }
-
-    // blink heartbeat LED
-    if ((millis() - last_led_blink_time) >= LED_BLINK_INTERVAL) {
-        last_led_blink_time = millis();
-        digitalWrite(BUILTIN_LED_PIN, !digitalRead(BUILTIN_LED_PIN));
+#endif // ARDUINO_ARCH_ESP8266
     }
     
     // reset ESP every 6h to be safe
     }
 }
 
-#endif // defined(ARDUINO_ARCH_ESP8266) || defined(ARDUINO_ARCH_ESP32)
+#endif // PLATFORM_ESP

src/main.cpp

 #include <Arduino.h>
 
-#include "Keymatrix.h"
-#include "SerialLCD.h"
-#include "Statemachine.h"
-#include "Plants.h"
+#include "Functionality.h"
 #include "WifiStuff.h"
 #include "config.h"
+#include "config_pins.h"
 
-void blink_lcd(int n, int wait = 200);
-void write_to_all(const char *a, const char *b,
-                  const char *c, const char *d, int num_input);
-void backspace(void);
-
-SerialLCD lcd(9);
-
-Keymatrix keys(4, 3);
-int keymatrix_pins[4 + 3] = { 5, 6, 7, 8, 2, 3, 4 };
-
-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 };
-
-Statemachine sm(write_to_all, backspace);
-
-unsigned long last_input_time = 0;
-bool backlight_state = true;
-bool doing_multi_input = false;
+unsigned long last_led_blink_time = 0;
 
 void setup() {
+    pinMode(BUILTIN_LED_PIN, OUTPUT);
+    digitalWrite(BUILTIN_LED_PIN, HIGH);
+    
     Serial.begin(115200);
     Serial.println("Initializing Giess-o-mat");
-    
-    keys.setPins(keymatrix_pins);
-    plants.setValvePins(valve_pins);
-    plants.setPumpPins(pump_pins);
-    plants.setSwitchPins(switch_pins, true);
+    Serial.println("Version: " FIRMWARE_VERSION);
 
-    Serial.println("Setting up LCD, please wait");
-    delay(1000); // give LCD some time to boot
-    lcd.init();
-    
-#ifdef DEBUG_WAIT_FOR_SERIAL_CONN
-    lcd.write(0, "Waiting for serial");
-    lcd.write(1, "connection on debug");
-    lcd.write(2, "USB port...");
-    
-    while (!Serial);
+#ifdef FUNCTION_UI
+    ui_setup();
+#endif // FUNCTION_UI
     
-    lcd.clear();
-#endif
+#ifdef FUNCTION_CONTROL
+    control_setup();
+#endif // FUNCTION_CONTROL
     
-#if defined(ARDUINO_ARCH_ESP8266) || defined(ARDUINO_ARCH_ESP32)
+#ifdef PLATFORM_ESP
     wifi_setup();
-#endif
+#endif // PLATFORM_ESP
     
     Serial.println("Ready, starting main loop");
-    sm.begin();
-}
-
-void loop() {
-#if defined(ARDUINO_ARCH_ESP8266) || defined(ARDUINO_ARCH_ESP32)
-    wifi_run();
-#endif
-
-    keys.scan();
-    while (keys.hasEvent()) {
-        auto ke = keys.getEvent();
-        if (ke.getType() == Keymatrix::Event::button_down) {
-            last_input_time = millis();
-            if (!backlight_state) {
-                backlight_state = true;
-                lcd.setBacklight(255);
-                
-                // swallow input when used to activate light
-                continue;
-            }
-            
-            int n = ke.getNum();
-            Serial.print("Got keypad input: \"");
-            
-            if (n < 0) {
-                Serial.print((n == -1) ? '*' : '#');
-            } else {
-                Serial.print(n);
-                
-                if (doing_multi_input) {
-                    char s[2] = { (char)(n + '0'), '\0' };
-                    lcd.write(s);
-                }
-            }
-            
-            Serial.println("\"");
-            
-            blink_lcd(1, 100);
-            sm.input(n);
-        }
-    }
-    
-#ifdef DEBUG_ENABLE_KEYPAD_INPUT_ON_SERIAL
-    if (Serial.available() > 0) {
-        last_input_time = millis();
-        if (!backlight_state) {
-            backlight_state = true;
-            lcd.setBacklight(255);
-        }
-        
-        int c = Serial.read();
-        if (c == '*') {
-            Serial.write(c);
-            Serial.write('\n');
-            
-            if (doing_multi_input) {
-                char s[2] = { (char)(c), '\0' };
-                lcd.write(s);
-            }
-            
-            sm.input(-1);
-        } else if  (c == '#') {
-            Serial.write(c);
-            Serial.write('\n');
-            
-            if (doing_multi_input) {
-                char s[2] = { (char)(c), '\0' };
-                lcd.write(s);
-            }
-            
-            sm.input(-2);
-        } else if  (c == '\n') {
-            Serial.write('#');
-            Serial.write('\n');
-            
-            if (doing_multi_input) {
-                char s[2] = { '#', '\0' };
-                lcd.write(s);
-            }
-            
-            sm.input(-2);
-        } else if (c == '\b') {
-            Serial.write(c);
-            sm.input(-1);
-        } else if ((c >= '0') && (c <= '9')) {
-            Serial.write(c);
-            if (!doing_multi_input) {
-                Serial.write('\n');
-            }
-            
-            if (doing_multi_input) {
-                char s[2] = { (char)(c), '\0' };
-                lcd.write(s);
-            }
-            
-            sm.input(c - '0');
-        }
-    }
-#endif
-    
-    sm.act();
+    digitalWrite(BUILTIN_LED_PIN, LOW);
     
-    if (backlight_state && (millis() >= (last_input_time + DISPLAY_BACKLIGHT_TIMEOUT))) {
-        backlight_state = false;
-        lcd.setBacklight(0);
-    }
-}
-
-void write_to_all(const char *a, const char *b,
-                  const char *c, const char *d, int num_input) {
-    lcd.clear();
-    
-    if (num_input >= 0) {
-        lcd.write(0, a);
-        if (num_input >= 1) {
-            lcd.write(1, b);
-        }
-        if (num_input >= 2) {
-            lcd.write(2, c);
-        }
-        if (num_input >= 3) {
-            lcd.write(3, d);
-        }
-        
-        lcd.cursor(3);
-        doing_multi_input = true;
-    } else {
-        lcd.write(0, a);
-        lcd.write(1, b);
-        lcd.write(2, c);
-        lcd.write(3, d);
-        
-        lcd.cursor(0);
-        doing_multi_input = false;
-    }
-    
-#ifdef DEBUG_ENABLE_LCD_OUTPUT_ON_SERIAL
-    int la = strlen(a);
-    int lb = strlen(b);
-    int lc = strlen(c);
-    int ld = strlen(d);
-    
-    Serial.println();
-    Serial.println(" ----------------------");
-    
-    Serial.print("| ");
-    Serial.print(a);
-    if (la < 20) {
-        for (int i = 0; i < (20 - la); i++) {
-            Serial.print(' ');
-        }
-    }
-    Serial.println(" |");
+#ifdef FUNCTION_CONTROL
     
-    Serial.print("| ");
-    Serial.print(b);
-    if (lb < 20) {
-        for (int i = 0; i < (20 - lb); i++) {
-            Serial.print(' ');
-        }
-    }
-    Serial.println(" |");
+#ifndef FUNCTION_UI
+    // give ui unit some time to initialize
+    delay(3000);
+#endif // ! FUNCTION_UI
     
-    Serial.print("| ");
-    Serial.print(c);
-    if (lc < 20) {
-        for (int i = 0; i < (20 - lc); i++) {
-            Serial.print(' ');
-        }
-    }
-    Serial.println(" |");
+    control_begin();
     
-    Serial.print("| ");
-    Serial.print(d);
-    if (ld < 20) {
-        for (int i = 0; i < (20 - ld); i++) {
-            Serial.print(' ');
-        }
-    }
-    Serial.println(" |");
-    
-    Serial.println(" ----------------------");
-    Serial.println("Please provide keypad input:");
-#endif
+#endif // FUNCTION_CONTROL
 }
 
-void backspace(void) {
-    lcd.write("\b");
-}
+void loop() {
+#ifdef PLATFORM_ESP
+    wifi_run();
+#endif // PLATFORM_ESP
+
+#ifdef FUNCTION_UI
+    ui_run();
+#endif // FUNCTION_UI
+    
+#ifdef FUNCTION_CONTROL
+    control_run();
+#endif // FUNCTION_CONTROL
 
-void blink_lcd(int n, int wait) {
-    for (int i = 0; i < n; i++) {
-        lcd.setBacklight(0);
-        delay(wait);
-        
-        lcd.setBacklight(255);
-        if (i < (n - 1))
-            delay(wait);
+    // blink heartbeat LED
+    if ((millis() - last_led_blink_time) >= LED_BLINK_INTERVAL) {
+        last_led_blink_time = millis();
+        digitalWrite(BUILTIN_LED_PIN, !digitalRead(BUILTIN_LED_PIN));
     }
 }