first commit

.gitignore

@@ -0,0 +1 @@
+.pio

include/GPIOBank.h

@@ -0,0 +1,22 @@
+#ifndef _GPIO_BANK_H_
+#define _GPIO_BANK_H_
+
+class GPIOBank {
+public:
+    GPIOBank(int _size);
+    ~GPIOBank(void);
+    
+    void setPinNumbers(int _pins[]);
+    void setOutput(void);
+    void setInput(bool pullup);
+    
+    int getSize(void);
+    void setPin(int n, bool state);
+    bool getPin(int n);
+    
+private:
+    int size;
+    int *pins;
+};
+
+#endif // _GPIO_BANK_H_

include/Keymatrix.h

@@ -0,0 +1,55 @@
+#ifndef _KEYMATRIX_H_
+#define _KEYMATRIX_H_
+
+#include <CircularBuffer.h>
+
+class Keymatrix {
+public:
+    class Event {
+    public:
+        enum EventType {
+            button_down,
+            button_up,
+            no_event
+        };
+        
+        Event(EventType _type, int _row, int _col);
+        EventType getType(void);
+        int getRow(void);
+        int getCol(void);
+        
+        // helper for 4x3 telephone keypad
+        // -1 is *, -2 is #, or digits 0-9
+        int getNum(void);
+        
+    private:
+        EventType type;
+        int row, col;
+    };
+    
+    Keymatrix(int _rows, int _cols);
+    ~Keymatrix(void);
+    
+    // first rows, then cols
+    void setPins(int _pins[]);
+    void setDebounce(unsigned long ms);
+    
+    void scan(void);
+    
+    bool hasEvent(void);
+    Event getEvent(void);
+
+private:
+    unsigned long debounce;
+    const static unsigned long default_debounce = 5;
+    unsigned long last_scan_time;
+    
+    int rows, cols;
+    int *pins;
+    bool *lastPressed;
+    bool *lastState;
+    
+    CircularBuffer<Event *, 32> events;
+};
+
+#endif // _KEYMATRIX_H_

include/SerialLCD.h

@@ -0,0 +1,28 @@
+#ifndef _SERIAL_LCD_H_
+#define _SERIAL_LCD_H_
+
+#include <SendOnlySoftwareSerial.h>
+
+class SerialLCD {
+public:
+    SerialLCD(int tx_pin);
+    ~SerialLCD(void);
+    
+    void init(void);
+    void clear(void);
+    void setBacklight(uint8_t val);
+    
+    // 0 no cursor, 1 underline, 2 blinking, 3 both
+    void cursor(int style);
+    
+    void position(int line, int col);
+    
+    void write(const char *text);
+    void write(int line, const char *text);
+    void write(int line, int col, const char *text);
+    
+private:
+    SendOnlySoftwareSerial *lcd;
+};
+
+#endif // _SERIAL_LCD_H_

include/Statemachine.h

@@ -0,0 +1,72 @@
+#ifndef _STATEMACHINE_H_
+#define _STATEMACHINE_H_
+
+class Statemachine {
+public:
+    enum States {
+        init,
+        menu, // auto, pumps, valves
+        
+        menu_auto, // select plant
+        menu_auto_mode, // select mode
+        menu_auto_go, // running
+        menu_auto_done,
+        
+        menu_pumps, // selet pump
+        menu_pumps_time, // set runtime
+        menu_pumps_go, // running
+        menu_pumps_running,
+        menu_pumps_done,
+        
+        menu_valves, // select valve
+        menu_valves_time, // set runtime
+        menu_valves_go, // running
+        menu_valves_running,
+        menu_valves_done
+    };
+    
+    class DigitBuffer {
+    public:
+        DigitBuffer(int _size);
+        ~DigitBuffer();
+        
+        bool spaceLeft(void);
+        bool hasDigits(void);
+        int countDigits(void);
+        
+        void addDigit(int d);
+        void removeDigit(void);
+        void clear(void);
+        
+        uint32_t getNumber(void);
+        
+    private:
+        int size;
+        int pos;
+        int *digits;
+    };
+    
+    typedef void (*print_fn)(const char *, const char *, const char *, const char *, int);
+    
+    typedef void (*backspace_fn)(void);
+    
+    Statemachine(print_fn _print, backspace_fn _backspace);
+    void begin(void);
+    
+    void input(int n);
+    void act(void);
+    
+private:
+    void switch_to(States s);
+    uint32_t number_input(void);
+    
+    DigitBuffer db;
+    States state;
+    print_fn print;
+    backspace_fn backspace;
+    
+    uint32_t selected_id; // pump or valve id
+    uint32_t selected_time; // runtime
+};
+
+#endif // _STATEMACHINE_H_

