Basic UI

Boiler.h

@@ -0,0 +1,39 @@
+//
+// Created by robin on 1/27/20.
+//
+
+#ifndef HEATER_BOILER_H
+#define HEATER_BOILER_H
+
+typedef char temp_t;
+
+enum UiStateEnum
+{
+    Hibernate,
+    Lighting,
+    WaterSetting,
+    HeaterSetting
+};
+
+struct UiState
+{
+    UiStateEnum state;
+    unsigned long lastOpMs;
+    unsigned modeSequenceIndex;
+};
+
+struct BoilerLineState
+{
+    temp_t current;
+    temp_t setting;
+    bool isActive;
+};
+
+struct BoilerState
+{
+    BoilerLineState water;
+    BoilerLineState heater;
+    UiState uiState;
+};
+
+#endif //HEATER_BOILER_H

CMakeLists.txt

@@ -18,6 +18,6 @@ set(${CMAKE_PROJECT_NAME}_PORT /dev/ttyUSB3)
 
 
 enable_language(ASM)
-set(${CMAKE_PROJECT_NAME}_ALL_SRCS main.ino)
+set(${CMAKE_PROJECT_NAME}_ALL_SRCS main.ino JC_Button.cpp)
 set(${CMAKE_PROJECT_NAME}_SKETCH main.ino)
 generate_arduino_firmware(${CMAKE_PROJECT_NAME})

JC_Button.cpp

@@ -0,0 +1,100 @@
+// Arduino Button Library
+// https://github.com/JChristensen/JC_Button
+// Copyright (C) 2018 by Jack Christensen and licensed under
+// GNU GPL v3.0, https://www.gnu.org/licenses/gpl.html
+
+#include "JC_Button.h"
+
+/*----------------------------------------------------------------------*
+/ initialize a Button object and the pin it's connected to.             *
+/-----------------------------------------------------------------------*/
+void Button::begin()
+{
+    pinMode(m_pin, m_puEnable ? INPUT_PULLUP : INPUT);
+    m_state = digitalRead(m_pin);
+    if (m_invert) m_state = !m_state;
+    m_time = millis();
+    m_lastState = m_state;
+    m_changed = false;
+    m_lastChange = m_time;
+}
+
+/*----------------------------------------------------------------------*
+/ returns the state of the button, true if pressed, false if released.  *
+/ does debouncing, captures and maintains times, previous state, etc.   *
+/-----------------------------------------------------------------------*/
+bool Button::read()
+{
+    uint32_t ms = millis();
+    bool pinVal = digitalRead(m_pin);
+    if (m_invert) pinVal = !pinVal;
+    if (ms - m_lastChange < m_dbTime)
+    {
+        m_changed = false;
+    }
+    else
+    {
+        m_lastState = m_state;
+        m_state = pinVal;
+        m_changed = (m_state != m_lastState);
+        if (m_changed) m_lastChange = ms;
+    }
+    m_time = ms;
+    return m_state;
+}
+
+/*----------------------------------------------------------------------*
+ * isPressed() and isReleased() check the button state when it was last *
+ * read, and return false (0) or true (!=0) accordingly.                *
+ * These functions do not cause the button to be read.                  *
+ *----------------------------------------------------------------------*/
+bool Button::isPressed()
+{
+    return m_state;
+}
+
+bool Button::isReleased()
+{
+    return !m_state;
+}
+
+/*----------------------------------------------------------------------*
+ * wasPressed() and wasReleased() check the button state to see if it   *
+ * changed between the last two reads and return false (0) or           *
+ * true (!=0) accordingly.                                              *
+ * These functions do not cause the button to be read.                  *
+ *----------------------------------------------------------------------*/
+bool Button::wasPressed()
+{
+    return m_state && m_changed;
+}
+
+bool Button::wasReleased()
+{
+    return !m_state && m_changed;
+}
+
+/*----------------------------------------------------------------------*
+ * pressedFor(ms) and releasedFor(ms) check to see if the button is     *
+ * pressed (or released), and has been in that state for the specified  *
+ * time in milliseconds. Returns false (0) or true (!=0) accordingly.   *
+ * These functions do not cause the button to be read.                  *
+ *----------------------------------------------------------------------*/
+bool Button::pressedFor(uint32_t ms)
+{
+    return m_state && m_time - m_lastChange >= ms;
+}
+
+bool Button::releasedFor(uint32_t ms)
+{
+    return !m_state && m_time - m_lastChange >= ms;
+}
+
+/*----------------------------------------------------------------------*
+ * lastChange() returns the time the button last changed state,         *
+ * in milliseconds.                                                     *
+ *----------------------------------------------------------------------*/
+uint32_t Button::lastChange()
+{
+    return m_lastChange;
+}

JC_Button.h

