bunch of work on firmware

include/config.h

@@ -20,29 +20,25 @@
 #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 XY_MICRO_STEPS 16.0
 #define XY_MOTOR_STEPS_PER_REV (200.0 * XY_MICRO_STEPS)
 #define XY_STEPS_PER_MM (XY_MOTOR_STEPS_PER_REV / XY_PULLEY_TEETH / XY_BELT_PITCH)
 
+// z steps per mm
 #define Z_ROD_PITCH 2.0
 #define Z_MICRO_STEPS 16.0
 #define Z_MOTOR_STEPS_PER_REV (200.0 * Z_MICRO_STEPS)
 #define Z_STEPS_PER_MM (Z_MOTOR_STEPS_PER_REV / Z_ROD_PITCH)
 
+// e steps per mm
 #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 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 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
-
+// travel lengths
 #define X_AXIS_MIN -5.0 // in mm
 #define X_AXIS_MAX 260.0 // in mm
 #define Y_AXIS_MIN -5.0 // in mm
@@ -52,4 +48,37 @@
 #define E_AXIS_MIN 0.0 // in mm
 #define E_AXIS_MAX 6.0 // in mm
 
+// 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
+
+// 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
+
+// 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
+
+// axis movement directions (1.0 normal, -1.0 inverted)
+#define X_AXIS_MOVEMENT_DIR 1.0
+#define Y_AXIS_MOVEMENT_DIR 1.0
+#define Z_AXIS_MOVEMENT_DIR 1.0
+#define E_AXIS_MOVEMENT_DIR 1.0
+
+// homing back-off
+#define XY_BACK_OFF_DISTANCE 10.0 // in mm
+#define Z_BACK_OFF_DISTANCE 5.0 // in mm
+#define E_BACK_OFF_DISTANCE 2.0 // in mm
+
+#define XY_HOME_BACK_OFF_TIME (XY_BACK_OFF_DISTANCE / XY_FAST_HOME_SPEED * 1000)
+#define Z_HOME_BACK_OFF_TIME (Z_BACK_OFF_DISTANCE / Z_FAST_HOME_SPEED * 1000)
+#define E_HOME_BACK_OFF_TIME (E_BACK_OFF_DISTANCE / E_FAST_HOME_SPEED * 1000)
+
 #endif // _CONFIG_H_

include/config_pins.h

@@ -27,6 +27,10 @@
 #define E0_DIR_PIN         28
 #define E0_ENABLE_PIN      24
 
+// use the remaining z endstop pin for e axis
+#define E_MIN_PIN          18
+#define E_MAX_PIN          -1
+
 //extruder 2
 #define E1_STEP_PIN        36
 #define E1_DIR_PIN         34
@@ -90,3 +94,43 @@
 #if ((Y_MIN_PIN != -1) && (Y_MAX_PIN != -1)) || ((Y_MIN_PIN == -1) && (Y_MAX_PIN == -1))
 #error define one of Y_MIN_PIN or Y_MAX_PIN
 #endif
+
+#if ((Z_MIN_PIN != -1) && (Z_MAX_PIN != -1)) || ((Z_MIN_PIN == -1) && (Z_MAX_PIN == -1))
+#error define one of Z_MIN_PIN or Z_MAX_PIN
+#endif
+
+#if ((E_MIN_PIN != -1) && (E_MAX_PIN != -1)) || ((E_MIN_PIN == -1) && (E_MAX_PIN == -1))
+#error define one of E_MIN_PIN or E_MAX_PIN
+#endif
+
+#if (X_MIN_PIN == -1)
+#define X_HOMING_DIR 1.0
+#define X_ENDSTOP_PIN X_MAX_PIN
+#else
+#define X_HOMING_DIR -1.0
+#define X_ENDSTOP_PIN X_MIN_PIN
+#endif
+
+#if (Y_MIN_PIN == -1)
+#define Y_HOMING_DIR 1.0
+#define Y_ENDSTOP_PIN Y_MAX_PIN
+#else
+#define Y_HOMING_DIR -1.0
+#define Y_ENDSTOP_PIN Y_MIN_PIN
+#endif
+
+#if (Z_MIN_PIN == -1)
+#define Z_HOMING_DIR 1.0
+#define Z_ENDSTOP_PIN Z_MAX_PIN
+#else
+#define Z_HOMING_DIR -1.0
+#define Z_ENDSTOP_PIN Z_MIN_PIN
+#endif
+
+#if (E_MIN_PIN == -1)
+#define E_HOMING_DIR 1.0
+#define E_ENDSTOP_PIN E_MAX_PIN
+#else
+#define E_HOMING_DIR -1.0
+#define E_ENDSTOP_PIN E_MIN_PIN
+#endif

