work on firmware, state machine

include/config.h

@@ -1,6 +1,10 @@
 #ifndef _CONFIG_H_
 #define _CONFIG_H_
 
+/***************************************
+ ********** Firmware Settings **********
+ ***************************************/
+
 #define FIRMWARE_VERSION "0.1"
 
 #define LED_BLINK_INTERVAL 500
@@ -9,6 +13,13 @@
 #define ENCODER_CLICK_BEEP_FREQ 2000
 #define ENCODER_CLICK_BEEP_TIME 50
 
+/***************************************
+ ********** Hardware Settings **********
+ ***************************************/
+
+#define USE_20X4_TEXT_LCD
+//#define USE_FULL_GRAPHIC_LCD
+
 #define XY_BELT_PITCH 2.0
 #define XY_PULLEY_TEETH 40.0
 #define XY_MICRO_STEPS 16.0

include/config_pins.h

@@ -47,6 +47,8 @@
 #define TEMP_0_PIN		13   // ANALOG NUMBERING
 #define TEMP_1_PIN		14   // ANALOG NUMBERING
 
+#ifdef USE_20X4_TEXT_LCD
+
 // from https://reprap.org/wiki/RepRapDiscount_Smart_Controller
 
 //STOP / KILL button
@@ -71,12 +73,20 @@
 //SD card detect pin
 #define SDCARDDETECT 49 //[RAMPS14-SMART-ADAPTER]
 
+#endif // USE_20X4_TEXT_LCD
+
+#ifdef USE_FULL_GRAPHIC_LCD
+
+// TODO
+
+#endif // USE_FULL_GRAPHIC_LCD
+
 #endif // _CONFIG_PINS_H_
 
 #if ((X_MIN_PIN != -1) && (X_MAX_PIN != -1)) || ((X_MIN_PIN == -1) && (X_MAX_PIN == -1))
-#error define one of X_MIN_PIN and X_MAX_PIN
+#error define one of X_MIN_PIN or X_MAX_PIN
 #endif
 
 #if ((Y_MIN_PIN != -1) && (Y_MAX_PIN != -1)) || ((Y_MIN_PIN == -1) && (Y_MAX_PIN == -1))
-#error define one of Y_MIN_PIN and Y_MAX_PIN
+#error define one of Y_MIN_PIN or Y_MAX_PIN
 #endif

include/lcd.h

@@ -1,10 +1,10 @@
 #ifndef _LCD_H_
 #define _LCD_H_
 
-#include <LiquidCrystal.h>
-
-extern LiquidCrystal lcd;
-
 void lcd_init(void);
 
+void lcd_clear(void);
+void lcd_set_heading(const char *heading);
+void lcd_set_text(const char *text);
+
 #endif // _LCD_H_

include/statemachine.h

@@ -1,7 +1,74 @@
 #ifndef _STATE_MACHINE_H_
 #define _STATE_MACHINE_H_
 
-void statemachine_run(int click, int encoder, int kill);
-void statemachine_motors_done(void);
+#include <Array.h>
+
+struct StateMachineInput {
+    StateMachineInput(int c, int e, int k, int m)
+            : click(c), encoder(e), kill(k), motors_done(m) { };
+
+    int click;
+    int encoder;
+    int kill;
+    int motors_done;
+};
+
+class State {
+public:
+    State(State *_parent = NULL);
+    State *getParent(void) { return parent; }
+
+    virtual void setChild(State *_child) { child = _child; }
+    State *getChild(void) { return child; }
+
+    void setTitle(const char *_title) { title = _title; }
+    const char *getTitle(void) { return title; }
+
+    virtual void enterState(void) = 0;
+    virtual void inState(StateMachineInput smi) = 0;
+
+private:
+    State *parent;
+    State *child;
+    const char *title;
+};
+
+class StateText : public State {
+public:
+    StateText(State *_parent = NULL);
+
+    void setHeading(const char *_heading);
+    void setText(const char *_text);
+
+    typedef void(*EnterFuncPtr)(void);
+    typedef void(*InFuncPtr)(StateMachineInput smi);
+
+    void onEnter(EnterFuncPtr func);
+    void whenIn(InFuncPtr func);
+
+    virtual void enterState(void);
+    virtual void inState(StateMachineInput smi);
+
+private:
+    const char *heading;
+    const char *text;
+    EnterFuncPtr onEnterFunc;
+    InFuncPtr whenInFunc;
+};
+
+class StateMenu : public State {
+public:
+    StateMenu(State *_parent = NULL);
+    virtual void setChild(State *_child);
+
+    void addChild(State *_child, int pos = -1);
+
+    virtual void enterState(void);
+    virtual void inState(StateMachineInput smi);
+
+private:
+    int menuPos;
+    Array<State *, 42> children;
+};
 
 #endif // _STATE_MACHINE_H_

include/states.h