@@ -0,0 +1,111 @@
+// Arduino Button Library
+// https://github.com/JChristensen/JC_Button
+// Copyright (C) 2018 by Jack Christensen and licensed under
+// GNU GPL v3.0, https://www.gnu.org/licenses/gpl.html
+
+#ifndef JC_BUTTON_H_INCLUDED
+#define JC_BUTTON_H_INCLUDED
+
+#include <Arduino.h>
+
+class Button
+{
+public:
+    // Button(pin, dbTime, puEnable, invert) instantiates a button object.
+    //
+    // Required parameter:
+    // pin      The Arduino pin the button is connected to
+    //
+    // Optional parameters:
+    // dbTime   Debounce time in milliseconds (default 25ms)
+    // puEnable true to enable the AVR internal pullup resistor (default true)
+    // invert   true to interpret a low logic level as pressed (default true)
+    Button(uint8_t pin, uint32_t dbTime=25, uint8_t puEnable=true, uint8_t invert=true)
+            : m_pin(pin), m_dbTime(dbTime), m_puEnable(puEnable), m_invert(invert) {}
+
+    // Initialize a Button object and the pin it's connected to
+    void begin();
+
+    // Returns the current debounced button state, true for pressed,
+    // false for released. Call this function frequently to ensure
+    // the sketch is responsive to user input.
+    bool read();
+
+    // Returns true if the button state was pressed at the last call to read().
+    // Does not cause the button to be read.
+    bool isPressed();
+
+    // Returns true if the button state was released at the last call to read().
+    // Does not cause the button to be read.
+    bool isReleased();
+
+    // Returns true if the button state at the last call to read() was pressed,
+    // and this was a change since the previous read.
+    bool wasPressed();
+
+    // Returns true if the button state at the last call to read() was released,
+    // and this was a change since the previous read.
+    bool wasReleased();
+
+    // Returns true if the button state at the last call to read() was pressed,
+    // and has been in that state for at least the given number of milliseconds.
+    bool pressedFor(uint32_t ms);
+
+    // Returns true if the button state at the last call to read() was released,
+    // and has been in that state for at least the given number of milliseconds.
+    bool releasedFor(uint32_t ms);
+
+    // Returns the time in milliseconds (from millis) that the button last
+    // changed state.
+    uint32_t lastChange();
+
+private:
+    uint8_t m_pin;          // arduino pin number connected to button
+    uint32_t m_dbTime;      // debounce time (ms)
+    bool m_puEnable;        // internal pullup resistor enabled
+    bool m_invert;          // if true, interpret logic low as pressed, else interpret logic high as pressed
+    bool m_state;           // current button state, true=pressed
+    bool m_lastState;       // previous button state
+    bool m_changed;         // state changed since last read
+    uint32_t m_time;        // time of current state (ms from millis)
+    uint32_t m_lastChange;  // time of last state change (ms)
+};
+
+// a derived class for a "push-on, push-off" (toggle) type button.
+// initial state can be given, default is off (false).
+class ToggleButton : public Button
+{
+public:
+
+    // constructor is similar to Button, but includes the initial state for the toggle.
+    ToggleButton(uint8_t pin, bool initialState=false, uint32_t dbTime=25, uint8_t puEnable=true, uint8_t invert=true)
+            : Button(pin, dbTime, puEnable, invert), m_toggleState(initialState) {}
+
+    // read the button and return its state.
+    // should be called frequently.
+    bool read()
+    {
+        Button::read();
+        if (wasPressed())
+        {
+            m_toggleState = !m_toggleState;
+            m_changed = true;
+        }
+        else
+        {
+            m_changed = false;
+        }
+        return m_toggleState;
+    }
+
+    // has the state changed?
+    bool changed() {return m_changed;}
+
+    // return the current state
+    bool toggleState() {return m_toggleState;}
+
+private:
+    bool m_toggleState;
+    bool m_changed;
+};
+#endif

main.ino