lib/README

@@ -0,0 +1,46 @@
+
+This directory is intended for project specific (private) libraries.
+PlatformIO will compile them to static libraries and link into executable file.
+
+The source code of each library should be placed in a an own separate directory
+("lib/your_library_name/[here are source files]").
+
+For example, see a structure of the following two libraries `Foo` and `Bar`:
+
+|--lib
+|  |
+|  |--Bar
+|  |  |--docs
+|  |  |--examples
+|  |  |--src
+|  |     |- Bar.c
+|  |     |- Bar.h
+|  |  |- library.json (optional, custom build options, etc) https://docs.platformio.org/page/librarymanager/config.html
+|  |
+|  |--Foo
+|  |  |- Foo.c
+|  |  |- Foo.h
+|  |
+|  |- README --> THIS FILE
+|
+|- platformio.ini
+|--src
+   |- main.c
+
+and a contents of `src/main.c`:
+```
+#include <Foo.h>
+#include <Bar.h>
+
+int main (void)
+{
+  ...
+}
+
+```
+
+PlatformIO Library Dependency Finder will find automatically dependent
+libraries scanning project source files.
+
+More information about PlatformIO Library Dependency Finder
+- https://docs.platformio.org/page/librarymanager/ldf.html

platformio.ini

@@ -0,0 +1,23 @@
+; PlatformIO Project Configuration File
+;
+;   Build options: build flags, source filter
+;   Upload options: custom upload port, speed and extra flags
+;   Library options: dependencies, extra library storages
+;   Advanced options: extra scripting
+;
+; Please visit documentation for the other options and examples
+; https://docs.platformio.org/page/projectconf.html
+
+[platformio]
+default_envs = leonardo
+
+[env:leonardo]
+platform = atmelavr
+board = leonardo
+framework = arduino
+upload_port = /dev/ttyACM0
+monitor_port = /dev/ttyACM0
+monitor_speed = 115200
+lib_deps =
+  https://github.com/nickgammon/SendOnlySoftwareSerial
+  https://github.com/rlogiacco/CircularBuffer

src/GPIOBank.cpp

@@ -0,0 +1,51 @@
+#include <Arduino.h>
+#include "GPIOBank.h"
+
+GPIOBank::GPIOBank(int _size) {
+    size = _size;
+    pins = new int[size];
+}
+
+GPIOBank::~GPIOBank(void) {
+    delete pins;
+}
+
+void GPIOBank::setPinNumbers(int _pins[]) {
+    for (int i = 0; i < size; i++) {
+        pins[i] = _pins[i];
+    }
+}
+
+void GPIOBank::setOutput(void) {
+    for (int i = 0; i < size; i++) {
+        pinMode(pins[i], OUTPUT);
+    }
+}
+
+void GPIOBank::setInput(bool pullup) {
+    for (int i = 0; i < size; i++) {
+        if (pullup) {
+            pinMode(pins[i], INPUT_PULLUP);
+        } else {
+            pinMode(pins[i], INPUT);
+        }
+    }
+}
+
+int GPIOBank::getSize(void) {
+    return size;
+}
+
+void GPIOBank::setPin(int n, bool state) {
+    if ((n >= 0) && (n < size)) {
+        digitalWrite(pins[n], state ? HIGH : LOW);
+    }
+}
+
+bool GPIOBank::getPin(int n) {
+    if ((n >= 0) && (n < size)) {
+        return digitalRead(pins[n]);
+    } else {
+        return LOW;
+    }
+}

src/Keymatrix.cpp