@@ -0,0 +1,12 @@
+#ifndef _STATES_H_
+#define _STATES_H_
+
+#include "statemachine.h"
+
+void states_init(void);
+void states_run(struct StateMachineInput smi);
+
+State *states_get(void);
+void states_go_to(State *state);
+
+#endif // _STATES_H_

include/steppers.h

@@ -5,7 +5,7 @@ void steppers_init(void);
 bool steppers_run(void);
 
 bool steppers_homed(void);
-int steppers_start_homing(void);
+void steppers_start_homing(void);
 
 int steppers_move_x(long pos);
 int steppers_move_y(long pos);

platformio.ini

@@ -22,3 +22,4 @@ lib_deps =
     arduino-libraries/LiquidCrystal
     https://github.com/waspinator/AccelStepper
     https://github.com/mathertel/RotaryEncoder
+    https://github.com/janelia-arduino/Array

src/lcd.cpp

@@ -4,14 +4,54 @@
 #include "config_pins.h"
 #include "lcd.h"
 
+#if (defined(USE_20X4_TEXT_LCD) && defined(USE_FULL_GRAPHIC_LCD)) || (!defined(USE_20X4_TEXT_LCD) && !defined(USE_FULL_GRAPHIC_LCD))
+#error define one of USE_20X4_TEXT_LCD or USE_FULL_GRAPHIC_LCD
+#endif
+
+#ifdef USE_20X4_TEXT_LCD
+#include <LiquidCrystal.h>
 LiquidCrystal lcd(LCD_PINS_RS, LCD_PINS_ENABLE, LCD_PINS_D4, LCD_PINS_D5, LCD_PINS_D6, LCD_PINS_D7);
+#endif // USE_20X4_TEXT_LCD
+
+#ifdef USE_FULL_GRAPHIC_LCD
+// TODO
+#endif // USE_FULL_GRAPHIC_LCD
 
 void lcd_init(void) {
+#ifdef USE_20X4_TEXT_LCD
     lcd.begin(20, 4);
+    lcd.clear();
 
     lcd.print(F("    Fuellfix  v2    "));
-    lcd.print(F("    Initializing    "));
+    lcd.print(F("  Initializing....  "));
     lcd.print(F("Software Version "));
     lcd.print(F(FIRMWARE_VERSION));
     lcd.print(F("made by: xythobuz.de"));
+#endif // USE_20X4_TEXT_LCD
+}
+
+void lcd_clear(void) {
+    Serial.println();
+
+#ifdef USE_20X4_TEXT_LCD
+    lcd.clear();
+#endif // USE_20X4_TEXT_LCD
+}
+
+void lcd_set_heading(const char *heading) {
+    Serial.println(heading);
+
+#ifdef USE_20X4_TEXT_LCD
+    lcd.setCursor(0, 0);
+    lcd.print(heading);
+#endif // USE_20X4_TEXT_LCD
+}
+
+void lcd_set_text(const char *text) {
+    Serial.println(text);
+
+#ifdef USE_20X4_TEXT_LCD
+    lcd.setCursor(0, 1);
+    lcd.print(text);
+#endif // USE_20X4_TEXT_LCD
 }

src/main.cpp

@@ -6,7 +6,7 @@
 #include "encoder.h"
 #include "lcd.h"
 #include "steppers.h"