include/data.h

@@ -0,0 +1,29 @@
+#ifndef _DATA_H_
+#define _DATA_H_
+
+#define DATA_SCHEMA_VERSION 0
+
+struct data_config_options {
+    float speed_x, speed_y, speed_z, speed_e;
+    float accel_x, accel_y, accel_z, accel_e;
+};
+
+struct data_config_preset {
+    uint8_t rows, cols;
+    float distance_x, distance_y;
+    float offset_x, offset_y;
+    float top_z, bottom_z;
+    float extrusion;
+};
+
+void data_init(void);
+void data_eeprom_write(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);
+
+#endif // _DATA_H_

include/statemachine.h

@@ -71,4 +71,30 @@ private:
     Array<State *, 42> children;
 };
 
+class StateDynamicMenu : public State {
+public:
+    StateDynamicMenu(State *_parent = NULL);
+
+    typedef int(*CountFuncPtr)(void);
+    typedef const char *(*GetFuncPtr)(int);
+    typedef void(*CallFuncPtr)(int);
+
+    void dataCount(CountFuncPtr count);
+    void dataGet(GetFuncPtr get);
+    void dataCall(CallFuncPtr call);
+
+    virtual void enterState(void);
+    virtual void inState(StateMachineInput smi);
+
+private:
+    void display(void);
+
+    CountFuncPtr countFunc;
+    GetFuncPtr getFunc;
+    CallFuncPtr callFunc;
+
+    int count;
+    Array<const char *, 42> contents;
+};
+
 #endif // _STATE_MACHINE_H_

src/data.cpp

