more work on firmware, support for full graphic smart lcd.

include/config.h

 
 #define FIRMWARE_VERSION "0.1"
 
-#define LED_BLINK_INTERVAL 500
+#define LED_BLINK_INTERVAL 1000
 #define DEBOUNCE_DELAY 50
 
 #define ENCODER_CLICK_BEEP_FREQ 2000
 #define ENCODER_CLICK_BEEP_TIME 50
 
+#define HOMING_BEEP_FREQ 3000
+#define HOMING_BEEP_TIME 100
+
+#define KILL_BEEP_FREQ 3000
+#define KILL_BEEP_TIME 100
+#define KILL_BEEP_REPEAT 5
+
 /***************************************
  ********** Hardware Settings **********
  ***************************************/
 
-#define USE_20X4_TEXT_LCD
-//#define USE_FULL_GRAPHIC_LCD
-
 // xy steps per mm
 #define XY_BELT_PITCH 2.0
 #define XY_PULLEY_TEETH 40.0
 #define Z_STEPS_PER_MM (Z_MOTOR_STEPS_PER_REV / Z_ROD_PITCH)
 
 // e steps per mm
+// 1/2 turn of output is movement range
+// gear box factor 3:1 output:input
+// 3/2 turns of motor equals 100% movement
+// (16 * 200) = 3200 steps for motor turn
+// 3200 * 3 / 2 = 4800 steps for 3/2 turn
+// 4800 / 100 = 48 steps for one percent of movement
+#define GEARBOX_MULT 3
+#define OUTPUT_TURN_DIV 2
 #define E_MICRO_STEPS 16.0
 #define E_MOTOR_STEPS_PER_REV (200.0 * E_MICRO_STEPS)
-#define E_STEPS_PER_MM (E_MOTOR_STEPS_PER_REV / 42) // TODO
+#define E_STEPS_PER_PERCENT (E_MOTOR_STEPS_PER_REV * GEARBOX_MULT / OUTPUT_TURN_DIV / 100.0)
 
 // travel lengths
 #define X_AXIS_MIN -5.0 // in mm
 #define E_AXIS_MIN 0.0 // in mm
 #define E_AXIS_MAX 6.0 // in mm
 
+//   0 degree =   0 percent =  pi = 0mm
+// 180 degree = 100 percent = 2pi = 6mm
+// (cos(pi + x / 100 * pi) + 1) / 2 * 6mm
+#define E_PERCENT_TO_MM(x) ((cos(PI + (x * PI / 100.0)) + 1.0) / 2.0 * E_AXIS_MAX)
+#define E_MM_TO_PERCENT(x) ((acos((x * 2.0 / E_AXIS_MAX) - 1.0) - PI) * 100.0 / PI)
+
 // maximum speeds
 #define XY_MAX_SPEED 50.0 // in mm/s
 #define Z_MAX_SPEED 20.0 // in mm/s
-#define E_MAX_SPEED 10.0 // in mm/s
+#define E_MAX_SPEED 50.0 // in percent/s
 
 // homing speeds
 #define XY_FAST_HOME_SPEED 2.5 // in mm/s
 #define XY_SLOW_HOME_SPEED 1.0 // in mm/s
 #define Z_FAST_HOME_SPEED 2.0 // in mm/s
 #define Z_SLOW_HOME_SPEED 1.0 // in mm/s
-#define E_FAST_HOME_SPEED 0.1 // in mm/s
-#define E_SLOW_HOME_SPEED 0.05 // in mm/s
+#define E_FAST_HOME_SPEED 10.0 // in percent/s
+#define E_SLOW_HOME_SPEED 5.0 // in percent/s
 
 // accelerations
 #define XY_MAX_ACCEL 100.0 // in mm/s^2
 #define Z_MAX_ACCEL 50.0 // in mm/s^2
-#define E_MAX_ACCEL 20.0 // in mm/s^2
+#define E_MAX_ACCEL 1000.0 // in percent/s^2
 
 // axis movement directions (1.0 normal, -1.0 inverted)
 #define X_AXIS_MOVEMENT_DIR 1.0

include/config_pins.h

 
 #ifdef USE_FULL_GRAPHIC_LCD
 
-// TODO
+// based on https://reprap.org/wiki/RepRapDiscount_Full_Graphic_Smart_Controller
+
+// STOP / KILL button
+#define KILL_PIN 41
+
+// lcd pins
+#define LCD_PINS_CS 16
+#define LCD_PINS_MOSI 17
+#define LCD_PINS_SCK 23
+
+// encoder pins
+#define BTN_EN1 31
+#define BTN_EN2 33
+#define BTN_ENC 35
+
+// beeper
+#define BEEPER 37
 
 #endif // USE_FULL_GRAPHIC_LCD
 
 #define E_HOMING_DIR -1.0
 #define E_ENDSTOP_PIN E_MIN_PIN
 #endif
+
+#ifdef KILL_PIN
+#if (KILL_PIN == -1)
+#undef KILL_PIN
+#endif
+#endif // KILL_PIN

include/data.h

 void data_init(void);
 void data_eeprom_write(void);
 
+bool data_eeprom_read(void);
+const char *data_eeprom_error(void);
+
 struct data_config_options *data_options(void);
 
 unsigned int data_preset_count(void);
 struct data_config_preset *data_preset(unsigned int i);
-void data_preset_add(struct data_config_preset preset);
-void data_preset_remove(unsigned int i);
+bool data_preset_add(struct data_config_preset preset);
+bool data_preset_remove(unsigned int i);
 
 #endif // _DATA_H_

include/lcd.h

 #define _LCD_H_
 
 void lcd_init(void);
+void lcd_loop(void);
 
 void lcd_clear(void);
 void lcd_set_heading(const char *heading);
 void lcd_set_text(const char *text);
+void lcd_set_menu_text(int line, const char *text);
+
+int lcd_text_lines(void);
 
 #endif // _LCD_H_

include/statemachine.h

 
 #include <Array.h>
 
