more work on firmware.

include/data.h

 };
 
 struct data_config_preset {
-    uint8_t rows, cols;
+    uint8_t count_x, count_y;
     float distance_x, distance_y;
     float offset_x, offset_y;
     float top_z, bottom_z;

include/statemachine.h

     void dataGet(GetFuncPtr get);
     void dataCall(CallFuncPtr call);
 
+    void setPrefix(String pre);
+
     virtual void enterState(void);
     virtual void inState(StateMachineInput smi);
 
 
     int menuPos, menuOff;
     int count;
-    Array<const char *, STATE_ARRAY_SIZE> contents;
+    Array<String, STATE_ARRAY_SIZE> contents;
+    String prefix;
 };
 
 template <typename T>
 public:
     StateValue(State *_parent, T &_value, T _min, T _max);
 
+    void setHeading(const char *_heading);
+    void setText(const char *_text);
+
+    typedef void(*EnterFuncPtr)(void);
     typedef void(*UpdateFuncPtr)(T value);
 
+    void onEnter(EnterFuncPtr func);
+    void onLiveUpdate(UpdateFuncPtr func);
     void onUpdate(UpdateFuncPtr func);
 
     virtual void enterState(void);
 
     T &value;
     T min, max;
-    UpdateFuncPtr updateFunc;
+    const char *heading;
+    const char *text;
+    EnterFuncPtr onEnterFunc;
+    UpdateFuncPtr updateFunc, updateLiveFunc;
 };
 
+template <typename T, size_t N>
+class StateValues : public State {
+public:
+    StateValues(State *_parent);
+
+    void setData(size_t index, const char *name, T *value, T min, T max);
+
+    void setHeading(const char *_heading);
+    void setText(const char *_text);
+
+    typedef void(*UpdateFuncPtr)(size_t index, T value);
+
+    void onLiveUpdate(UpdateFuncPtr func);
+    void onUpdate(UpdateFuncPtr func);
+
+    virtual void enterState(void);
+    virtual void inState(StateMachineInput smi);
+
+private:
+    void display(void);
+
+    T *values[N];
+    T mins[N], maxs[N];
+    const char *texts[N];
+    const char *heading;
+    size_t pos;
+    bool editing;
+    UpdateFuncPtr updateFunc, updateLiveFunc;
+};
 
 #endif // _STATE_MACHINE_H_

include/steppers.h

 bool steppers_homed(void);
 void steppers_start_homing(void);
 
-int steppers_move_x(long pos);
-int steppers_move_y(long pos);
-int steppers_move_z(long pos);
-int steppers_move_e(long pos);
+float steppers_pos_x(void);
+float steppers_pos_y(void);
+float steppers_pos_z(void);
+float steppers_pos_e(void);
+
+int steppers_move_x(float pos);
+int steppers_move_y(float pos);
+int steppers_move_z(float pos);
+int steppers_move_e(float pos);
 
 void steppers_kill(void);
 

src/data.cpp

 
 // TODO make defines platform specific
 #define EEPROM_SIZE 4096
-#define RAM_SIZE (8192 / 2)
+#define RAM_SIZE (8192 / 8)
 
 struct data_config {
     uint8_t data_schema_version;
             return false;
         }
     } else {
-        Serial.print("read=");
+        Serial.print(F("checksum read="));
         Serial.print(config.checksum);
-        Serial.print(" calc=");
+        Serial.print(F(" calc="));
         Serial.println(checksum);
         last_error = "Checksum";
         return false;

src/encoder.cpp

 
 #ifdef DEBUG_ENCODER
     if (diff != 0) {
-        Serial.print("encoder_change: ");
+        Serial.print(F("encoder_change: "));
         Serial.print(diff);
-        Serial.print(" ticks: ");
+        Serial.print(F(" ticks: "));
         Serial.println(new_pos);
     }
 #endif // DEBUG_ENCODER
         ignore_until_next_unclick = true;
 
 #ifdef DEBUG_ENCODER
-        Serial.println("encoder_click: 1");
+        Serial.println(F("encoder_click: 1"));
 #endif // DEBUG_ENCODER
     }
 
 #ifdef KILL_PIN
 #ifdef DEBUG_ENCODER
     if (kill_state == 1) {
-        Serial.println("kill_switch: 1");
+        Serial.println(F("kill_switch: 1"));
     }
 #endif // DEBUG_ENCODER
 