@@ -0,0 +1,164 @@
+#include <Arduino.h>
+#include <EEPROM.h>
+
+#include "config.h"
+#include "config_pins.h"
+#include "data.h"
+
+#define EEPROM_SIZE 4096
+
+struct data_config {
+    uint8_t data_schema_version;
+    uint8_t preset_count;
+    uint32_t checksum;
+    struct data_config_options options;
+    struct data_config_preset *presets;
+};
+
+static struct data_config d;
+
+static unsigned int max_presets(void) {
+    unsigned int s = EEPROM_SIZE - sizeof(struct data_config) + sizeof(struct data_config_preset *);
+    return s / sizeof(struct data_config_preset);
+}
+
+static uint32_t data_checksum(struct data_config *data) {
+    uint32_t c = 0;
+
+    uint8_t *t = (uint8_t *)data;
+    for (unsigned int i = 0; i < sizeof(struct data_config); i++) {
+        c ^= t[i];
+    }
+
+    for (unsigned int i = 0; i < data->preset_count; i++) {
+        t = (uint8_t *)(&data->presets[i]);
+        for (unsigned int j = 0; j < sizeof(struct data_config_preset); j++) {
+            c ^= t[j];
+        }
+    }
+
+    return c;
+}
+
+static bool data_eeprom_read(void) {
+    struct data_config config;
+    uint8_t *data = (uint8_t *)&config;
+
+    // read meta-data and settings
+    unsigned int s = sizeof(struct data_config);
+    for (unsigned int i = 0; i < s; i++) {
+        data[i] = EEPROM.read(i);
+    }
+
+    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 "));
+            return false;
+        }
+
+        if (config.preset_count > max_presets()) {
+            Serial.print(F("Preset "));
+            return false;
+        }
+
+        // read presets
+        for (unsigned int i = 0; i < config.preset_count; i++) {
+            data = (uint8_t *)(&config.presets[i]);
+            for (unsigned int j = 0; j < sizeof(struct data_config_preset); j++) {
+                data[j] = EEPROM.read(s + j);
+                s += sizeof(struct data_config_preset);
+            }
+        }
+    } else {
+        config.presets = NULL;
+    }
+
+    // verify checksum
+    uint32_t checksum = data_checksum(&config);
+    if (config.checksum == checksum) {
+        // verify version
+        if (config.data_schema_version == DATA_SCHEMA_VERSION) {
+            if (d.presets != NULL) {
+                free(d.presets);
+            }
+            d = config;
+
+            return true;
+        } else {
+            Serial.print(F("Version "));
+            return false;
+        }
+    } else {
+        Serial.print(F("Checksum "));
+        return false;
+    }
+}
+
+void data_eeprom_write(void) {
+    d.checksum = data_checksum(&d);
+
+    // write meta-data and settings
+    uint8_t *data = (uint8_t *)&d;
+    unsigned int s = sizeof(struct data_config);
+    for (unsigned int i = 0; i < s; i++) {
+        EEPROM.update(i, data[i]);
+    }
+
+    // write presets
+    for (unsigned int i = 0; i < d.preset_count; i++) {
+        data = (uint8_t *)(&d.presets[i]);
+        for (unsigned int j = 0; j < sizeof(struct data_config_preset); j++) {
+            EEPROM.update(s + j, data[j]);
+            s += sizeof(struct data_config_preset);
+        }
+    }
+}
+
+void data_init(void) {
+    d.data_schema_version = DATA_SCHEMA_VERSION;
+    d.preset_count = 0;
+    d.checksum = 0;
+
+    d.options.speed_x = XY_MAX_SPEED;
+    d.options.speed_y = XY_MAX_SPEED;
+    d.options.speed_z = Z_MAX_SPEED;
+    d.options.speed_e = E_MAX_SPEED;
+
+    d.options.accel_x = XY_MAX_ACCEL;
+    d.options.accel_y = XY_MAX_ACCEL;
+    d.options.accel_z = Z_MAX_ACCEL;
+    d.options.accel_e = E_MAX_ACCEL;
+
+    d.presets = NULL;
+
+    Serial.print(F("EEPROM read... "));
+    if (!data_eeprom_read()) {
+        Serial.println(F("Error"));
+    } else {
+        Serial.println(F("Ok"));
+    }
+}
+
+struct data_config_options *data_options(void) {
+    return &d.options;
+}
+
+unsigned int data_preset_count(void) {
+    return d.preset_count;
+}
+
+struct data_config_preset *data_preset(unsigned int i) {
+    if (i < d.preset_count) {
+        return &d.presets[i];
+    }
+    return NULL;
+}
+
+void data_preset_add(struct data_config_preset preset) {
+
+}
+
+void data_preset_remove(unsigned int i) {
+
+}

src/main.cpp

@@ -3,6 +3,7 @@
 #include "config.h"
 #include "config_pins.h"
 #include "common.h"
+#include "data.h"
 #include "encoder.h"
 #include "lcd.h"
 #include "steppers.h"