@@ -0,0 +1,157 @@
+#include <Arduino.h>
+#include "Keymatrix.h"
+
+//#define DEBUG_PRINT_MATRIX_STATE
+
+Keymatrix::Event::Event(EventType _type, int _row, int _col) {
+    type = _type;
+    row = _row;
+    col = _col;
+}
+
+Keymatrix::Event::EventType Keymatrix::Event::getType(void) {
+    return type;
+}
+
+int Keymatrix::Event::getRow(void) {
+    return row;
+}
+
+int Keymatrix::Event::getCol(void) {
+    return col;
+}
+
+// -1 is *, -2 is #, or digits 0-9
+int Keymatrix::Event::getNum(void) {
+    if (row == 3) {
+        switch (col) {
+        case 0:
+            return -1; // *
+            
+        case 2:
+            return -2; // #
+            
+        default:
+            return 0;
+        }
+    } else {
+        return (row * 3) + col + 1;
+    }
+}
+
+Keymatrix::Keymatrix(int _rows, int _cols) {
+    debounce = default_debounce;
+    last_scan_time = 0;
+    
+    rows = _rows;
+    cols = _cols;
+    
+    pins = new int[rows + cols];
+    lastPressed = new bool[rows * cols];
+    lastState = new bool[rows * cols];
+    
+    for (int i = 0; i < (rows * cols); i++) {
+        lastPressed[i] = false;
+        lastState[i] = false;
+    }
+}
+
+Keymatrix::~Keymatrix(void) {
+    delete pins;
+    delete lastPressed;
+    delete lastState;
+}
+
+// first rows, then cols
+void Keymatrix::setPins(int _pins[]) {
+    for (int i = 0; i < (rows + cols); i++) {
+        pins[i] = _pins[i];
+        
+        // rows as outputs, cols as inputs
+        if (i < rows) {
+            //pinMode(pins[i], OUTPUT);
+            pinMode(pins[i], INPUT);
+        } else {
+            pinMode(pins[i], INPUT_PULLUP);
+        }
+    }
+}
+
+void Keymatrix::setDebounce(unsigned long ms) {
+    debounce = ms;
+}
+
+void Keymatrix::scan(void) {
+    // only continue when enough time has passed
+    unsigned long current_time = millis();
+    if (current_time < (last_scan_time + debounce)) {
+        return;
+    }
+    last_scan_time = current_time;
+    
+    // disable all rows
+    for (int r = 0; r < rows; r++) {
+        //digitalWrite(pins[r], HIGH);
+        pinMode(pins[r], INPUT);
+    }
+    
+    int buttons = rows * cols;
+    bool pressed[buttons];
+    
+    // go through all rows
+    for (int r = 0; r < rows; r++) {
+        // enable current row
+        pinMode(pins[r], OUTPUT);
+        digitalWrite(pins[r], LOW);
+        
+        // read out all columns
+        for (int c = 0; c < cols; c++) {
+            int v = digitalRead(pins[rows + c]);
+            pressed[(r * cols) + c] = (v == LOW);
+        }
+        
+        // disable current row
+        //digitalWrite(pins[r], HIGH);
+        pinMode(pins[r], INPUT);
+    }
+    
+#ifdef DEBUG_PRINT_MATRIX_STATE
+    for (int i = 0; i < buttons; i++) {
+        Serial.print(pressed[i] ? "1" : "0");
+        if (i < (buttons - 1)) {
+            Serial.print(" ");
+        } else {
+            Serial.println();
+        }
+    }
+#endif
+    
+    for (int i = 0; i < buttons; i++) {
+        // debounce - compare to previous state
+        if ((lastPressed[i] == pressed[i]) && (pressed[i] != lastState[i])) {
+            lastState[i] = pressed[i];
+            int c = i % cols;
+            int r = i / cols;
+            Event::EventType et = (pressed[i]) ? Event::button_down : Event::button_up;
+            events.push(new Event(et, r, c));
+        }
+        
+        // save current state for next time
+        lastPressed[i] = pressed[i];
+    }
+}
+
+bool Keymatrix::hasEvent(void) {
+    return !events.isEmpty();
+}
+
+Keymatrix::Event Keymatrix::getEvent(void) {
+    if (hasEvent()) {
+        Event *e = events.shift();
+        Event e_copy = *e;
+        delete e;
+        return e_copy;
+    } else {
+        return Keymatrix::Event(Event::no_event, -1, -1);
+    }
+}

src/SerialLCD.cpp