+#define STATE_ARRAY_SIZE 42
+
+template <typename T, size_t N>
+void array_print(Array<T, N> *arr);
+
+template <typename T, size_t N>
+void array_insert_at_pos(Array<T, N> *arr, T value, size_t pos);
+
 struct StateMachineInput {
     StateMachineInput(int c, int e, int k, int m)
             : click(c), encoder(e), kill(k), motors_done(m) { };
 
 class StateMenu : public State {
 public:
-    StateMenu(State *_parent = NULL);
+    StateMenu(State *_parent = NULL, bool _show_parent = true);
     virtual void setChild(State *_child);
 
     void addChild(State *_child, int pos = -1);
     virtual void inState(StateMachineInput smi);
 
 private:
-    int menuPos;
-    Array<State *, 42> children;
+    void display(void);
+
+    bool show_parent;
+    int menuPos, menuOff;
+    Array<State *, STATE_ARRAY_SIZE> children;
 };
 
 class StateDynamicMenu : public State {
     GetFuncPtr getFunc;
     CallFuncPtr callFunc;
 
+    int menuPos, menuOff;
     int count;
-    Array<const char *, 42> contents;
+    Array<const char *, STATE_ARRAY_SIZE> contents;
+};
+
+template <typename T>
+class StateValue : public State {
+public:
+    StateValue(State *_parent, T &_value, T _min, T _max);
+
+    typedef void(*UpdateFuncPtr)(T value);
+
+    void onUpdate(UpdateFuncPtr func);
+
+    virtual void enterState(void);
+    virtual void inState(StateMachineInput smi);
+
+private:
+    void display(void);
+
+    T &value;
+    T min, max;
+    UpdateFuncPtr updateFunc;
 };
 
+
 #endif // _STATE_MACHINE_H_

include/steppers.h

 int steppers_move_z(long pos);
 int steppers_move_e(long pos);
 
+void steppers_kill(void);
+
+void steppers_set_speed_x(float speed);
+void steppers_set_speed_y(float speed);
+void steppers_set_speed_z(float speed);
+void steppers_set_speed_e(float speed);
+
+void steppers_set_accel_x(float accel);
+void steppers_set_accel_y(float accel);
+void steppers_set_accel_z(float accel);
+void steppers_set_accel_e(float accel);
+
 #endif // _STEPPERS_H_

platformio.ini

 ; https://docs.platformio.org/page/projectconf.html
 
 [platformio]
-default_envs = arduino
+default_envs = ramps_lcd2004, ramps_lcd12864
 
-[env:arduino]
+[env:ramps_lcd2004]
 platform = atmelavr
 board = megaatmega2560
 framework = arduino
+build_flags = -D USE_20X4_TEXT_LCD -Wno-sign-compare
 upload_port = /dev/ttyUSB1
 monitor_port = /dev/ttyUSB1
 monitor_speed = 115200
     https://github.com/waspinator/AccelStepper
     https://github.com/mathertel/RotaryEncoder
     https://github.com/janelia-arduino/Array
+
+[env:ramps_lcd12864]
+platform = atmelavr
+board = megaatmega2560
+framework = arduino
+build_flags = -D USE_FULL_GRAPHIC_LCD -Wno-sign-compare
+upload_port = /dev/ttyUSB1
+monitor_port = /dev/ttyUSB1
+monitor_speed = 115200
+lib_deps =
+    u8g2
+    https://github.com/waspinator/AccelStepper
+    https://github.com/mathertel/RotaryEncoder
+    https://github.com/janelia-arduino/Array

src/data.cpp

 #include "config_pins.h"
 #include "data.h"
 
+// TODO make defines platform specific
 #define EEPROM_SIZE 4096
+#define RAM_SIZE (8192 / 2)
 
 struct data_config {
     uint8_t data_schema_version;
 };
 
 static struct data_config d;
+static const char *last_error = "";
 
-static unsigned int max_presets(void) {
+static unsigned int max_presets_eeprom(void) {
     unsigned int s = EEPROM_SIZE - sizeof(struct data_config) + sizeof(struct data_config_preset *);
     return s / sizeof(struct data_config_preset);
 }
 
+static unsigned int max_presets_ram(void) {
+    unsigned int s = RAM_SIZE - sizeof(struct data_config) + sizeof(struct data_config_preset *);
+    return s / sizeof(struct data_config_preset);
+}
+
+static unsigned int max_presets(void) {
+    unsigned int eeprom = max_presets_eeprom();
+    unsigned int ram = max_presets_ram();
+    return (eeprom < ram) ? eeprom : ram;
+}
+
 static uint32_t data_checksum(struct data_config *data) {
     uint32_t c = 0;
 
     return c;
 }
 
-static bool data_eeprom_read(void) {
+const char *data_eeprom_error(void) {
+    return last_error;
+}
+
+bool data_eeprom_read(void) {
     struct data_config config;
     uint8_t *data = (uint8_t *)&config;
 
     }
 
     if (config.preset_count > 0) {
-        config.presets = (struct data_config_preset *)malloc(config.preset_count * sizeof(struct data_config_preset));
-        if (config.presets == NULL) {
-            Serial.print(F("Alloc "));
+        if (config.preset_count > max_presets()) {
+            last_error = "Preset";
             return false;
         }
 
-        if (config.preset_count > max_presets()) {
-            Serial.print(F("Preset "));
+        config.presets = (struct data_config_preset *)malloc(config.preset_count * sizeof(struct data_config_preset));
+        if (config.presets == NULL) {
+            last_error = "Alloc";
             return false;
         }
 
     }
 
     // verify checksum
+    uint32_t read_checksum = config.checksum;
+    config.checksum = 0;
     uint32_t checksum = data_checksum(&config);
-    if (config.checksum == checksum) {
+    if (read_checksum == checksum) {
         // verify version
         if (config.data_schema_version == DATA_SCHEMA_VERSION) {
             if (d.presets != NULL) {
             }
             d = config;
 
+            last_error = "";
             return true;
         } else {
-            Serial.print(F("Version "));
+            last_error = "Version";
             return false;
         }
     } else {
-        Serial.print(F("Checksum "));
+        Serial.print("read=");
+        Serial.print(config.checksum);
+        Serial.print(" calc=");
+        Serial.println(checksum);
+        last_error = "Checksum";
         return false;
     }
 }
 
 void data_eeprom_write(void) {
+    d.checksum = 0;
     d.checksum = data_checksum(&d);
 
     // write meta-data and settings
 
     d.presets = NULL;
 
+    Serial.print(F("EEPROM max presets: "));
+    Serial.println(max_presets());
+
     Serial.print(F("EEPROM read... "));
     if (!data_eeprom_read()) {
-        Serial.println(F("Error"));
+        Serial.print(last_error);
+        Serial.println(F(" Error"));
     } else {
         Serial.println(F("Ok"));
     }
     return NULL;
 }
 
-void data_preset_add(struct data_config_preset preset) {
-
+bool data_preset_add(struct data_config_preset preset) {
+    if ((d.preset_count == 0) || (d.presets == NULL)) {
+        d.preset_count = 1;
+        d.presets = (struct data_config_preset *)malloc(d.preset_count * sizeof(struct data_config_preset));
+        if (d.presets == NULL) {
+            d.preset_count = 0;
+            last_error = "Alloc";
+            return false;
+        } else {
+            d.presets[d.preset_count - 1] = preset;
+            return true;
+        }
+    } else if (d.preset_count < max_presets()) {
+        d.preset_count += 1;
+        struct data_config_preset *new_mem = (struct data_config_preset *)realloc(d.presets, d.preset_count * sizeof(struct data_config_preset));
+        if (new_mem == NULL) {
+            d.preset_count -= 1;
+            last_error = "Realloc";
+            return false;
+        } else {
+            d.presets = new_mem;
+            d.presets[d.preset_count - 1] = preset;
+            return true;
+        }
+    } else {
+        return false;
+    }
 }
 
-void data_preset_remove(unsigned int i) {
-
+bool data_preset_remove(unsigned int i) {
+    if (d.preset_count == 1) {
+        d.preset_count = 0;
+        free(d.presets);
+        d.presets = NULL;
+        return true;
+    } else if (d.preset_count > 1) {
+        for (int j = i; j < (d.preset_count - 1); j++) {
+            d.presets[j] = d.presets[j + 1];
+        }
+        d.preset_count -= 1;
+        struct data_config_preset *new_mem = (struct data_config_preset *)realloc(d.presets, d.preset_count * sizeof(struct data_config_preset));
+        if (new_mem == NULL) {
+            d.preset_count += 1;
+            last_error = "Realloc";
+            return false;
+        } else {
+            d.presets = new_mem;
+            return true;
+        }
+    } else {
+        return true; // nothing to delete
+    }
 }

src/encoder.cpp

 #include "debounce.h"
 #include "encoder.h"
 
+//#define DEBUG_ENCODER
+
 static Debouncer click(BTN_ENC);
 static int click_state = 0;
 static bool ignore_until_next_unclick = false;
 
+#ifdef KILL_PIN
 static Debouncer kill(KILL_PIN);
 static int kill_state = 0;
+#endif // KILL_PIN
 
-static RotaryEncoder encoder(BTN_EN1, BTN_EN2, RotaryEncoder::LatchMode::TWO03);
+static RotaryEncoder encoder(BTN_EN1, BTN_EN2, RotaryEncoder::LatchMode::FOUR3);
 static int pos = 0;
 
 void encoder_init(void) {
-    pinMode(BTN_ENC, INPUT);
-    pinMode(KILL_PIN, INPUT);
+    pinMode(BTN_ENC, INPUT_PULLUP);
+
+#ifdef KILL_PIN
+    pinMode(KILL_PIN, INPUT_PULLUP);
+#endif // KILL_PIN
 }
 
 void encoder_run(void) {
         click_state = cs;
     }
 
+#ifdef KILL_PIN
     kill_state = kill.poll();
+#endif // KILL_PIN
 
     encoder.tick();
 }
     int new_pos = encoder.getPosition();
     int diff = new_pos - pos;
     pos = new_pos;
+
+#ifdef DEBUG_ENCODER
+    if (diff != 0) {
+        Serial.print("encoder_change: ");
+        Serial.print(diff);
+        Serial.print(" ticks: ");
+        Serial.println(new_pos);
+    }
+#endif // DEBUG_ENCODER
+
     return diff;
 }
 
     if (r == 1) {
         click_state = 0;
         ignore_until_next_unclick = true;
+
+#ifdef DEBUG_ENCODER
+        Serial.println("encoder_click: 1");
+#endif // DEBUG_ENCODER
     }
 
     return r;
 }
 
 int kill_switch(void) {
+#ifdef KILL_PIN
+#ifdef DEBUG_ENCODER
+    if (kill_state == 1) {
+        Serial.println("kill_switch: 1");
+    }
+#endif // DEBUG_ENCODER
+
     return kill_state;
+#else
+    return 0;
+#endif // KILL_PIN
 }

src/lcd.cpp

 #endif
 
 #ifdef USE_20X4_TEXT_LCD
+
 #include <LiquidCrystal.h>
+
+#define LCD_HEADING_LINES 1
+#define LCD_HEADING_WIDTH 20
+#define LCD_TEXT_LINES 3
+#define LCD_TEXT_WIDTH 20
+
 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
+
+#include <U8g2lib.h>
+
+#define LCD_HEADING_LINES 1
+#define LCD_HEADING_WIDTH 15
+#define LCD_TEXT_LINES 5
+#define LCD_TEXT_WIDTH 25
+
+#define LCD_HEADING_FONT u8g2_font_torussansbold8_8r
+#define LCD_TEXT_FONT u8g2_font_5x7_tr
+
+#define LCD_HEADING_TEXT_OFFSET 3
+#define LCD_HEADING_HEIGHT 8
+#define LCD_TEXT_HEIGHT 9
+
+U8G2_ST7920_128X64_1_SW_SPI lcd(U8G2_R0, LCD_PINS_SCK, LCD_PINS_MOSI, LCD_PINS_CS);
+
 #endif // USE_FULL_GRAPHIC_LCD
 
+String heading[LCD_HEADING_LINES];
+String text[LCD_TEXT_LINES];
+
+String heading_pre, heading_post;
+String text_pre, text_post;
+int heading_direction, text_direction;
+
+String menu_pre[LCD_TEXT_LINES], menu_post[LCD_TEXT_LINES];
+int menu_dir[LCD_TEXT_LINES];
+
+boolean redraw = false;
+
+enum lcd_text_mode {
+    lcd_mode_none,
+    lcd_mode_multiline,
+    lcd_mode_menu
+};
+enum lcd_text_mode text_mode = lcd_mode_none;
+
+#define SCROLL_DELAY 500
+unsigned long last_scroll_time = 0;
+
+void lcd_shorten_multiline(String s[], int n, int w, String *remainder) {
+    // if a line is longer then w, take end off and put in front of next line
+    String for_next_line = "";
+    for (int i = 0; i < n; i++) {
+        s[i] = for_next_line + s[i];
+        for_next_line = "";
+        if (s[i].length() > w) {
+            for_next_line = s[i].substring(w);
+            s[i] = s[i].substring(0, w);
+        }
+    }
+
+    // if something remains at end, store remainder, if given, otherwise leave at last line
+    if (remainder != NULL) {
+        *remainder = for_next_line;
+    } else {
+        s[n - 1] = s[n - 1] + for_next_line;
+    }
+
+    last_scroll_time = millis();
+}
+
+void lcd_scroll_multiline(String s[], int n, int w, String &pre, String &post, int &dir) {
+    if (dir == 0) {
+        // switch directions if done scrolling in current direction
+        if (post.length() == 0) {
+            dir = 1;
+            return;
+        }
+
+        // take first char of first line, append to pre
+        pre = pre + s[0][0];
+        s[0] = s[0].substring(1);
+
+        // shift now empty spot to the left through lines
+        for (int i = 1; i < n; i++) {
+            s[i - 1] = s[i - 1] + s[i][0];
+            s[i] = s[i].substring(1);
+        }
+
+        // fill empty spot at end of last line with first char of post
+        s[n - 1] = s[n - 1] + post[0];
+        post = post.substring(1);
+    } else {
+        // switch directions if done scrolling in current direction
+        if (pre.length() == 0) {
+            dir = 0;
+            return;
+        }
+
+        // take last char of last line, prepend to post
+        post = s[n - 1][s[n - 1].length() - 1] + post;
+        s[n - 1] = s[n - 1].substring(0, s[n - 1].length() - 1);
+
+        // shift now empty sport to the right through lines
+        for (int i = n - 1; i >= 1; i--) {
+            s[i] = s[i - 1][s[i - 1].length() - 1] + s[i];
+            s[i - 1] = s[i - 1].substring(0, s[i - 1].length() - 1);
+        }
+
+        // fill empty spot at beginning with last char of pre
+        s[0] = pre[pre.length() - 1] + s[0];
+        pre = pre.substring(0, pre.length() - 1);
+    }
+
+    redraw = true;
+}
+
+void lcd_scrolling(void) {
+    if (text_mode != lcd_mode_none) {
+        if ((heading_pre.length() > 0) || (heading_post.length() > 0)) {
+            lcd_scroll_multiline(heading, LCD_HEADING_LINES, LCD_HEADING_WIDTH,
+                                 heading_pre, heading_post, heading_direction);
+        }
+    }
+
+    if (text_mode == lcd_mode_multiline) {
+        if ((text_pre.length() > 0) || (text_post.length() > 0)) {
+            lcd_scroll_multiline(text, LCD_TEXT_LINES, LCD_TEXT_WIDTH,
+                                 text_pre, text_post, text_direction);
+        }
+    } else if (text_mode == lcd_mode_menu) {
+        for (int i = 0; i < LCD_TEXT_LINES; i++) {
+            if ((menu_pre[i].length() > 0) || (menu_post[i].length() > 0)) {
+                lcd_scroll_multiline(text + i, 1, LCD_TEXT_WIDTH,
+                                     menu_pre[i], menu_post[i], menu_dir[i]);
+            }
+        }
+    }
+}
+
+int lcd_text_lines(void) {
+    return LCD_TEXT_LINES;
+}
+
 void lcd_init(void) {
 #ifdef USE_20X4_TEXT_LCD
     lcd.begin(20, 4);
     lcd.print(F(FIRMWARE_VERSION));
     lcd.print(F("made by: xythobuz.de"));
 #endif // USE_20X4_TEXT_LCD
+
+#ifdef USE_FULL_GRAPHIC_LCD
+    lcd.begin();
+
+    lcd.firstPage();
+    do {
+        lcd.setFont(u8g2_font_luBS12_tr);
+        lcd.drawStr(0, 14 * 1, "Fuellfix v2");
+        lcd.drawStr(0, 14 * 2, "Initializing");
+
+        lcd.setFont(u8g2_font_t0_12b_tr);
+        lcd.drawStr(0, 14 * 2 + 8 + 12 * 1, "Software Version " FIRMWARE_VERSION);
+        lcd.drawStr(0, 14 * 2 + 8 + 12 * 2, "made by: xythobuz.de");
+    } while (lcd.nextPage());
+#endif // USE_FULL_GRAPHIC_LCD
+}
+
+void lcd_loop(void) {
+    if ((millis() - last_scroll_time) >= SCROLL_DELAY) {
+        last_scroll_time = millis();
+        lcd_scrolling();
+    }
+
+#ifdef USE_FULL_GRAPHIC_LCD
+    if (redraw) {
+        lcd.firstPage();
+        do {
+            lcd.setFont(LCD_HEADING_FONT);
+            for (int i = 0; i < LCD_HEADING_LINES; i++) {
+                lcd.drawStr(0, LCD_HEADING_HEIGHT * (i + 1), heading[i].c_str());
+            }
+
+            lcd.setFont(LCD_TEXT_FONT);
+            for (int i = 0; i < LCD_TEXT_LINES; i++) {
+                lcd.drawStr(0, LCD_HEADING_HEIGHT * LCD_HEADING_LINES + LCD_HEADING_TEXT_OFFSET + LCD_TEXT_HEIGHT * (i + 1), text[i].c_str());
+            }
+        } while (lcd.nextPage());
+        redraw = false;
+    }
+#endif // USE_FULL_GRAPHIC_LCD
 }
 
 void lcd_clear(void) {
     Serial.println();
 
+    text_mode = lcd_mode_none;
+
 #ifdef USE_20X4_TEXT_LCD
     lcd.clear();
 #endif // USE_20X4_TEXT_LCD
+
+#ifdef USE_FULL_GRAPHIC_LCD
+    for (int i = 0; i < LCD_HEADING_LINES; i++) {
+        heading[i] = "";
+    }
+    for (int i = 0; i < LCD_TEXT_LINES; i++) {
+        text[i] = "";
+    }
+    redraw = true;
+#endif // USE_FULL_GRAPHIC_LCD
 }
 
-void lcd_set_heading(const char *heading) {
-    Serial.println(heading);
+void lcd_set_heading(const char *h) {
+    Serial.println(h);
 
 #ifdef USE_20X4_TEXT_LCD
     lcd.setCursor(0, 0);
-    lcd.print(heading);
+    lcd.print(h);
 #endif // USE_20X4_TEXT_LCD
+
+#ifdef USE_FULL_GRAPHIC_LCD
+    heading[0] = h;
+    heading_pre = "";
+    heading_direction = 0;
+    lcd_shorten_multiline(heading, LCD_HEADING_LINES, LCD_HEADING_WIDTH, &heading_post);
+    redraw = true;
+#endif // USE_FULL_GRAPHIC_LCD
+}
+
+void lcd_set_text(const char *t) {
+    Serial.println(t);
+
+    text_mode = lcd_mode_multiline;
+
+#ifdef USE_20X4_TEXT_LCD
+    lcd.setCursor(0, LCD_HEADING_LINES);
+    lcd.print(t);
+#endif // USE_20X4_TEXT_LCD
+
+#ifdef USE_FULL_GRAPHIC_LCD
+    text[0] = t;
+    text_pre = "";
+    text_direction = 0;
+    lcd_shorten_multiline(text, LCD_TEXT_LINES, LCD_TEXT_WIDTH, &text_post);
+    redraw = true;
+#endif // USE_FULL_GRAPHIC_LCD
 }
 
-void lcd_set_text(const char *text) {
-    Serial.println(text);
+void lcd_set_menu_text(int line, const char *t) {
+    Serial.print(line);
+    Serial.print(": ");
+    Serial.println(t);
+
+    text_mode = lcd_mode_menu;
 
 #ifdef USE_20X4_TEXT_LCD
-    lcd.setCursor(0, 1);
-    lcd.print(text);
+    lcd.setCursor(0, LCD_HEADING_LINES + line);
+    lcd.print(t);
 #endif // USE_20X4_TEXT_LCD
+
+#ifdef USE_FULL_GRAPHIC_LCD
+    text[line] = t;
+    menu_pre[line] = "";
+    menu_dir[line] = 0;
+    lcd_shorten_multiline(text + line, 1, LCD_TEXT_WIDTH, menu_post + line);
+    redraw = true;
+#endif // USE_FULL_GRAPHIC_LCD
 }

src/main.cpp

     Serial.println(F(" mm"));
 
     Serial.print(F("\t"));
-    Serial.print(E_STEPS_PER_MM);
-    Serial.println(F(" steps/mm"));
+    Serial.print(E_STEPS_PER_PERCENT);
+    Serial.println(F(" steps/percent"));
 
     Serial.print(F("\t"));
     Serial.print(E_MAX_SPEED);
-    Serial.println(F(" mm/s"));
+    Serial.println(F(" percent/s"));
 
     Serial.print(F("\t"));
     Serial.print(E_MAX_ACCEL);
-    Serial.println(F(" mm/s^2"));
+    Serial.println(F(" percent/s^2"));
 
     Serial.println();
 
     int click = encoder_click();
     int kill = kill_switch();
 
-    if (click) {
-        async_beep(ENCODER_CLICK_BEEP_TIME, ENCODER_CLICK_BEEP_FREQ);
-    }
-
     struct StateMachineInput smi(click, encoder_change(), kill, !still_running);
     states_run(smi);
+
+    lcd_loop();
 }

src/statemachine.cpp

 // --------------------------------------
 
 StateText::StateText(State *_parent) : State(_parent) {
-    heading = "";
-    text = "";
+    heading = "no heading";
+    text = "text missing";
     onEnterFunc = []() { };
     whenInFunc = [](StateMachineInput smi) {
         State *s = states_get();
-        if (smi.click && (s != NULL) && (s->getChild() != NULL)) {
-            states_go_to(s->getChild());
+        if (smi.click && (s != NULL)) {
+            if (s->getChild() != NULL) {
+                states_go_to(s->getChild());
+            } else if (s->getParent() != NULL) {
+                states_go_to(s->getParent());
+            }
         }
     };
 }
 }
 
 void StateText::enterState(void) {
+    if (onEnterFunc != NULL) {
+        onEnterFunc();
+    }
+
     lcd_clear();
     lcd_set_heading(heading);
     lcd_set_text(text);
-
-    onEnterFunc();
 }
 
 void StateText::inState(struct StateMachineInput smi) {
-    whenInFunc(smi);
+    if (whenInFunc != NULL) {
+        whenInFunc(smi);
+    }
 }
 
 // --------------------------------------
 
-StateMenu::StateMenu(State *_parent) : State(_parent) {
+StateMenu::StateMenu(State *_parent, bool _show_parent) : State(_parent) {
+    show_parent = _show_parent;
     menuPos = 0;
+    menuOff = 0;
 }
 
 void StateMenu::setChild(State *_child) {
     if (pos < 0) {
         setChild(_child);
     } else {
-        // TODO insert child at pos in children
+        array_insert_at_pos(&children, _child, pos);
     }
 }
 
 void StateMenu::enterState(void) {
-    menuPos = 0;
+    display();
+}
+
+void StateMenu::display(void) {
+    lcd_clear();
+    lcd_set_heading(getTitle());
+
+    int size = children.size();
+    if (show_parent) {
+        size++;
+    }
+
+    for (int i = menuOff; (i < menuOff + lcd_text_lines()) && (i < size); i++) {
+        String s = "";
+        if (i == menuPos) {
+            s += "> ";
+        } else {
+            s += "  ";
+        }
+        if (i == children.size()) {
+            s += getParent()->getTitle();
+        } else {
+            s += children.at(i)->getTitle();
+        }
+        lcd_set_menu_text(i - menuOff, s.c_str());
+    }
 }
 
 void StateMenu::inState(struct StateMachineInput smi) {
+    int size = children.size();
+    if (show_parent) {
+        size++;
+    }
+
+    if (smi.encoder != 0) {
+        menuPos -= smi.encoder;
+
+        while (menuPos < 0) {
+            menuPos += size;
+        }
+
+        while (menuPos >= size) {
+            menuPos -= size;
+        }
 
+        while (menuPos < menuOff) {
+            menuOff--;
+        }
+
+        while (menuPos >= (menuOff + lcd_text_lines())) {
+            menuOff++;
+        }
+
+        display();
+    }
+
+    if (smi.click) {
+        if (menuPos == children.size()) {
+            menuPos = 0;
+            menuOff = 0;
+            states_go_to(getParent());
+        } else {
+            states_go_to(children.at(menuPos));
+        }
+    }
 }
 
 // --------------------------------------
 
-StateDynamicMenu::StateDynamicMenu(State *_parent = NULL) : State(_parent) { }
+StateDynamicMenu::StateDynamicMenu(State *_parent) : State(_parent) {
+    menuPos = 0;
+    menuOff = 0;
+}
 
 void StateDynamicMenu::dataCount(CountFuncPtr count) {
     countFunc = count;
 }
 
 void StateDynamicMenu::display(void) {
+    lcd_clear();
+    lcd_set_heading(getTitle());
 
+    for (int i = menuOff; (i < menuOff + lcd_text_lines()) && (i < count + 1); i++) {
+        String s = "";
+        if (i == menuPos) {
+            s += "> ";
+        } else {
+            s += "  ";
+        }
+        if (i == count) {
+            s += getParent()->getTitle();
+        } else {
+            s += contents.at(i);
+        }
+        lcd_set_menu_text(i - menuOff, s.c_str());
+    }
 }
 
 void StateDynamicMenu::enterState(void) {
     // cache all entries on entering state
-    count = countFunc();
+    if (countFunc != NULL) {
+        count = countFunc();
+    } else {
+        count = 0;
+    }
     contents.clear();
     for (int i = 0; i < count; i++) {
-        contents.push_back(getFunc(i));
+        if (getFunc != NULL) {
+            contents.push_back(getFunc(i));
+        } else {
+            contents.push_back("no get func");
+        }
     }
 
     display();
 }
 
 void StateDynamicMenu::inState(StateMachineInput smi) {
+    if (smi.encoder != 0) {
+        menuPos -= smi.encoder;
+
+        while (menuPos < 0) {
+            menuPos += count + 1;
+        }
+
+        while (menuPos >= count + 1) {
+            menuPos -= count + 1;
+        }
+
+        while (menuPos < menuOff) {
+            menuOff--;
+        }
+
+        while (menuPos >= (menuOff + lcd_text_lines())) {
+            menuOff++;
+        }
+
+        display();
+    }
+
+    if (smi.click) {
+        if (menuPos == count) {
+            menuPos = 0;
+            menuOff = 0;
+            states_go_to(getParent());
+        } else {
+            if (callFunc != NULL) {
+                callFunc(menuPos);
+            }
+        }
+    }
+}
+
+// --------------------------------------
+
+template <typename T>
+StateValue<T>::StateValue(State *_parent, T &_value, T _min, T _max) : State(_parent), value(_value) {
+    min = _min;
+    max = _max;
+    updateFunc = NULL;
+}
+
+template <typename T>
+void StateValue<T>::onUpdate(UpdateFuncPtr func) {
+    updateFunc = func;
+}
+
+template <typename T>
+void StateValue<T>::display(void) {
+    String s = String(min) + " .. " + String(value) + " .. " + String(max);
+    lcd_set_text(s.c_str());
+}
+
+template <typename T>
+void StateValue<T>::enterState(void) {
+    lcd_clear();
+    lcd_set_heading(getTitle());
+
+    display();
+}
+
+template <typename T>
+void StateValue<T>::inState(StateMachineInput smi) {
+    if (smi.encoder != 0) {
+        value -= smi.encoder;
+        if (value < min) {
+            value = min;
+        }
+        if (value > max) {
+            value = max;
+        }
+        display();
+    }
+    if (smi.click) {
+        if (updateFunc != NULL) {
+            updateFunc(value);
+        }
+        states_go_to(getParent());
+    }
+}
+
+template class StateValue<float>;
+
+// --------------------------------------
+
+template <typename T, size_t N>
+void array_print(Array<T, N> *arr) {
+    Serial.print("Array length: ");
+    Serial.print(arr->size());
+    Serial.println(" contents:");
+    for (int i = 0; i < arr->size(); i++) {
+        Serial.print(i);
+        Serial.print(": ");
+        Serial.println(arr->at(i)->getTitle());
+    }
+}
+
+template <typename T, size_t N>
+void array_insert_at_pos(Array<T, N> *arr, T value, size_t pos) {
+    // make additional space
+    arr->push_back(value);
+
+    if ((pos >= arr->max_size()) || (pos >= arr->size())) {
+        // we can not shift it to the given position
+        return;
+    }
+
+    for (int i = arr->size() - 2; i >= pos; i--) {
+        arr->at(i + 1) = arr->at(i);
+    }
 
+    arr->at(pos) = value;
 }

src/states.cpp

 
 StateText sm_ask_homing = StateText();
 StateText sm_do_homing = StateText(&sm_ask_homing);
-StateMenu sm_menu = StateMenu(&sm_do_homing);
+StateMenu sm_menu = StateMenu(&sm_do_homing, false);
 
 StateMenu sm_auto = StateMenu(&sm_menu);
 StateDynamicMenu sm_presets = StateDynamicMenu(&sm_auto);
-StateDynamicMenu sm_new_preset = StateDynamicMenu(&sm_auto);
+StateText sm_new_preset = StateText(&sm_auto);
 StateDynamicMenu sm_mod_preset = StateDynamicMenu(&sm_auto);
 StateDynamicMenu sm_del_preset = StateDynamicMenu(&sm_auto);
 
-StateMenu sm_config = StateMenu(&sm_menu);
+StateMenu sm_move = StateMenu(&sm_menu);
+StateText sm_move_x = StateText(&sm_move);
+StateText sm_move_y = StateText(&sm_move);
+StateText sm_move_z = StateText(&sm_move);
+StateText sm_move_e = StateText(&sm_move);
 
+StateMenu sm_config = StateMenu(&sm_menu);
+StateText sm_conf_load = StateText(&sm_config);
+StateText sm_conf_save = StateText(&sm_config);
+StateValue<float> sm_conf_speed_xy = StateValue<float>(&sm_config, data_options()->speed_x, 1.0, XY_MAX_SPEED);
+StateValue<float> sm_conf_speed_z = StateValue<float>(&sm_config, data_options()->speed_z, 1.0, Z_MAX_SPEED);
+StateValue<float> sm_conf_speed_e = StateValue<float>(&sm_config, data_options()->speed_e, 1.0, E_MAX_SPEED);
+StateValue<float> sm_conf_accel_xy = StateValue<float>(&sm_config, data_options()->accel_x, 1.0, XY_MAX_ACCEL);
+StateValue<float> sm_conf_accel_z = StateValue<float>(&sm_config, data_options()->accel_z, 1.0, Z_MAX_ACCEL);
+StateValue<float> sm_conf_accel_e = StateValue<float>(&sm_config, data_options()->accel_e, 1.0, E_MAX_ACCEL);
 
 // --------------------------------------
 
 State *current_state = NULL;
+String strbuf;
 
 void states_init(void) {
     // ----------------------------------
 
+    sm_ask_homing.setTitle("Ask for homing");
     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.setHeading("Homing...");
 
     sm_do_homing.onEnter([]() {
-        steppers_start_homing();
+        //steppers_start_homing();
     });
 
     sm_do_homing.whenIn([](StateMachineInput smi) {
-        if (smi.motors_done) {
-            if (steppers_homed()) {
-                async_beep(100, 2000);
+        //if (smi.motors_done) {
+        //    if (steppers_homed()) {
+                async_beep(HOMING_BEEP_TIME, HOMING_BEEP_FREQ);
                 states_go_to(&sm_menu);
-            }
-        }
+        //    }
+        //}
 
         // TODO update text with current axis
     });
 
     // ----------------------------------
 
+    sm_move.setTitle("Move Axis");
+
+    sm_move_x.setTitle("X Axis");
+    sm_move_y.setTitle("Y Axis");
+    sm_move_z.setTitle("Z Axis");
+    sm_move_e.setTitle("E Axis");
+
+    // ----------------------------------
+
     sm_auto.setTitle("Filling Menu");
-    sm_auto.setChild(&sm_menu);
 
-    sm_presets.setTitle("Presets");
+    sm_presets.setTitle("Use Preset");
     sm_presets.dataCount([]() {
         return (int)data_preset_count();
     });
         // dynamically. need to have a name stored
         // somewhere, in data/eeprom, for each preset
         // that we can pass here
+        return "foo";
+    });
+
+    sm_new_preset.setTitle("Add new Preset");
+    sm_new_preset.setHeading("Add new Preset");
+    sm_new_preset.onEnter([]() {
+        struct data_config_preset preset;
+        if (!data_preset_add(preset)) {
+            strbuf = String(data_eeprom_error()) + " Error adding preset!";
+            sm_new_preset.setText(strbuf.c_str());
+        } else {
+            strbuf = "Preset " + String(data_preset_count()) + " has been added!";
+            sm_new_preset.setText(strbuf.c_str());
+        }
     });
 
-    sm_new_preset.setTitle("New Preset");
     sm_mod_preset.setTitle("Modify Preset");
+    sm_mod_preset.dataCount([]() {
+        return (int)data_preset_count();
+    });
+    sm_mod_preset.dataGet([](int i) {
+        // TODO can not build a name string here
+        // dynamically. need to have a name stored
+        // somewhere, in data/eeprom, for each preset
+        // that we can pass here
+        return "foo";
+    });
+
     sm_del_preset.setTitle("Delete Preset");
+    sm_del_preset.dataCount([]() {
+        return (int)data_preset_count();
+    });
+    sm_del_preset.dataGet([](int i) {
+        // TODO can not build a name string here
+        // dynamically. need to have a name stored
+        // somewhere, in data/eeprom, for each preset
+        // that we can pass here
+        return "foo";
+    });
 
     // ----------------------------------
 
     sm_config.setTitle("Configuration");
-    sm_auto.setChild(&sm_menu);
+
+    sm_conf_load.setTitle("Load from EEPROM");
+    sm_conf_load.setHeading("Load from EEPROM");
+    sm_conf_load.onEnter([]() {
+        if (!data_eeprom_read()) {
+            strbuf = String(data_eeprom_error()) + " Error reading configuration!";
+            sm_conf_load.setText(strbuf.c_str());
+        } else {
+            sm_conf_load.setText("Configuration read successful!");
+
+            steppers_set_speed_x(data_options()->speed_x);
+            steppers_set_accel_x(data_options()->accel_x);
+            steppers_set_speed_y(data_options()->speed_y);
+            steppers_set_accel_y(data_options()->accel_y);
+            steppers_set_speed_z(data_options()->speed_z);
+            steppers_set_accel_z(data_options()->accel_z);
+            steppers_set_speed_e(data_options()->speed_e);
+            steppers_set_accel_e(data_options()->accel_e);
+        }
+    });
+
+    sm_conf_save.setTitle("Store to EEPROM");
+    sm_conf_save.setHeading("Store to EEPROM");
+    sm_conf_save.setText("Configuration written to EEPROM!");
+    sm_conf_save.onEnter([]() {
+        data_eeprom_write();
+    });
+
+    sm_conf_speed_xy.setTitle("XY Speed");
+    sm_conf_speed_xy.onUpdate([](float v) {
+        steppers_set_speed_x(v);
+        steppers_set_speed_y(v);
+    });
+
+    sm_conf_speed_z.setTitle("Z Speed");
+    sm_conf_speed_z.onUpdate([](float v) {
+        steppers_set_speed_z(v);
+    });
+
+    sm_conf_speed_e.setTitle("E Speed");
+    sm_conf_speed_e.onUpdate([](float v) {
+        steppers_set_speed_e(v);
+    });
+
+    sm_conf_accel_xy.setTitle("XY Acceleration");
+    sm_conf_accel_xy.onUpdate([](float v) {
+        steppers_set_accel_x(v);
+        steppers_set_accel_y(v);
+    });
+
+    sm_conf_accel_z.setTitle("Z Acceleration");
+    sm_conf_accel_z.onUpdate([](float v) {
+        steppers_set_accel_z(v);
+    });
+
+    sm_conf_accel_e.setTitle("E Acceleration");
+    sm_conf_accel_e.onUpdate([](float v) {
+        steppers_set_accel_e(v);
+    });
 
     // ----------------------------------
 
 }
 
 void states_run(StateMachineInput smi) {
+    if (smi.click) {
+        async_beep(ENCODER_CLICK_BEEP_TIME, ENCODER_CLICK_BEEP_FREQ);
+    }
+
+    if (smi.kill) {
+        steppers_kill();
+        Serial.println("Kill button pressed!");
+        blocking_beep(KILL_BEEP_TIME, KILL_BEEP_FREQ, KILL_BEEP_REPEAT - 1);
+        states_go_to(&sm_ask_homing);
+        return;
+    }
+
     if (current_state != NULL) {
         current_state->inState(smi);
     }

src/steppers.cpp

 #include "config.h"
 #include "config_pins.h"
 #include "lcd.h"
+#include "data.h"
 #include "steppers.h"
 
 static AccelStepper stepper_x(AccelStepper::DRIVER, X_STEP_PIN, X_DIR_PIN, 0, 0, false);
 static unsigned long steppers_home_move_start_time = 0;
 
 void steppers_init(void) {
-    pinMode(X_ENDSTOP_PIN, INPUT);
-    pinMode(Y_ENDSTOP_PIN, INPUT);
-    pinMode(Z_ENDSTOP_PIN, INPUT);
-    pinMode(E_ENDSTOP_PIN, INPUT);
+    pinMode(X_ENDSTOP_PIN, INPUT_PULLUP);
+    pinMode(Y_ENDSTOP_PIN, INPUT_PULLUP);
+    pinMode(Z_ENDSTOP_PIN, INPUT_PULLUP);
+    pinMode(E_ENDSTOP_PIN, INPUT_PULLUP);
 
     pinMode(X_ENABLE_PIN, OUTPUT);
     pinMode(X_STEP_PIN, OUTPUT);
 
     stepper_x.setEnablePin(X_ENABLE_PIN);
     stepper_x.setMaxSpeed(XY_MAX_SPEED * XY_STEPS_PER_MM);
-    stepper_x.setAcceleration(XY_MAX_ACCEL * XY_STEPS_PER_MM);
+    steppers_set_speed_x(data_options()->speed_x);
+    steppers_set_accel_x(data_options()->accel_x);
 
     stepper_y.setEnablePin(Y_ENABLE_PIN);
-    stepper_y.setMaxSpeed(XY_MAX_SPEED * XY_STEPS_PER_MM);
-    stepper_y.setAcceleration(XY_MAX_ACCEL * XY_STEPS_PER_MM);
+    steppers_set_speed_y(data_options()->speed_y);
+    steppers_set_accel_y(data_options()->accel_y);
 
     stepper_z.setEnablePin(Z_ENABLE_PIN);
-    stepper_z.setMaxSpeed(Z_MAX_SPEED * Z_STEPS_PER_MM);
-    stepper_z.setAcceleration(Z_MAX_ACCEL * Z_STEPS_PER_MM);
+    steppers_set_speed_z(data_options()->speed_z);
+    steppers_set_accel_z(data_options()->accel_z);
 
     stepper_e.setEnablePin(E0_ENABLE_PIN);
-    stepper_e.setMaxSpeed(E_MAX_SPEED * E_STEPS_PER_MM);
-    stepper_e.setAcceleration(E_MAX_ACCEL * E_STEPS_PER_MM);
+    steppers_set_speed_e(data_options()->speed_e);
+    steppers_set_accel_e(data_options()->accel_e);
 }
 
 static void steppers_initiate_home(int axis, int phase) {
         // e
         if (phase == 0) {
             state = step_homing_e_fast;
-            stepper_e.setSpeed(E_HOMING_DIR * E_AXIS_MOVEMENT_DIR * E_FAST_HOME_SPEED * E_STEPS_PER_MM);
+            stepper_e.setSpeed(E_HOMING_DIR * E_AXIS_MOVEMENT_DIR * E_FAST_HOME_SPEED * E_STEPS_PER_PERCENT);
         } else if (phase == 1) {
             state = step_homing_e_back;
-            stepper_e.setSpeed(-1.0 * E_HOMING_DIR * E_AXIS_MOVEMENT_DIR * E_FAST_HOME_SPEED * E_STEPS_PER_MM);
+            stepper_e.setSpeed(-1.0 * E_HOMING_DIR * E_AXIS_MOVEMENT_DIR * E_FAST_HOME_SPEED * E_STEPS_PER_PERCENT);
         } else if (phase == 2) {
             state = step_homing_e_slow;
-            stepper_e.setSpeed(E_HOMING_DIR * E_AXIS_MOVEMENT_DIR * E_SLOW_HOME_SPEED * E_STEPS_PER_MM);
+            stepper_e.setSpeed(E_HOMING_DIR * E_AXIS_MOVEMENT_DIR * E_SLOW_HOME_SPEED * E_STEPS_PER_PERCENT);
         }
     } else {
         Serial.println(F("home_init error: invalid axis"));
         }
     } else if (state == step_homing_x_slow) {
         if (steppers_home_switch(0)) {
+            stepper_x.setSpeed(0);
             steppers_initiate_home(1, 0);
         } else {
             stepper_x.runSpeed();
         }
     } else if (state == step_homing_y_slow) {
         if (steppers_home_switch(1)) {
+            stepper_y.setSpeed(0);
             steppers_initiate_home(3, 0);
         } else {
             stepper_y.runSpeed();
         }
     } else if (state == step_homing_z_slow) {
         if (steppers_home_switch(2)) {
+            stepper_z.setSpeed(0);
             steppers_initiate_home(0, 0);
         } else {
             stepper_z.runSpeed();
         }
     } else if (state == step_homing_e_slow) {
         if (steppers_home_switch(3)) {
+            stepper_e.setSpeed(0);
             state = step_homed;
             return false;
         } else {
-            stepper_z.runSpeed();
+            stepper_e.runSpeed();
         }
     } else if (state != step_disabled) {
         for (int i = 0; i < 4; i++) {
     Serial.print(F("Moving E to "));
     Serial.print(pos);
     Serial.print(F(" mm ("));
-    Serial.print(pos * E_STEPS_PER_MM * E_AXIS_MOVEMENT_DIR);
+    Serial.print(E_MM_TO_PERCENT(pos));
+    Serial.println(F("% = "));
+    Serial.print(E_MM_TO_PERCENT(pos) * E_STEPS_PER_PERCENT * E_AXIS_MOVEMENT_DIR);
     Serial.println(F(" steps)"));
 
     if (pos < E_AXIS_MIN) {
         return -1;
     }
 
-    return steppers_move_axis(stepper_e, pos * E_STEPS_PER_MM * E_AXIS_MOVEMENT_DIR);
+    return steppers_move_axis(stepper_e, E_MM_TO_PERCENT(pos) * E_STEPS_PER_PERCENT * E_AXIS_MOVEMENT_DIR);
+}
+
+void steppers_kill(void) {
+    stepper_x.setCurrentPosition(0);
+    stepper_y.setCurrentPosition(0);
+    stepper_z.setCurrentPosition(0);
+    stepper_e.setCurrentPosition(0);
+
+    stepper_x.disableOutputs();
+    stepper_y.disableOutputs();
+    stepper_z.disableOutputs();
+    stepper_e.disableOutputs();
+
+    state = step_not_homed;
+}
+
+void steppers_set_speed_x(float speed) {
+    if (speed < 0.0) {
+        speed = 0.0;
+    }
+    if (speed > XY_MAX_SPEED) {
+        speed = XY_MAX_SPEED;
+    }
+    stepper_x.setMaxSpeed(speed * XY_STEPS_PER_MM);
+}
+
+void steppers_set_speed_y(float speed) {
+    if (speed < 0.0) {
+        speed = 0.0;
+    }
+    if (speed > XY_MAX_SPEED) {
+        speed = XY_MAX_SPEED;
+    }
+    stepper_y.setMaxSpeed(speed * XY_STEPS_PER_MM);
+}
+
+void steppers_set_speed_z(float speed) {
+    if (speed < 0.0) {
+        speed = 0.0;
+    }
+    if (speed > Z_MAX_SPEED) {
+        speed = Z_MAX_SPEED;
+    }
+    stepper_z.setMaxSpeed(speed * Z_STEPS_PER_MM);
+}
+
+void steppers_set_speed_e(float speed) {
+    if (speed < 0.0) {
+        speed = 0.0;
+    }
+    if (speed > E_MAX_SPEED) {
+        speed = E_MAX_SPEED;
+    }
+    stepper_e.setMaxSpeed(speed * E_STEPS_PER_PERCENT);
+}
+
+void steppers_set_accel_x(float accel) {
+    if (accel < 0.0) {
+        accel = 0.0;
+    }
+    if (accel > XY_MAX_ACCEL) {
+        accel = XY_MAX_ACCEL;
+    }
+    stepper_x.setAcceleration(accel * XY_STEPS_PER_MM);
+}
+
+void steppers_set_accel_y(float accel) {
+    if (accel < 0.0) {
+        accel = 0.0;
+    }
+    if (accel > XY_MAX_ACCEL) {
+        accel = XY_MAX_ACCEL;
+    }
+    stepper_y.setAcceleration(accel * XY_STEPS_PER_MM);
+}
+
+void steppers_set_accel_z(float accel) {
+    if (accel < 0.0) {
+        accel = 0.0;
+    }
+    if (accel > Z_MAX_ACCEL) {
+        accel = Z_MAX_ACCEL;
+    }
+    stepper_z.setAcceleration(accel * Z_STEPS_PER_MM);
+}
+
+void steppers_set_accel_e(float accel) {
+    if (accel < 0.0) {
+        accel = 0.0;
+    }
+    if (accel > E_MAX_ACCEL) {
+        accel = E_MAX_ACCEL;
+    }
+    stepper_e.setAcceleration(accel * E_STEPS_PER_PERCENT);
 }