@@ -20,6 +21,9 @@ void setup() {
     Serial.print(F("Version: "));
     Serial.println(FIRMWARE_VERSION);
 
+    Serial.println(F("Init data"));
+    data_init();
+
     Serial.println(F("Init encoder"));
     encoder_init();
 

src/statemachine.cpp

@@ -78,3 +78,38 @@ void StateMenu::enterState(void) {
 void StateMenu::inState(struct StateMachineInput smi) {
 
 }
+
+// --------------------------------------
+
+StateDynamicMenu::StateDynamicMenu(State *_parent = NULL) : State(_parent) { }
+
+void StateDynamicMenu::dataCount(CountFuncPtr count) {
+    countFunc = count;
+}
+
+void StateDynamicMenu::dataGet(GetFuncPtr get) {
+    getFunc = get;
+}
+
+void StateDynamicMenu::dataCall(CallFuncPtr call) {
+    callFunc = call;
+}
+
+void StateDynamicMenu::display(void) {
+
+}
+
+void StateDynamicMenu::enterState(void) {
+    // cache all entries on entering state
+    count = countFunc();
+    contents.clear();
+    for (int i = 0; i < count; i++) {
+        contents.push_back(getFunc(i));
+    }
+
+    display();
+}
+
+void StateDynamicMenu::inState(StateMachineInput smi) {
+
+}

src/states.cpp

@@ -2,6 +2,7 @@
 
 #include "config.h"
 #include "config_pins.h"
+#include "data.h"
 #include "common.h"
 #include "lcd.h"
 #include "steppers.h"
@@ -15,9 +16,14 @@ StateText sm_do_homing = StateText(&sm_ask_homing);
 StateMenu sm_menu = StateMenu(&sm_do_homing);
 
 StateMenu sm_auto = StateMenu(&sm_menu);
+StateDynamicMenu sm_presets = StateDynamicMenu(&sm_auto);
+StateDynamicMenu sm_new_preset = StateDynamicMenu(&sm_auto);
+StateDynamicMenu sm_mod_preset = StateDynamicMenu(&sm_auto);
+StateDynamicMenu sm_del_preset = StateDynamicMenu(&sm_auto);
 
 StateMenu sm_config = StateMenu(&sm_menu);
 
+
 // --------------------------------------
 
 State *current_state = NULL;
@@ -58,6 +64,21 @@ void states_init(void) {
     sm_auto.setTitle("Filling Menu");
     sm_auto.setChild(&sm_menu);
 
+    sm_presets.setTitle("Presets");
+    sm_presets.dataCount([]() {
+        return (int)data_preset_count();
+    });
+    sm_presets.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
+    });
+
+    sm_new_preset.setTitle("New Preset");
+    sm_mod_preset.setTitle("Modify Preset");
+    sm_del_preset.setTitle("Delete Preset");
+
     // ----------------------------------
 
     sm_config.setTitle("Configuration");

src/steppers.cpp

@@ -3,6 +3,7 @@
 
 #include "config.h"
 #include "config_pins.h"
+#include "lcd.h"
 #include "steppers.h"
 
 static AccelStepper stepper_x(AccelStepper::DRIVER, X_STEP_PIN, X_DIR_PIN, 0, 0, false);
@@ -29,8 +30,27 @@ enum stepper_states {
 };
 
 static stepper_states state = step_disabled;
+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_ENABLE_PIN, OUTPUT);
+    pinMode(X_STEP_PIN, OUTPUT);
+    pinMode(X_DIR_PIN, OUTPUT);
+    pinMode(Y_ENABLE_PIN, OUTPUT);
+    pinMode(Y_STEP_PIN, OUTPUT);
+    pinMode(Y_DIR_PIN, OUTPUT);
+    pinMode(Z_ENABLE_PIN, OUTPUT);
+    pinMode(Z_STEP_PIN, OUTPUT);
+    pinMode(Z_DIR_PIN, OUTPUT);
+    pinMode(E0_ENABLE_PIN, OUTPUT);
+    pinMode(E0_STEP_PIN, OUTPUT);
+    pinMode(E0_DIR_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);
@@ -48,27 +68,177 @@ void steppers_init(void) {
     stepper_e.setAcceleration(E_MAX_ACCEL * E_STEPS_PER_MM);
 }
 