@@ -0,0 +1,92 @@
+#include <Arduino.h>
+#include "SerialLCD.h"
+
+#define LCD_DELAY 3 // 3
+
+SerialLCD::SerialLCD(int tx_pin) {
+    lcd = new SendOnlySoftwareSerial(tx_pin);
+    lcd->begin(9600);
+}
+
+SerialLCD::~SerialLCD(void) {
+    delete lcd;
+}
+
+void SerialLCD::init(void) {
+    clear();
+    cursor(0);
+    setBacklight(255);
+    
+    lcd->write(0x7C);
+    lcd->write(0x03); // 0x03=20 chars. 0x04=16 chars
+    delay(LCD_DELAY);
+    
+    lcd->write(0x7C);
+    lcd->write(0x05); // 0x05=4 lines, 0x06=2 lines
+    delay(LCD_DELAY);
+}
+
+void SerialLCD::clear(void) {
+    lcd->write(0xFE);
+    lcd->write(0x01);
+    delay(LCD_DELAY);
+}
+
+// 0 no cursor, 1 underline, 2 blinking, 3 both
+void SerialLCD::cursor(int style) {
+    lcd->write(0xFE);
+    lcd->write(0x0C); // display on, no cursor
+    delay(LCD_DELAY);
+    
+    if (style == 1) {
+        lcd->write(0xFE);
+        lcd->write(0x0E); // underline cursor on
+        delay(LCD_DELAY);
+    } else if (style == 2) {
+        lcd->write(0xFE);
+        lcd->write(0x0D); // blinking cursor on
+        delay(LCD_DELAY);
+    } else if (style == 3) {
+        lcd->write(0xFE);
+        lcd->write(0x0F); // both cursors on
+        delay(LCD_DELAY);
+    }
+}
+
+void SerialLCD::setBacklight(uint8_t val) {
+    val = map(val, 0, 255, 0, 30);
+    lcd->write(0x7C);
+    lcd->write(0x80 + val);
+    
+    delay(LCD_DELAY);
+}
+
+void SerialLCD::position(int line, int col) {
+    int cursor = 0;
+    if (line ==  1) {
+        cursor = 64;
+    } else if (line == 2) {
+        cursor = 20;
+    } else if (line == 3) {
+        cursor = 84;
+    }
+    
+    lcd->write(0xFE);
+    lcd->write(0x80 + cursor + col);
+    delay(LCD_DELAY);
+}
+
+void SerialLCD::write(const char *text) {
+    lcd->print(text);
+    delay(LCD_DELAY);
+}
+
+void SerialLCD::write(int line, const char *text) {
+    position(line, 0);
+    write(text);
+}
+
+void SerialLCD::write(int line, int col, const char *text) {
+    position(line, col);
+    write(text);
+}

src/Statemachine.cpp