@@ -1,8 +1,175 @@
+#include <LiquidCrystal.h>
+#include <JC_Button.h>
+#include "Boiler.h"
+
+#define HIBERNATE_DELAY 5000
+#define TEMP_TRIGGER 10
+
+#define PIN_BTN_MODE 11
+#define PIN_BTN_MINUS 10
+#define PIN_BTN_PLUS 9
+#define PIN_LCD_LED 8
+#define PIN_LCD_RS 7
+#define PIN_LCD_ENABLE 6
+#define PIN_LCD_D0 5
+#define PIN_LCD_D1 4
+#define PIN_LCD_D2 3
+#define PIN_LCD_D3 2
+
+Button g_btnMode(PIN_BTN_MODE);
+Button g_btnMinus(PIN_BTN_MINUS);
+Button g_btnPlus(PIN_BTN_PLUS);
+Button* g_buttons[3] = {&g_btnMode, &g_btnMinus, &g_btnPlus};
+#define BUTTONS_COUNT (sizeof(g_buttons) / sizeof(*g_buttons))
+
+LiquidCrystal g_lcd(PIN_LCD_RS, PIN_LCD_ENABLE, PIN_LCD_D0, PIN_LCD_D1, PIN_LCD_D2, PIN_LCD_D3);
+
+UiStateEnum g_modeSequence[3] = {WaterSetting, HeaterSetting, Lighting};
+#define MODE_SEQUENCE_COUNT (sizeof(g_modeSequence) / sizeof(*g_modeSequence))
+
+BoilerState g_boilerState = {
+        .water = {
+              .current = 44,
+              .setting = 44,
+              .isActive = false
+        },
+        .heater = {
+              .current = 44,
+              .setting = 44,
+              .isActive = false
+        },
+        .uiState = {
+                .state = Lighting,
+                .lastOpMs = 0,
+                .modeSequenceIndex = MODE_SEQUENCE_COUNT - 1
+        }
+};
+
+void printStateLine(char prefix, const BoilerLineState& boilerLineState, bool isModifying, bool isActive, LiquidCrystal lcd)
+{
+    char curTmp[5], setTmp[5], tmp[17];
+    dtostrf(boilerLineState.current / 2.0f, 2, 1, curTmp);
+    dtostrf(boilerLineState.setting / 2.0f, 2, 1, setTmp);
+    int count = snprintf(tmp, sizeof(tmp), "%c: %s [%s]%c%c", prefix, curTmp, setTmp, isModifying ? '<' : ' ', isActive ? 'o' : ' ');
+    for (; count < 17; ++count)
+    {
+        tmp[count] = ' ';
+    }
+    tmp[count] = 0;
+    lcd.print(tmp);
+}
+
+void printState(const BoilerState& boilerState, LiquidCrystal lcd)
+{
+    lcd.setCursor(0, 0);
+    printStateLine('S', boilerState.water, boilerState.uiState.state == WaterSetting, boilerState.water.isActive, lcd);
+    lcd.setCursor(0, 1);
+    printStateLine('C', boilerState.heater, boilerState.uiState.state == HeaterSetting, boilerState.heater.isActive, lcd);
+}
+
 void setup()
 {
+    for (unsigned i = 0; i < BUTTONS_COUNT; ++i)
+    {
+        g_buttons[i]->begin();
+    }
+
+    pinMode(PIN_LCD_LED, OUTPUT);
+    digitalWrite(PIN_LCD_LED, 1);
+
+    g_lcd.begin(16, 2);
+    printState(g_boilerState, g_lcd);
+
     Serial.begin(9600);
 }
 
 void loop()
 {
+    bool needLcdUpdate = false;
+    unsigned long currentMs = millis();
+
+    for (unsigned i = 0; i < BUTTONS_COUNT; ++i)
+    {
+        g_buttons[i]->read();
+        if (g_buttons[i]->isPressed())
+        {
+            g_boilerState.uiState.lastOpMs = currentMs;
+        }
+    }
+
+
+    if (g_boilerState.uiState.state == Hibernate)
+    {
+        for (unsigned i = 0; i < BUTTONS_COUNT; ++i)
+        {
+            if (g_buttons[i]->wasReleased())
+            {
+                g_boilerState.uiState.state = Lighting;
+                digitalWrite(PIN_LCD_LED, 1);
+                break;
+            }
+        }
+        needLcdUpdate = true;
+    }
+    else
+    {
+        if (currentMs - g_boilerState.uiState.lastOpMs >= HIBERNATE_DELAY)
+        {
+            g_boilerState.uiState.state = Hibernate;
+            digitalWrite(PIN_LCD_LED, 0);
+            g_boilerState.uiState.modeSequenceIndex = MODE_SEQUENCE_COUNT - 1;
+            needLcdUpdate = true;
+        }
+        else
+        {
+            if (g_btnMode.wasPressed())
+            {
+                g_boilerState.uiState.modeSequenceIndex =
+                        (g_boilerState.uiState.modeSequenceIndex + 1) % MODE_SEQUENCE_COUNT;
+                g_boilerState.uiState.state = g_modeSequence[g_boilerState.uiState.modeSequenceIndex];
+                needLcdUpdate = true;
+            }
+            else
+            {
+                temp_t* setting = NULL;
+                if (g_boilerState.uiState.state == WaterSetting)
+                {
+                    setting = &g_boilerState.water.setting;
+                }
+                else if (g_boilerState.uiState.state == HeaterSetting)
+                {
+                    setting = &g_boilerState.heater.setting;
+                }
+
+                if (setting)
+                {
+                    if (g_btnMinus.wasReleased())
+                    {
+                        --(*setting);
+                    }
+                    else if (g_btnPlus.wasReleased())
+                    {
+                        ++(*setting);
+                    }
+                    needLcdUpdate = true;
+                }
+            }
+        }
+    }
+
+    if (!g_boilerState.water.isActive && (g_boilerState.water.current <= g_boilerState.water.setting - TEMP_TRIGGER))
+    {
+        g_boilerState.water.isActive = true;
+        needLcdUpdate = true;
+    }
+    else if (g_boilerState.water.isActive && (g_boilerState.water.current >= g_boilerState.water.setting))
+    {
+        g_boilerState.water.isActive = false;
+        needLcdUpdate = true;
+    }
+
+    if (needLcdUpdate)
+    {
+        printState(g_boilerState, g_lcd);
+    }
 }