src/lcd.cpp

 #define SCROLL_DELAY 500
 unsigned long last_scroll_time = 0;
 
+#define IS_TEXT_CHAR(x) (((x >= 'a') && (x <= 'z')) || ((x >= 'A') && (x <= 'Z')))
+
 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++) {
+        // take previously stored string and put in front of line
         s[i] = for_next_line + s[i];
         for_next_line = "";
+
+        // if a line is longer then w, take end off and store
         if (s[i].length() > w) {
-            for_next_line = s[i].substring(w);
+            for_next_line += s[i].substring(w);
             s[i] = s[i].substring(0, w);
         }
+
+        // if a newline is in this line, end the text there and split it
+        for (int j = 0; j < s[i].length(); j++) {
+            if (s[i][j] == '\n') {
+                for_next_line = s[i].substring(j + 1) + for_next_line;
+                s[i] = s[i].substring(0, j);
+                break;
+            }
+        }
+
+        // if the last char of this line and the first char of for_next_line
+        // exist and are both upper/lowercase characters, check if one of the
+        // previous 5 chars is a space, and instead split there
+        if ((n > 1) && (for_next_line.length() > 0) && IS_TEXT_CHAR(s[i][s[i].length() - 1]) && IS_TEXT_CHAR(for_next_line[0])) {
+            for (int j = s[i].length() - 2; (j >= 0) && (j >= s[i].length() - 2 - 5); j--) {
+                if (s[i][j] == ' ') {
+                for_next_line = s[i].substring(j + 1) + for_next_line;
+                s[i] = s[i].substring(0, j + 1);
+                break;
+                }
+            }
+        }
     }
 
     // if something remains at end, store remainder, if given, otherwise leave at last line
     lcd.firstPage();
     do {
         lcd.setFont(u8g2_font_luBS12_tr);
-        lcd.drawStr(0, 14 * 1, "Fuellfix v2");
-        lcd.drawStr(0, 14 * 2, "Initializing");
+
+        String s = F("Fuellfix v2");
+        lcd.drawStr(0, 14 * 1, s.c_str());
+
+        s = F("Initializing");
+        lcd.drawStr(0, 14 * 2, s.c_str());
 
         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");
+
+        s = F("Software Version " FIRMWARE_VERSION);
+        lcd.drawStr(0, 14 * 2 + 8 + 12 * 1, s.c_str());
+
+        s = F("made by: xythobuz.de");
+        lcd.drawStr(0, 14 * 2 + 8 + 12 * 2, s.c_str());
     } while (lcd.nextPage());
 #endif // USE_FULL_GRAPHIC_LCD
 }
 
 void lcd_set_menu_text(int line, const char *t) {
     Serial.print(line);
-    Serial.print(": ");
+    Serial.print(F(": "));
     Serial.println(t);
 
     text_mode = lcd_mode_menu;

src/statemachine.cpp

     }
 
     lcd_clear();