@@ -0,0 +1,325 @@
+#include <Arduino.h>
+#include "Statemachine.h"
+
+Statemachine::DigitBuffer::DigitBuffer(int _size) {
+    size = _size;
+    pos = 0;
+    digits = new int[size];
+}
+
+Statemachine::DigitBuffer::~DigitBuffer() {
+    delete digits;
+}
+
+bool Statemachine::DigitBuffer::spaceLeft(void) {
+    return (pos < size);
+}
+
+bool Statemachine::DigitBuffer::hasDigits(void) {
+    return (pos > 0);
+}
+
+int Statemachine::DigitBuffer::countDigits(void) {
+    return pos;
+}
+
+void Statemachine::DigitBuffer::addDigit(int d) {
+    if (spaceLeft()) {
+        digits[pos] = d;
+        pos++;
+    }
+}
+
+void Statemachine::DigitBuffer::removeDigit(void) {
+    if (hasDigits()) {
+        pos--;
+    }
+}
+
+void Statemachine::DigitBuffer::clear(void) {
+    pos = 0;
+}
+
+uint32_t Statemachine::DigitBuffer::getNumber(void) {
+    uint32_t fact = 1;
+    uint32_t sum = 0;
+    for (int i = (pos - 1); i >= 0; i--) {
+        sum += digits[i] * fact;
+        fact *= 10;
+    }
+    return sum;
+}
+
+Statemachine::Statemachine(print_fn _print, backspace_fn _backspace)
+        : db(7) {
+    state = init;
+    print = _print;
+    backspace = _backspace;
+    
+    selected_id = 0;
+    selected_time = 0;
+}
+
+void Statemachine::begin(void) {
+    switch_to(init);
+}
+
+void Statemachine::input(int n) {
+    if (state == init) {
+        switch_to(menu);
+    } else if (state == menu) {
+        if (n == 1) {
+            switch_to(menu_auto);
+        } else if (n == 2) {
+            switch_to(menu_pumps);
+        } else if (n == 3) {
+            switch_to(menu_valves);
+        } else if ((n == -1) || (n == -2)) {
+            switch_to(init);
+        }
+    } else if (state == menu_auto) {
+        if ((n == -1) || (n == -2)) {
+            switch_to(menu);
+        } else if (n == 1) {
+            // water only
+            
+        } else if (n == 2) {
+            // with fertilizer
+            
+        }
+    } else if (state == menu_auto_mode) {
+        switch_to(menu);
+    } else if (state == menu_auto_go) {
+        switch_to(menu);
+    } else if (state == menu_auto_done) {
+        switch_to(menu);
+    } else if (state == menu_pumps) {
+        if (n == -1) {
+            if (db.hasDigits()) {
+                backspace();
+                db.removeDigit();
+            } else {
+                switch_to(menu);
+            }
+        } else if (n == -2) {
+            if (!db.hasDigits()) {
+                return;
+            }
+            
+            selected_id = number_input();
+            
+            // TODO validate
+            switch_to(menu_pumps_time);
+        } else {
+            if (db.spaceLeft()) {
+                db.addDigit(n);
+            } else {
+                backspace();
+            }
+        }
+    } else if (state == menu_pumps_time) {
+        if (n == -1) {
+            if (db.hasDigits()) {
+                backspace();
+                db.removeDigit();
+            } else {
+                switch_to(menu_pumps);
+            }
+        } else if (n == -2) {
+            if (!db.hasDigits()) {
+                return;
+            }
+            
+            selected_time = number_input();
+            
+            // TODO validate
+            switch_to(menu_pumps_go);
+        } else {
+            if (db.spaceLeft()) {
+                db.addDigit(n);
+            } else {
+                backspace();
+            }
+        }
+    } else if (state == menu_pumps_go) {
+        switch_to(menu);
+    } else if (state == menu_pumps_running) {
+        switch_to(menu);
+    } else if (state == menu_pumps_done) {
+        switch_to(menu);
+    } else if (state == menu_valves) {
+        if (n == -1) {
+            if (db.hasDigits()) {
+                backspace();
+                db.removeDigit();
+            } else {
+                switch_to(menu);
+            }
+        } else if (n == -2) {
+            if (!db.hasDigits()) {
+                return;
+            }
+            
+            selected_id = number_input();
+            
+            // TODO validate
+            switch_to(menu_valves_time);
+        } else {
+            if (db.spaceLeft()) {
+                db.addDigit(n);
+            } else {
+                backspace();
+            }
+        }
+    } else if (state == menu_valves_time) {
+        if (n == -1) {
+            if (db.hasDigits()) {
+                backspace();
+                db.removeDigit();
+            } else {
+                switch_to(menu_valves);
+            }
+        } else if (n == -2) {
+            if (!db.hasDigits()) {
+                return;
+            }
+            
+            selected_time = number_input();
+            
+            // TODO validate
+            switch_to(menu_valves_go);
+        } else {
+            if (db.spaceLeft()) {
+                db.addDigit(n);
+            } else {
+                backspace();
+            }
+        }
+    } else if (state == menu_valves_go) {
+        switch_to(menu);
+    } else if (state == menu_valves_running) {
+        switch_to(menu);
+    } else if (state == menu_valves_done) {
+        switch_to(menu);
+    }
+}
+
+uint32_t Statemachine::number_input(void) {
+    for (int i = 0; i < db.countDigits(); i++) {
+        backspace();
+    }
+    
+    uint32_t n = db.getNumber();
+    db.clear();
+    
+    Serial.print("Whole number input: ");
+    Serial.println(n);
+    
+    return n;
+}
+
+void Statemachine::act(void) {
+    
+}
+
+void Statemachine::switch_to(States s) {
+    state = s;
+    
+    if (s == init) {
+        print("- Giess-o-mat V0.1 -",
+              "Usage:  Enter number",
+              "* Delete prev. digit",
+              "# Execute input num.",
+              -1);
+    } else if (s == menu) {
+        print("------- Menu -------",
+              "1: Automatic program",
+              "2: Fertilizer pumps",
+              "3: Outlet valves",
+              -1);
+    } else if (s == menu_auto) {
+        print("------- Auto -------",
+              "1: Water only",
+              "2: With fertilizer",
+              "",
+              -1);
+    } else if (s == menu_auto_mode) {
+        print("",
+              "",
+              "",
+              "",
+              -1);
+    } else if (s == menu_auto_go) {
+        print("",
+              "",
+              "",
+              "",
+              -1);
+    } else if (s == menu_auto_done) {
+        print("",
+              "",
+              "",
+              "",
+              -1);
+    } else if (s == menu_pumps) {
+        print("------- Pump -------",
+              "Please select pump",
+              "(Input 1 to 3)",
+              "Pump: ",
+              3);
+    } else if (s == menu_pumps_time) {
+        print("------ Pump X ------",
+              "Please set runtime",
+              "(Input in seconds)",
+              "Runtime: ",
+              3);
+    } else if (s == menu_pumps_go) {
+        print("",
+              "",
+              "",
+              "",
+              -1);
+    } else if (s == menu_pumps_running) {
+        print("",
+              "",
+              "",
+              "",
+              -1);
+    } else if (s == menu_pumps_done) {
+        print("",
+              "",
+              "",
+              "",
+              -1);
+    } else if (s == menu_valves) {
+        print("------ Valves ------",
+              "Please select valve",
+              "(Input 1 to 5)",
+              "Valve: ",
+              3);
+    } else if (s == menu_valves_time) {
+        print("----- Valve XX -----",
+              "Please set runtime",
+              "(Input in seconds)",
+              "Runtime: ",
+              3);
+    } else if (s == menu_valves_go) {
+        print("",
+              "",
+              "",
+              "",
+              -1);
+    } else if (s == menu_valves_running) {
+        print("",
+              "",
+              "",
+              "",
+              -1);
+    } else if (s == menu_valves_done) {
+        print("",
+              "",
+              "",
+              "",
+              -1);
+    }
+}