-#include "statemachine.h"
+#include "states.h"
 
 void setup() {
     pinMode(LED_PIN, OUTPUT);
@@ -115,27 +115,27 @@ void setup() {
 
     // wait some time to show splash screen
     delay(2000);
+
+    Serial.println(F("Init state machine"));
+    states_init();
+
     blocking_beep(100, 2000);
     Serial.println(F("starting main loop"));
 }
 
 void loop() {
     unsigned long t = millis();
-
     common_run(t);
+    bool still_running = steppers_run();
     encoder_run();
 
     int click = encoder_click();
+    int kill = kill_switch();
+
     if (click) {
         async_beep(ENCODER_CLICK_BEEP_TIME, ENCODER_CLICK_BEEP_FREQ);
     }
 
-    int kill = kill_switch();
-
-    statemachine_run(click, encoder_change(), kill);
-
-    bool still_running = steppers_run();
-    if (!still_running) {
-        statemachine_motors_done();
-    }
+    struct StateMachineInput smi(click, encoder_change(), kill, !still_running);
+    states_run(smi);
 }

src/statemachine.cpp

@@ -2,56 +2,79 @@
 
 #include "config.h"
 #include "config_pins.h"
-#include "common.h"
 #include "lcd.h"
-#include "steppers.h"
-#include "statemachine.h"
+#include "states.h"
 
-enum states {
-    sm_init,
-    sm_ask_homing,
-    sm_do_homing,
-    sm_menu
-};
+State::State(State *_parent) : parent(_parent), child(NULL), title("no title") {
+    if (_parent != NULL) {
+        _parent->setChild(this);
+    }
+}
 
-static states state = sm_init;
+// --------------------------------------
 
-static void switch_state(states s) {
-    state = s;
+StateText::StateText(State *_parent) : State(_parent) {
+    heading = "";
+    text = "";
+    onEnterFunc = []() { };
+    whenInFunc = [](StateMachineInput smi) {
+        State *s = states_get();
+        if (smi.click && (s != NULL) && (s->getChild() != NULL)) {
+            states_go_to(s->getChild());
+        }
+    };
+}
 
-    if (state == sm_ask_homing) {
-        lcd.clear();
-        lcd.print(F("  Homing Required!"));
-        lcd.setCursor(0, 2);
-        lcd.print(F(" Click to home XYZE"));
-    } else if (state == sm_do_homing) {
+void StateText::setHeading(const char *_heading) {
+    heading = _heading;
+}
 
-    } else if (state == sm_menu) {
+void StateText::setText(const char *_text) {
+    text = _text;
+}
 
-    }
+void StateText::onEnter(EnterFuncPtr func) {
+    onEnterFunc = func;
 }
 
-void statemachine_run(int click, int encoder, int kill) {
-    if (state == sm_init) {
-        if (click) {
-            switch_state(sm_ask_homing);
-        }
-    } else if (state == sm_ask_homing) {
-        if (click) {
-            switch_state(sm_do_homing);
-        }
-    } else if (state == sm_do_homing) {
+void StateText::whenIn(InFuncPtr func) {
+    whenInFunc = func;
+}
 
-    } else if (state == sm_menu) {
+void StateText::enterState(void) {
+    lcd_clear();
+    lcd_set_heading(heading);
+    lcd_set_text(text);
 
-    }
+    onEnterFunc();
 }
 
-void statemachine_motors_done(void) {
-    if (state == sm_do_homing) {
-        if (steppers_homed()) {
-            async_beep(100, 2000);
-            switch_state(sm_menu);
-        }
+void StateText::inState(struct StateMachineInput smi) {
+    whenInFunc(smi);
+}
+
+// --------------------------------------
+
+StateMenu::StateMenu(State *_parent) : State(_parent) {
+    menuPos = 0;
+}
+
+void StateMenu::setChild(State *_child) {
+    children.push_back(_child);
+}
+
+void StateMenu::addChild(State *_child, int pos) {
+    if (pos < 0) {
+        setChild(_child);
+    } else {
+        // TODO insert child at pos in children
     }
 }
+
+void StateMenu::enterState(void) {
+    menuPos = 0;
+}
+
+void StateMenu::inState(struct StateMachineInput smi) {
+
+}

src/states.cpp

@@ -0,0 +1,87 @@
+#include <Arduino.h>
+
+#include "config.h"
+#include "config_pins.h"
+#include "common.h"
+#include "lcd.h"
+#include "steppers.h"
+#include "statemachine.h"
+#include "states.h"
+
+// --------------------------------------
+
+StateText sm_ask_homing = StateText();
+StateText sm_do_homing = StateText(&sm_ask_homing);
+StateMenu sm_menu = StateMenu(&sm_do_homing);
+
+StateMenu sm_auto = StateMenu(&sm_menu);
+
+StateMenu sm_config = StateMenu(&sm_menu);
+
+// --------------------------------------
+
+State *current_state = NULL;
+
+void states_init(void) {
+    // ----------------------------------
+
+    sm_ask_homing.setHeading("Homing Required!");
+    sm_ask_homing.setText("Click to home all four axes.");
+
+    // ----------------------------------
+
+    sm_do_homing.setTitle("Home all axes");
+    sm_do_homing.setHeading("Homing");
+
+    sm_do_homing.onEnter([]() {
+        steppers_start_homing();
+    });
+
+    sm_do_homing.whenIn([](StateMachineInput smi) {
+        if (smi.motors_done) {
+            if (steppers_homed()) {
+                async_beep(100, 2000);
+                states_go_to(&sm_menu);
+            }
+        }
+
+        // TODO update text with current axis
+    });
+
+    // ----------------------------------
+
+    sm_menu.setTitle("Main Menu");
+    sm_menu.addChild(&sm_do_homing, 1);
+
+    // ----------------------------------
+
+    sm_auto.setTitle("Filling Menu");
+    sm_auto.setChild(&sm_menu);
+
+    // ----------------------------------
+
+    sm_config.setTitle("Configuration");
+    sm_auto.setChild(&sm_menu);
+
+    // ----------------------------------
+
+    states_go_to(&sm_ask_homing);
+}
+
+void states_run(StateMachineInput smi) {
+    if (current_state != NULL) {
+        current_state->inState(smi);
+    }
+}
+
+State *states_get(void) {
+    return current_state;
+}
+
+void states_go_to(State *state) {
+    current_state = state;
+
+    if (current_state != NULL) {
+        current_state->enterState();
+    }
+}

src/steppers.cpp

@@ -75,7 +75,7 @@ bool steppers_homed(void) {
     return (state == step_homed);
 }
 
-int steppers_start_homing(void) {
+void steppers_start_homing(void) {
     state = step_homing_x_fast;
 
 }