-    lcd_set_heading(heading);
-    lcd_set_text(text);
+    if (heading != NULL) {
+        lcd_set_heading(heading);
+    } else if (getTitle() != NULL) {
+        lcd_set_heading(getTitle());
+    }
+    if (text != NULL) {
+        lcd_set_text(text);
+    }
 }
 
 void StateText::inState(struct StateMachineInput smi) {
     }
 
     for (int i = menuOff; (i < menuOff + lcd_text_lines()) && (i < size); i++) {
-        String s = "";
+        String s;
         if (i == menuPos) {
-            s += "> ";
+            s = F("> ");
         } else {
-            s += "  ";
+            s = F("  ");
         }
         if (i == children.size()) {
             s += getParent()->getTitle();
 StateDynamicMenu::StateDynamicMenu(State *_parent) : State(_parent) {
     menuPos = 0;
     menuOff = 0;
+    prefix = "";
+    countFunc = NULL;
+    getFunc = NULL;
+    callFunc = NULL;
 }
 
 void StateDynamicMenu::dataCount(CountFuncPtr count) {
     lcd_set_heading(getTitle());
 
     for (int i = menuOff; (i < menuOff + lcd_text_lines()) && (i < count + 1); i++) {
-        String s = "";
+        String s;
         if (i == menuPos) {
-            s += "> ";
+            s = F("> ");
         } else {
-            s += "  ";
+            s = F("  ");
         }
         if (i == count) {
             s += getParent()->getTitle();
     }
 }
 
+void StateDynamicMenu::setPrefix(String pre) {
+    prefix = pre;
+}
+
 void StateDynamicMenu::enterState(void) {
     // cache all entries on entering state
     if (countFunc != NULL) {
     contents.clear();
     for (int i = 0; i < count; i++) {
         if (getFunc != NULL) {
-            contents.push_back(getFunc(i));
+            contents.push_back(prefix + String(getFunc(i)));
         } else {
-            contents.push_back("no get func");
+            contents.push_back(prefix + String(i + 1));
         }
     }
 
 StateValue<T>::StateValue(State *_parent, T &_value, T _min, T _max) : State(_parent), value(_value) {
     min = _min;
     max = _max;
+    heading = NULL;
+    text = NULL;
+    onEnterFunc = NULL;
     updateFunc = NULL;
+    updateLiveFunc = NULL;
+}
+
+template <typename T>
+void StateValue<T>::setHeading(const char *_heading) {
+    heading = _heading;
+}
+
+template <typename T>
+void StateValue<T>::setText(const char *_text) {
+    text = _text;
+}
+
+template <typename T>
+void StateValue<T>::onEnter(EnterFuncPtr func) {
+    onEnterFunc = func;
 }
 
 template <typename T>
 }
 
 template <typename T>
+void StateValue<T>::onLiveUpdate(UpdateFuncPtr func) {
+    updateLiveFunc = func;
+}
+
+template <typename T>
 void StateValue<T>::display(void) {
-    String s = String(min) + " .. " + String(value) + " .. " + String(max);
+    lcd_clear();
+    if (heading == NULL) {
+        lcd_set_heading(getTitle());
+    } else {
+        lcd_set_heading(heading);
+    }
+
+    String s = String(min) + F(" .. ") + String(value) + F(" .. ") + String(max);
+
+    if (text != NULL) {
+        s = text + String(F("\n")) + s;
+    }
+
     lcd_set_text(s.c_str());
 }
 
+
 template <typename T>
 void StateValue<T>::enterState(void) {
-    lcd_clear();
-    lcd_set_heading(getTitle());
-
+    if (onEnterFunc != NULL) {
+        onEnterFunc();
+    }
     display();
 }
 
         if (value > max) {
             value = max;
         }
+        if (updateLiveFunc != NULL) {
+            updateLiveFunc(value);
+        }
         display();
     }
     if (smi.click) {
     }
 }
 
+template class StateValue<int>;
 template class StateValue<float>;
 
 // --------------------------------------
 
 template <typename T, size_t N>
+StateValues<T, N>::StateValues(State *_parent) : State(_parent) {
+    heading = NULL;
+    updateFunc = NULL;
+    updateLiveFunc = NULL;
+    pos = 0;
+    editing = false;
+}
+
+template <typename T, size_t N>
+void StateValues<T, N>::setData(size_t index, const char *name, T *value, T min, T max) {
+    if (index >= N) {
+        return;
+    }
+    values[index] = value;
+    mins[index] = min;
+    maxs[index] = max;
+    texts[index] = name;
+}
+
+template <typename T, size_t N>
+void StateValues<T, N>::setHeading(const char *_heading) {
+    heading = _heading;
+}
+
+template <typename T, size_t N>
+void StateValues<T, N>::onUpdate(UpdateFuncPtr func) {
+    updateFunc = func;
+}
+
+template <typename T, size_t N>
+void StateValues<T, N>::onLiveUpdate(UpdateFuncPtr func) {
+    updateLiveFunc = func;
+}
+
+template <typename T, size_t N>
+void StateValues<T, N>::display(void) {
+    lcd_clear();
+
+    if (heading == NULL) {
+        lcd_set_heading(getTitle());
+    } else {
+        lcd_set_heading(heading);
+    }
+
+    for (size_t i = 0; i < (N + 1); i++) {
+        String s;
+
+        if (i == pos) {
+            if (editing) {
+                s = F("# ");
+            } else {
+                s = F("> ");
+            }
+        } else {
+            s = F("  ");
+        }
+
+        if (i < N) {
+            s += texts[i] + String(*(values[i])) + F(" (") + String(mins[i]) + F("/") + String(maxs[i]) + F(")");
+        } else {
+            if (getChild() != NULL) {
+                s += F("Continue");
+            } else {
+                s += F("Done");
+            }
+        }
+
+        lcd_set_menu_text(i, s.c_str());
+    }
+}
+
+template <typename T, size_t N>
+void StateValues<T, N>::enterState(void) {
+    pos = 0;
+    display();
+}
+
+template <typename T, size_t N>
+void StateValues<T, N>::inState(StateMachineInput smi) {
+    if (editing) {
+        if (smi.encoder != 0) {
+            *(values[pos]) -= smi.encoder;
+            if (*(values[pos]) < mins[pos]) {
+                *(values[pos]) = mins[pos];
+            }
+            if (*(values[pos]) > maxs[pos]) {
+                *(values[pos]) = maxs[pos];
+            }
+            if (updateLiveFunc != NULL) {
+                updateLiveFunc(pos, *(values[pos]));
+            }
+            display();
+        }
+        if (smi.click) {
+            editing = false;
+            display();
+        }
+    } else {
+        if (smi.encoder != 0) {
+            int tmp = pos;
+            tmp -= smi.encoder;
+
+            while (tmp < 0) {
+                tmp += N + 1;
+            }
+
+            while (tmp >= (N + 1)) {
+                tmp -= N + 1;
+            }
+
+            pos = tmp;
+
+            display();
+        }
+        if (smi.click) {
+            if (pos < N) {
+                editing = true;
+                display();
+            } else {
+                if (updateFunc != NULL) {
+                    for (size_t i = 0; i < N; i++) {
+                        updateFunc(i, *(values[i]));
+                    }
+                }
+                if (getChild() != NULL) {
+                    states_go_to(getChild());
+                } else if (getParent() != NULL) {
+                    states_go_to(getParent());
+                }
+            }
+        }
+    }
+}
+
+template class StateValues<uint8_t, 2>;
+template class StateValues<float, 2>;
+
+// --------------------------------------
+
+template <typename T, size_t N>
 void array_print(Array<T, N> *arr) {
-    Serial.print("Array length: ");
+    Serial.print(F("Array length: "));
     Serial.print(arr->size());
-    Serial.println(" contents:");
+    Serial.println(F(" contents:"));
     for (int i = 0; i < arr->size(); i++) {
         Serial.print(i);
-        Serial.print(": ");
+        Serial.print(F(": "));
         Serial.println(arr->at(i)->getTitle());
     }
 }

src/states.cpp

 
 StateMenu sm_auto = StateMenu(&sm_menu);
 StateDynamicMenu sm_presets = StateDynamicMenu(&sm_auto);
+// TODO dispense
+
 StateText sm_new_preset = StateText(&sm_auto);
+StateText sm_wiz_move = StateText(&sm_new_preset);
+StateValues<uint8_t, 2> sm_wiz_count = StateValues<uint8_t, 2>(&sm_wiz_move);
+StateValues<float, 2> sm_wiz_first_pos = StateValues<float, 2>(&sm_wiz_count);
+StateValues<float, 2> sm_wiz_last_pos = StateValues<float, 2>(&sm_wiz_first_pos);
+// TODO move z above container
+// TODO move z inside container
+// TODO move to extruder depth
+StateText sm_new_preset_done = StateText(&sm_wiz_last_pos);
+
 StateDynamicMenu sm_mod_preset = StateDynamicMenu(&sm_auto);
+// TODO modify
+
 StateDynamicMenu sm_del_preset = StateDynamicMenu(&sm_auto);
+// TODO delete
 
+float move_pos_x = 0.0, move_pos_y = 0.0, move_pos_z = 0.0, move_pos_e = 0.0;
 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);
+StateValue<float> sm_move_x = StateValue<float>(&sm_move, move_pos_x, X_AXIS_MIN, X_AXIS_MAX);
+StateValue<float> sm_move_y = StateValue<float>(&sm_move, move_pos_y, Y_AXIS_MIN, Y_AXIS_MAX);
+StateValue<float> sm_move_z = StateValue<float>(&sm_move, move_pos_z, Z_AXIS_MIN, Z_AXIS_MAX);
+StateValue<float> sm_move_e = StateValue<float>(&sm_move, move_pos_e, E_AXIS_MIN, E_AXIS_MAX);
 
 StateMenu sm_config = StateMenu(&sm_menu);
 StateText sm_conf_load = StateText(&sm_config);
 
 State *current_state = NULL;
 String strbuf;
+struct data_config_preset wizard_preset = { .count_x = 1, .count_y = 1 };
+float wizard_first_x = 0.0, wizard_first_y = 0.0;
+float wizard_last_x = 0.0, wizard_last_y = 0.0;
 
 void states_init(void) {
     // ----------------------------------
     sm_move.setTitle("Move Axis");
 
     sm_move_x.setTitle("X Axis");
+    sm_move_x.onEnter([]() {
+        move_pos_x = steppers_pos_x();
+    });
+    sm_move_x.onLiveUpdate([](float v) {
+        steppers_move_x(v);
+    });
+
     sm_move_y.setTitle("Y Axis");
+    sm_move_y.onEnter([]() {
+        move_pos_y = steppers_pos_y();
+    });
+    sm_move_y.onLiveUpdate([](float v) {
+        steppers_move_y(v);
+    });
+
     sm_move_z.setTitle("Z Axis");
+    sm_move_z.onEnter([]() {
+        move_pos_z = steppers_pos_z();
+    });
+    sm_move_z.onLiveUpdate([](float v) {
+        steppers_move_z(v);
+    });
+
     sm_move_e.setTitle("E Axis");
+    sm_move_e.onEnter([]() {
+        move_pos_e = steppers_pos_e();
+    });
+    sm_move_e.onLiveUpdate([](float v) {
+        steppers_move_e(v);
+    });
 
     // ----------------------------------
 
     sm_auto.setTitle("Filling Menu");
 
     sm_presets.setTitle("Use Preset");
+    sm_presets.setPrefix("Preset ");
     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
-        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());
+    sm_new_preset.setHeading("Preset Wizard");
+    sm_new_preset.setText("Moving axes into initial positions. Click to continue.");
+
+    sm_wiz_move.setTitle("Initial Movement");
+    sm_wiz_move.onEnter([]() {
+        //steppers_start_homing();
+    });
+    sm_wiz_move.whenIn([](StateMachineInput smi) {
+        //if (smi.motors_done) {
+        //    if (steppers_homed()) {
+                states_go_to(&sm_wiz_count);
+        //    }
+        //}
+
+        // TODO update text with current axis
+    });
+
+    sm_wiz_count.setTitle("Container Count");
+    sm_wiz_count.setData(0, "X: ", &wizard_preset.count_x, 1, 50);
+    sm_wiz_count.setData(1, "Y: ", &wizard_preset.count_y, 1, 100);
+
+    sm_wiz_first_pos.setTitle("First Container Position");
+    sm_wiz_first_pos.setData(0, "X: ", &wizard_first_x, X_AXIS_MIN, X_AXIS_MAX);
+    sm_wiz_first_pos.setData(1, "Y: ", &wizard_first_y, Y_AXIS_MIN, Y_AXIS_MAX);
+    sm_wiz_first_pos.onLiveUpdate([](size_t i, float v) {
+        if (i == 0) {
+            steppers_move_x(v);
+        } else {
+            steppers_move_y(v);
+        }
+    });
+    sm_wiz_first_pos.onUpdate([](size_t i, float v) {
+        if (i == 0) {
+            wizard_preset.offset_x = v;
+        } else {
+            wizard_preset.offset_y = v;
+        }
+    });
+
+    sm_wiz_last_pos.setTitle("Last Container Position");
+    sm_wiz_last_pos.setData(0, "X: ", &wizard_last_x, X_AXIS_MIN, X_AXIS_MAX);
+    sm_wiz_last_pos.setData(1, "Y: ", &wizard_last_y, Y_AXIS_MIN, Y_AXIS_MAX);
+    sm_wiz_last_pos.onLiveUpdate([](size_t i, float v) {
+        if (i == 0) {
+            steppers_move_x(v);
         } else {
-            strbuf = "Preset " + String(data_preset_count()) + " has been added!";
-            sm_new_preset.setText(strbuf.c_str());
+            steppers_move_y(v);
+        }
+    });
+    sm_wiz_last_pos.onUpdate([](size_t i, float v) {
+        if (i == 0) {
+            wizard_preset.distance_x = (v - wizard_preset.offset_x) / wizard_preset.count_x;
+        } else {
+            wizard_preset.distance_y = (v - wizard_preset.offset_y) / wizard_preset.count_y;
+        }
+    });
+
+    sm_new_preset_done.setTitle("Preset Wizard Done");
+    sm_new_preset_done.setHeading("Preset Wizard Done");
+    sm_new_preset_done.onEnter([]() {
+        if (!data_preset_add(wizard_preset)) {
+            strbuf = String(data_eeprom_error()) + F(" Error adding preset!");
+            sm_new_preset_done.setText(strbuf.c_str());
+        } else {
+            strbuf = F("Preset ");
+            strbuf += String(data_preset_count());
+            strbuf += F(" has been added! Don't forget to store config to EEPROM to keep it.");
+            sm_new_preset_done.setText(strbuf.c_str());
+        }
+    });
+    sm_new_preset_done.whenIn([](StateMachineInput smi) {
+        if (smi.click) {
+            states_go_to(&sm_auto);
         }
     });
 
     sm_mod_preset.setTitle("Modify Preset");
+    sm_mod_preset.setPrefix("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.setPrefix("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";
-    });
 
     // ----------------------------------
 
 
     if (smi.kill) {
         steppers_kill();
-        Serial.println("Kill button pressed!");
+        Serial.println(F("Kill button pressed!"));
         blocking_beep(KILL_BEEP_TIME, KILL_BEEP_FREQ, KILL_BEEP_REPEAT - 1);
         states_go_to(&sm_ask_homing);
         return;

src/steppers.cpp

     return 0;
 }
 