src/main.cpp

@@ -0,0 +1,253 @@
+#include <Arduino.h>
+#include "Keymatrix.h"
+#include "SerialLCD.h"
+#include "Statemachine.h"
+#include "GPIOBank.h"
+
+//#define DEBUG_WAIT_FOR_SERIAL_CONN
+
+#define DEBUG_ENABLE_LCD_OUTPUT_ON_SERIAL
+#define DEBUG_ENABLE_KEYPAD_INPUT_ON_SERIAL
+
+SerialLCD lcd(9);
+
+Keymatrix keys(4, 3);
+int keymatrix_pins[4 + 3] = { 5, 6, 7, 8, 2, 3, 4 };
+
+GPIOBank valves(5);
+int valve_pins[5] = { 9, 10, 11, 12, 13 };
+
+GPIOBank pumps(3);
+int pump_pins[5] = { 14, 15, 16 };
+
+#define DISPLAY_BACKLIGHT_TIMEOUT (5UL * 60UL * 1000UL)
+unsigned long last_input_time = 0;
+bool backlight_state = true;
+
+bool doing_multi_input = false;
+
+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
+}
+
+void backspace(void) {
+    lcd.write("\b");
+}
+
+Statemachine sm(write_to_all, backspace);
+
+void setup() {
+    Serial.begin(115200);
+    Serial.println("Initializing Giess-o-mat");
+    
+    keys.setPins(keymatrix_pins);
+    
+    valves.setPinNumbers(valve_pins);
+    valves.setOutput();
+    
+    pumps.setPinNumbers(pump_pins);
+    pumps.setOutput();
+
+    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
+    
+    Serial.println("Ready, starting main loop");
+    sm.begin();
+}
+
+void blink_lcd(int n, int wait = 200) {
+    for (int i = 0; i < n; i++) {
+        lcd.setBacklight(0);
+        delay(wait);
+        
+        lcd.setBacklight(255);
+        if (i < (n - 1))
+            delay(wait);
+    }
+}
+
+void loop() {
+    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();
+    
+    if (backlight_state && (millis() >= (last_input_time + DISPLAY_BACKLIGHT_TIMEOUT))) {
+        backlight_state = false;
+        lcd.setBacklight(0);
+    }
+}

test/README

@@ -0,0 +1,11 @@
+
+This directory is intended for PlatformIO Unit Testing and project tests.
+
+Unit Testing is a software testing method by which individual units of
+source code, sets of one or more MCU program modules together with associated
+control data, usage procedures, and operating procedures, are tested to
+determine whether they are fit for use. Unit testing finds problems early
+in the development cycle.
+
+More information about PlatformIO Unit Testing:
+- https://docs.platformio.org/page/plus/unit-testing.html