+static void steppers_initiate_home(int axis, int phase) {
+    steppers_home_move_start_time = millis();
+
+    if (axis == 0) {
+        // x
+        if (phase == 0) {
+            state = step_homing_x_fast;
+            stepper_x.setSpeed(X_HOMING_DIR * X_AXIS_MOVEMENT_DIR * XY_FAST_HOME_SPEED * XY_STEPS_PER_MM);
+        } else if (phase == 1) {
+            state = step_homing_x_back;
+            stepper_x.setSpeed(-1.0 * X_HOMING_DIR * X_AXIS_MOVEMENT_DIR * XY_FAST_HOME_SPEED * XY_STEPS_PER_MM);
+        } else if (phase == 2) {
+            state = step_homing_x_slow;
+            stepper_x.setSpeed(X_HOMING_DIR * X_AXIS_MOVEMENT_DIR * XY_SLOW_HOME_SPEED * XY_STEPS_PER_MM);
+        }
+    } else if (axis == 1) {
+        // y
+        if (phase == 0) {
+            state = step_homing_y_fast;
+            stepper_y.setSpeed(Y_HOMING_DIR * Y_AXIS_MOVEMENT_DIR * XY_FAST_HOME_SPEED * XY_STEPS_PER_MM);
+        } else if (phase == 1) {
+            state = step_homing_y_back;
+            stepper_y.setSpeed(-1.0 * Y_HOMING_DIR * Y_AXIS_MOVEMENT_DIR * XY_FAST_HOME_SPEED * XY_STEPS_PER_MM);
+        } else if (phase == 2) {
+            state = step_homing_y_slow;
+            stepper_y.setSpeed(Y_HOMING_DIR * Y_AXIS_MOVEMENT_DIR * XY_SLOW_HOME_SPEED * XY_STEPS_PER_MM);
+        }
+    } else if (axis == 2) {
+        // z
+        if (phase == 0) {
+            state = step_homing_z_fast;
+            stepper_z.setSpeed(Z_HOMING_DIR * Z_AXIS_MOVEMENT_DIR * Z_FAST_HOME_SPEED * Z_STEPS_PER_MM);
+        } else if (phase == 1) {
+            state = step_homing_z_back;
+            stepper_z.setSpeed(-1.0 * Z_HOMING_DIR * Z_AXIS_MOVEMENT_DIR * Z_FAST_HOME_SPEED * Z_STEPS_PER_MM);
+        } else if (phase == 2) {
+            state = step_homing_z_slow;
+            stepper_z.setSpeed(Z_HOMING_DIR * Z_AXIS_MOVEMENT_DIR * Z_SLOW_HOME_SPEED * Z_STEPS_PER_MM);
+        }
+    } else if (axis == 3) {
+        // 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);
+        } 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);
+        } 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);
+        }
+    } else {
+        Serial.println(F("home_init error: invalid axis"));
+    }
+}
+
+static bool steppers_home_switch(int axis) {
+    if (axis == 0) {
+        return digitalRead(X_ENDSTOP_PIN) == LOW;
+    } else if (axis == 1) {
+        return digitalRead(Y_ENDSTOP_PIN) == LOW;
+    } else if (axis == 2) {
+        return digitalRead(Z_ENDSTOP_PIN) == LOW;
+    } else if (axis == 3) {
+        return digitalRead(E_ENDSTOP_PIN) == LOW;
+    } else {
+        Serial.println(F("home_switch error: invalid axis"));
+    }
+    return true;
+}
+
 bool steppers_run(void) {
     if (state == step_homing_x_fast) {
+        if (steppers_home_switch(0)) {
+            steppers_initiate_home(0, 1);
+        } else {
+            stepper_x.runSpeed();
+        }
     } else if (state == step_homing_x_back) {
+        unsigned long end_time = steppers_home_move_start_time + XY_HOME_BACK_OFF_TIME;
+        if ((!steppers_home_switch(0)) && (millis() >= end_time)) {
+            steppers_initiate_home(0, 2);
+        } else {
+            stepper_x.runSpeed();
+        }
     } else if (state == step_homing_x_slow) {
+        if (steppers_home_switch(0)) {
+            steppers_initiate_home(1, 0);
+        } else {
+            stepper_x.runSpeed();
+        }
     } else if (state == step_homing_y_fast) {
+        if (steppers_home_switch(1)) {
+            steppers_initiate_home(1, 1);
+        } else {
+            stepper_y.runSpeed();
+        }
     } else if (state == step_homing_y_back) {
+        unsigned long end_time = steppers_home_move_start_time + XY_HOME_BACK_OFF_TIME;
+        if ((!steppers_home_switch(1)) && (millis() >= end_time)) {
+            steppers_initiate_home(1, 2);
+        } else {
+            stepper_y.runSpeed();
+        }
     } else if (state == step_homing_y_slow) {
+        if (steppers_home_switch(1)) {
+            steppers_initiate_home(3, 0);
+        } else {
+            stepper_y.runSpeed();
+        }
     } else if (state == step_homing_z_fast) {
+        if (steppers_home_switch(2)) {
+            steppers_initiate_home(2, 1);
+        } else {
+            stepper_z.runSpeed();
+        }
     } else if (state == step_homing_z_back) {
+        unsigned long end_time = steppers_home_move_start_time + Z_HOME_BACK_OFF_TIME;
+        if ((!steppers_home_switch(2)) && (millis() >= end_time)) {
+            steppers_initiate_home(2, 2);
+        } else {
+            stepper_z.runSpeed();
+        }
     } else if (state == step_homing_z_slow) {
+        if (steppers_home_switch(2)) {
+            steppers_initiate_home(0, 0);
+        } else {
+            stepper_z.runSpeed();
+        }
     } else if (state == step_homing_e_fast) {
+        if (steppers_home_switch(3)) {
+            steppers_initiate_home(3, 1);
+        } else {
+            stepper_e.runSpeed();
+        }
     } else if (state == step_homing_e_back) {
+        unsigned long end_time = steppers_home_move_start_time + E_HOME_BACK_OFF_TIME;
+        if ((!steppers_home_switch(3)) && (millis() >= end_time)) {
+            steppers_initiate_home(3, 2);
+        } else {
+            stepper_e.runSpeed();
+        }
     } else if (state == step_homing_e_slow) {
-    }
+        if (steppers_home_switch(3)) {
+            state = step_homed;
+            return false;
+        } else {
+            stepper_z.runSpeed();
+        }
+    } else if (state != step_disabled) {
+        for (int i = 0; i < 4; i++) {
+            if (steppers_home_switch(i)) {
+                Serial.print(F("ERROR: endstop hit on "));
+                Serial.println(i);
 
-    boolean x = stepper_x.run();
-    boolean y = stepper_y.run();
-    boolean z = stepper_z.run();
-    boolean e = stepper_e.run();
+                // TODO proper error handling?
+                lcd_clear();
+                lcd_set_heading("ERROR");
+                lcd_set_text("Endstop hit. Aborting!");
+                while (1) { }
+            }
+        }
+        boolean x = stepper_x.run();
+        boolean y = stepper_y.run();
+        boolean z = stepper_z.run();
+        boolean e = stepper_e.run();
+
+        return x || y || z || e;
+    }
 