-int steppers_move_x(long pos) {
+int steppers_move_x(float pos) {
     Serial.print(F("Moving X to "));
     Serial.print(pos);
     Serial.print(F(" mm ("));
     return steppers_move_axis(stepper_x, pos * XY_STEPS_PER_MM * X_AXIS_MOVEMENT_DIR);
 }
 
-int steppers_move_y(long pos) {
+int steppers_move_y(float pos) {
     Serial.print(F("Moving Y to "));
     Serial.print(pos);
     Serial.print(F(" mm ("));
     return steppers_move_axis(stepper_y, pos * XY_STEPS_PER_MM * Y_AXIS_MOVEMENT_DIR);
 }
 
-int steppers_move_z(long pos) {
+int steppers_move_z(float pos) {
     Serial.print(F("Moving Z to "));
     Serial.print(pos);
     Serial.print(F(" mm ("));
     return steppers_move_axis(stepper_z, pos * Z_STEPS_PER_MM * Z_AXIS_MOVEMENT_DIR);
 }
 
-int steppers_move_e(long pos) {
+int steppers_move_e(float pos) {
     Serial.print(F("Moving E to "));
     Serial.print(pos);
     Serial.print(F(" mm ("));
     return steppers_move_axis(stepper_e, E_MM_TO_PERCENT(pos) * E_STEPS_PER_PERCENT * E_AXIS_MOVEMENT_DIR);
 }
 
+float steppers_pos_x(void) {
+    float v = stepper_x.targetPosition();
+    return v / XY_STEPS_PER_MM / X_AXIS_MOVEMENT_DIR;
+}
+
+float steppers_pos_y(void) {
+    float v = stepper_y.targetPosition();
+    return v / XY_STEPS_PER_MM / Y_AXIS_MOVEMENT_DIR;
+}
+
+float steppers_pos_z(void) {
+    float v = stepper_z.targetPosition();
+    return v / Z_STEPS_PER_MM / Z_AXIS_MOVEMENT_DIR;
+}
+
+float steppers_pos_e(void) {
+    float v = stepper_e.targetPosition();
+    return E_PERCENT_TO_MM(v / E_STEPS_PER_PERCENT / E_AXIS_MOVEMENT_DIR);
+}
+
 void steppers_kill(void) {
     stepper_x.setCurrentPosition(0);
     stepper_y.setCurrentPosition(0);