-    return x || y || z || e;
+    return true;
 }
 
 bool steppers_homed(void) {
@@ -76,8 +246,7 @@ bool steppers_homed(void) {
 }
 
 void steppers_start_homing(void) {
-    state = step_homing_x_fast;
-
+    steppers_initiate_home(2, 0);
 }
 
 static int steppers_move_axis(AccelStepper &axis, long pos) {
@@ -91,45 +260,90 @@ static int steppers_move_axis(AccelStepper &axis, long pos) {
         state = step_not_homed;
     }
 
+    if (!steppers_homed()) {
+        Serial.println(F("WARNING: un-homed move!"));
+    }
+
     axis.moveTo(pos);
+    return 0;
 }
 
 int steppers_move_x(long pos) {
     Serial.print(F("Moving X to "));
     Serial.print(pos);
     Serial.print(F(" mm ("));
-    Serial.print(pos * XY_STEPS_PER_MM);
+    Serial.print(pos * XY_STEPS_PER_MM * X_AXIS_MOVEMENT_DIR);
     Serial.println(F(" steps)"));
 
-    return steppers_move_axis(stepper_x, pos * XY_STEPS_PER_MM);
+    if (pos < X_AXIS_MIN) {
+        Serial.println(F("Move below X_AXIS_MIN!"));
+        return -1;
+    }
+
+    if (pos > X_AXIS_MAX) {
+        Serial.println(F("Move above X_AXIS_MAX!"));
+        return -1;
+    }
+
+    return steppers_move_axis(stepper_x, pos * XY_STEPS_PER_MM * X_AXIS_MOVEMENT_DIR);
 }
 
 int steppers_move_y(long pos) {
     Serial.print(F("Moving Y to "));
     Serial.print(pos);
     Serial.print(F(" mm ("));
-    Serial.print(pos * XY_STEPS_PER_MM);
+    Serial.print(pos * XY_STEPS_PER_MM * Y_AXIS_MOVEMENT_DIR);
     Serial.println(F(" steps)"));
 
-    return steppers_move_axis(stepper_y, pos * XY_STEPS_PER_MM);
+    if (pos < Y_AXIS_MIN) {
+        Serial.println(F("Move below Y_AXIS_MIN!"));
+        return -1;
+    }
+
+    if (pos > Y_AXIS_MAX) {
+        Serial.println(F("Move above Y_AXIS_MAX!"));
+        return -1;
+    }
+
+    return steppers_move_axis(stepper_y, pos * XY_STEPS_PER_MM * Y_AXIS_MOVEMENT_DIR);
 }
 
 int steppers_move_z(long pos) {
     Serial.print(F("Moving Z to "));
     Serial.print(pos);
     Serial.print(F(" mm ("));
-    Serial.print(pos * Z_STEPS_PER_MM);
+    Serial.print(pos * Z_STEPS_PER_MM * Z_AXIS_MOVEMENT_DIR);
     Serial.println(F(" steps)"));
 
-    return steppers_move_axis(stepper_z, pos * Z_STEPS_PER_MM);
+    if (pos < Z_AXIS_MIN) {
+        Serial.println(F("Move below Z_AXIS_MIN!"));
+        return -1;
+    }
+
+    if (pos > Z_AXIS_MAX) {
+        Serial.println(F("Move above Z_AXIS_MAX!"));
+        return -1;
+    }
+
+    return steppers_move_axis(stepper_z, pos * Z_STEPS_PER_MM * Z_AXIS_MOVEMENT_DIR);
 }
 
 int steppers_move_e(long pos) {
     Serial.print(F("Moving E to "));
     Serial.print(pos);
     Serial.print(F(" mm ("));
-    Serial.print(pos * E_STEPS_PER_MM);
+    Serial.print(pos * E_STEPS_PER_MM * E_AXIS_MOVEMENT_DIR);
     Serial.println(F(" steps)"));
 
-    return steppers_move_axis(stepper_e, pos * E_STEPS_PER_MM);
+    if (pos < E_AXIS_MIN) {
+        Serial.println(F("Move below E_AXIS_MIN!"));
+        return -1;
+    }
+
+    if (pos > E_AXIS_MAX) {
+        Serial.println(F("Move above E_AXIS_MAX!"));
+        return -1;
+    }
+
+    return steppers_move_axis(stepper_e, pos * E_STEPS_PER_MM * E_AXIS_MOVEMENT_DIR);
 }