diff --git a/stm32-modules/include/flex-stacker/flex-stacker/gcodes_motor.hpp b/stm32-modules/include/flex-stacker/flex-stacker/gcodes_motor.hpp
index aefcf4d4..cdd6330b 100644
--- a/stm32-modules/include/flex-stacker/flex-stacker/gcodes_motor.hpp
+++ b/stm32-modules/include/flex-stacker/flex-stacker/gcodes_motor.hpp
@@ -87,6 +87,61 @@ struct GetTMCRegister {
     }
 };
 
+struct SetMicrosteps {
+    MotorID motor_id;
+    uint8_t microsteps_power;
+
+    using ParseResult = std::optional<SetMicrosteps>;
+    static constexpr auto prefix = std::array{'M', '9', '0', '9', ' '};
+    static constexpr const char* response = "M909 OK\n";
+
+    template <typename InputIt, typename Limit>
+    requires std::forward_iterator<InputIt> &&
+        std::sized_sentinel_for<Limit, InputIt>
+    static auto parse(const InputIt& input, Limit limit)
+        -> std::pair<ParseResult, InputIt> {
+        MotorID motor_id_val = MotorID::MOTOR_X;
+        auto working = prefix_matches(input, limit, prefix);
+        if (working == input) {
+            return std::make_pair(ParseResult(), input);
+        }
+        switch (*working) {
+            case 'X':
+                motor_id_val = MotorID::MOTOR_X;
+                break;
+            case 'Z':
+                motor_id_val = MotorID::MOTOR_Z;
+                break;
+            case 'L':
+                motor_id_val = MotorID::MOTOR_L;
+                break;
+            default:
+                return std::make_pair(ParseResult(), input);
+        }
+        std::advance(working, 1);
+        if (working == limit) {
+            return std::make_pair(ParseResult(), input);
+        }
+
+        auto ustep_res = gcode::parse_value<uint8_t>(working, limit);
+        if (!ustep_res.first.has_value()) {
+            return std::make_pair(ParseResult(), input);
+        }
+
+        return std::make_pair(ParseResult(SetMicrosteps{
+                                  .motor_id = motor_id_val,
+                                  .microsteps_power = ustep_res.first.value()}),
+                              ustep_res.second);
+    }
+
+    template <typename InputIt, typename InLimit>
+    requires std::forward_iterator<InputIt> &&
+        std::sized_sentinel_for<InputIt, InLimit>
+    static auto write_response_into(InputIt buf, InLimit limit) -> InputIt {
+        return write_string_to_iterpair(buf, limit, response);
+    }
+};
+
 struct SetTMCRegister {
     MotorID motor_id;
     uint8_t reg;
@@ -480,9 +535,7 @@ struct MoveMotorInSteps {
 struct MoveMotorInMm {
     MotorID motor_id;
     float mm;
-    float mm_per_second;
-    float mm_per_second_sq;
-    float mm_per_second_discont;
+    std::optional<float> mm_per_second, mm_per_second_sq, mm_per_second_discont;
 
     using ParseResult = std::optional<MoveMotorInMm>;
     static constexpr auto prefix = std::array{'G', '0', ' '};
@@ -508,7 +561,7 @@ struct MoveMotorInMm {
     };
     struct VelArg {
         static constexpr auto prefix = std::array{'V'};
-        static constexpr bool required = true;
+        static constexpr bool required = false;
         bool present = false;
         float value = 0;
     };
@@ -541,9 +594,9 @@ struct MoveMotorInMm {
         auto ret = MoveMotorInMm{
             .motor_id = MotorID::MOTOR_X,
             .mm = 0.0,
-            .mm_per_second = 0.0,
-            .mm_per_second_sq = 0.0,
-            .mm_per_second_discont = 0.0,
+            .mm_per_second = std::nullopt,
+            .mm_per_second_sq = std::nullopt,
+            .mm_per_second_discont = std::nullopt,
         };
 
         auto arguments = res.first.value();
@@ -561,8 +614,6 @@ struct MoveMotorInMm {
 
         if (std::get<3>(arguments).present) {
             ret.mm_per_second = std::get<3>(arguments).value;
-        } else {
-            return std::make_pair(ParseResult(), input);
         }
 
         if (std::get<4>(arguments).present) {
@@ -587,9 +638,7 @@ struct MoveMotorInMm {
 struct MoveToLimitSwitch {
     MotorID motor_id;
     bool direction;
-    float mm_per_second;
-    float mm_per_second_sq;
-    float mm_per_second_discont;
+    std::optional<float> mm_per_second, mm_per_second_sq, mm_per_second_discont;
 
     using ParseResult = std::optional<MoveToLimitSwitch>;
     static constexpr auto prefix = std::array{'G', '5', ' '};
@@ -646,9 +695,9 @@ struct MoveToLimitSwitch {
         auto ret = MoveToLimitSwitch{
             .motor_id = MotorID::MOTOR_X,
             .direction = false,
-            .mm_per_second = 0.0,
-            .mm_per_second_sq = 0.0,
-            .mm_per_second_discont = 0.0,
+            .mm_per_second = std::nullopt,
+            .mm_per_second_sq = std::nullopt,
+            .mm_per_second_discont = std::nullopt,
         };
 
         auto arguments = res.first.value();
@@ -826,4 +875,53 @@ struct GetLimitSwitches {
     }
 };
 
+struct GetMoveParams {
+    MotorID motor_id;
+    using ParseResult = std::optional<GetMoveParams>;
+    static constexpr auto prefix = std::array{'M', '1', '2', '0'};
+
+    template <typename InputIt, typename Limit>
+    requires std::forward_iterator<InputIt> &&
+        std::sized_sentinel_for<Limit, InputIt>
+    static auto parse(const InputIt& input, Limit limit)
+        -> std::pair<ParseResult, InputIt> {
+        MotorID motor = MotorID::MOTOR_X;
+        auto res = gcode::SingleParser<ArgX, ArgZ, ArgL>::parse_gcode(
+            input, limit, prefix);
+        if (!res.first.has_value()) {
+            return std::make_pair(ParseResult(), input);
+        }
+        auto arguments = res.first.value();
+        if (std::get<1>(arguments).present) {
+            motor = MotorID::MOTOR_Z;
+        } else if (std::get<2>(arguments).present) {
+            motor = MotorID::MOTOR_L;
+        } else if (!std::get<0>(arguments).present) {
+            return std::make_pair(ParseResult(), input);
+        }
+        return std::make_pair(ParseResult(GetMoveParams{.motor_id = motor}),
+                              res.second);
+    }
+
+    template <typename InputIt, typename InLimit>
+    requires std::forward_iterator<InputIt> &&
+        std::sized_sentinel_for<InputIt, InLimit>
+    static auto write_response_into(InputIt buf, InLimit limit,
+                                    MotorID motor_id, float velocity,
+                                    float accel, float velocity_discont)
+        -> InputIt {
+        char motor_char = motor_id == MotorID::MOTOR_X   ? 'X'
+                          : motor_id == MotorID::MOTOR_Z ? 'Z'
+                                                         : 'L';
+        int res = 0;
+        res =
+            snprintf(&*buf, (limit - buf), "M120 %c V:%.3f A:%.3f D:%.3f OK\n",
+                     motor_char, velocity, accel, velocity_discont);
+        if (res <= 0) {
+            return buf;
+        }
+        return buf + res;
+    }
+};
+
 }  // namespace gcode
diff --git a/stm32-modules/include/flex-stacker/flex-stacker/host_comms_task.hpp b/stm32-modules/include/flex-stacker/flex-stacker/host_comms_task.hpp
index d4242d19..0209dabb 100644
--- a/stm32-modules/include/flex-stacker/flex-stacker/host_comms_task.hpp
+++ b/stm32-modules/include/flex-stacker/flex-stacker/host_comms_task.hpp
@@ -35,23 +35,24 @@ class HostCommsTask {
   public:
     using Queue = QueueImpl<Message>;
     using Aggregator = typename tasks::Tasks<QueueImpl>::QueueAggregator;
+    using Queues = typename tasks::Tasks<QueueImpl>;
 
   private:
-    using GCodeParser =
-        gcode::GroupParser<gcode::GetTMCRegister, gcode::SetTMCRegister,
-                           gcode::SetRunCurrent, gcode::SetHoldCurrent,
-                           gcode::EnableMotor, gcode::DisableMotor,
-                           gcode::MoveMotorInSteps, gcode::MoveToLimitSwitch,
-                           gcode::MoveMotorInMm, gcode::GetLimitSwitches>;
+    using GCodeParser = gcode::GroupParser<
+        gcode::GetTMCRegister, gcode::SetTMCRegister, gcode::SetRunCurrent,
+        gcode::SetHoldCurrent, gcode::EnableMotor, gcode::DisableMotor,
+        gcode::MoveMotorInSteps, gcode::MoveToLimitSwitch, gcode::MoveMotorInMm,
+        gcode::GetLimitSwitches, gcode::SetMicrosteps, gcode::GetMoveParams>;
     using AckOnlyCache =
         AckCache<8, gcode::EnterBootloader, gcode::SetSerialNumber,
                  gcode::SetTMCRegister, gcode::SetRunCurrent,
                  gcode::SetHoldCurrent, gcode::EnableMotor, gcode::DisableMotor,
                  gcode::MoveMotorInSteps, gcode::MoveToLimitSwitch,
-                 gcode::MoveMotorInMm>;
+                 gcode::MoveMotorInMm, gcode::SetMicrosteps>;
     using GetSystemInfoCache = AckCache<8, gcode::GetSystemInfo>;
     using GetTMCRegisterCache = AckCache<8, gcode::GetTMCRegister>;
     using GetLimitSwitchesCache = AckCache<8, gcode::GetLimitSwitches>;
+    using GetMoveParamsCache = AckCache<8, gcode::GetMoveParams>;
 
   public:
     static constexpr size_t TICKS_TO_WAIT_ON_SEND = 10;
@@ -66,7 +67,9 @@ class HostCommsTask {
           // NOLINTNEXTLINE(readability-redundant-member-init)
           get_tmc_register_cache(),
           // NOLINTNEXTLINE(readability-redundant-member-init)
-          get_limit_switches_cache() {}
+          get_limit_switches_cache(),
+          // NOLINTNEXTLINE(readability-redundant-member-init)
+          get_move_params_cache() {}
     HostCommsTask(const HostCommsTask& other) = delete;
     auto operator=(const HostCommsTask& other) -> HostCommsTask& = delete;
     HostCommsTask(HostCommsTask&& other) noexcept = delete;
@@ -316,6 +319,29 @@ class HostCommsTask {
             cache_entry);
     }
 
+    template <typename InputIt, typename InputLimit>
+    requires std::forward_iterator<InputIt> &&
+        std::sized_sentinel_for<InputLimit, InputIt>
+    auto visit_message(const messages::GetMoveParamsResponse& response,
+                       InputIt tx_into, InputLimit tx_limit) -> InputIt {
+        auto cache_entry =
+            get_move_params_cache.remove_if_present(response.responding_to_id);
+        return std::visit(
+            [tx_into, tx_limit, response](auto cache_element) {
+                using T = std::decay_t<decltype(cache_element)>;
+                if constexpr (std::is_same_v<std::monostate, T>) {
+                    return errors::write_into(
+                        tx_into, tx_limit,
+                        errors::ErrorCode::BAD_MESSAGE_ACKNOWLEDGEMENT);
+                } else {
+                    return cache_element.write_response_into(
+                        tx_into, tx_limit, response.motor_id, response.velocity,
+                        response.acceleration, response.velocity_discont);
+                }
+            },
+            cache_entry);
+    }
+
     template <typename InputIt, typename InputLimit>
     requires std::forward_iterator<InputIt> &&
         std::sized_sentinel_for<InputLimit, InputIt>
@@ -424,6 +450,32 @@ class HostCommsTask {
         return std::make_pair(true, tx_into);
     }
 
+    template <typename InputIt, typename InputLimit>
+    requires std::forward_iterator<InputIt> &&
+        std::sized_sentinel_for<InputLimit, InputIt>
+    auto visit_gcode(const gcode::SetMicrosteps& gcode, InputIt tx_into,
+                     InputLimit tx_limit) -> std::pair<bool, InputIt> {
+        auto id = ack_only_cache.add(gcode);
+        if (id == 0) {
+            return std::make_pair(
+                false, errors::write_into(tx_into, tx_limit,
+                                          errors::ErrorCode::GCODE_CACHE_FULL));
+        }
+        auto message = messages::SetMicrostepsMessage{
+            .id = id,
+            .motor_id = gcode.motor_id,
+            .microsteps_power =
+                std::min(gcode.microsteps_power, static_cast<uint8_t>(8))};
+        if (!task_registry->send_to_address(message, Queues::MotorDriverAddress,
+                                            TICKS_TO_WAIT_ON_SEND)) {
+            auto wrote_to = errors::write_into(
+                tx_into, tx_limit, errors::ErrorCode::INTERNAL_QUEUE_FULL);
+            ack_only_cache.remove_if_present(id);
+            return std::make_pair(false, wrote_to);
+        }
+        return std::make_pair(true, tx_into);
+    }
+
     template <typename InputIt, typename InputLimit>
     requires std::forward_iterator<InputIt> &&
         std::sized_sentinel_for<InputLimit, InputIt>
@@ -614,6 +666,28 @@ class HostCommsTask {
         return std::make_pair(true, tx_into);
     }
 
+    template <typename InputIt, typename InputLimit>
+    requires std::forward_iterator<InputIt> &&
+        std::sized_sentinel_for<InputLimit, InputIt>
+    auto visit_gcode(const gcode::GetMoveParams& gcode, InputIt tx_into,
+                     InputLimit tx_limit) -> std::pair<bool, InputIt> {
+        auto id = get_move_params_cache.add(gcode);
+        if (id == 0) {
+            return std::make_pair(
+                false, errors::write_into(tx_into, tx_limit,
+                                          errors::ErrorCode::GCODE_CACHE_FULL));
+        }
+        auto message = messages::GetMoveParamsMessage{
+            .id = id, .motor_id = gcode.motor_id};
+        if (!task_registry->send(message, TICKS_TO_WAIT_ON_SEND)) {
+            auto wrote_to = errors::write_into(
+                tx_into, tx_limit, errors::ErrorCode::INTERNAL_QUEUE_FULL);
+            get_move_params_cache.remove_if_present(id);
+            return std::make_pair(false, wrote_to);
+        }
+        return std::make_pair(true, tx_into);
+    }
+
     // Our error handler just writes an error and bails
     template <typename InputIt, typename InputLimit>
     requires std::forward_iterator<InputIt> &&
@@ -632,6 +706,7 @@ class HostCommsTask {
     GetSystemInfoCache get_system_info_cache;
     GetTMCRegisterCache get_tmc_register_cache;
     GetLimitSwitchesCache get_limit_switches_cache;
+    GetMoveParamsCache get_move_params_cache;
     bool may_connect_latch = true;
 };
 
diff --git a/stm32-modules/include/flex-stacker/flex-stacker/messages.hpp b/stm32-modules/include/flex-stacker/flex-stacker/messages.hpp
index 49801728..7936d953 100644
--- a/stm32-modules/include/flex-stacker/flex-stacker/messages.hpp
+++ b/stm32-modules/include/flex-stacker/flex-stacker/messages.hpp
@@ -96,6 +96,12 @@ struct SetMotorCurrentMessage {
     float hold_current;
 };
 
+struct SetMicrostepsMessage {
+    uint32_t id;
+    MotorID motor_id;
+    uint8_t microsteps_power;
+};
+
 struct SetTMCRegisterMessage {
     uint32_t id;
     MotorID motor_id;
@@ -142,21 +148,21 @@ struct MoveMotorInStepsMessage {
 };
 
 struct MoveMotorInMmMessage {
-    uint32_t id;
-    MotorID motor_id;
-    float mm;
-    float mm_per_second;
-    float mm_per_second_sq;
-    float mm_per_second_discont;
+    uint32_t id = 0;
+    MotorID motor_id = MotorID::MOTOR_X;
+    float mm = 0;
+    std::optional<float> mm_per_second = std::nullopt;
+    std::optional<float> mm_per_second_sq = std::nullopt;
+    std::optional<float> mm_per_second_discont = std::nullopt;
 };
 
 struct MoveToLimitSwitchMessage {
-    uint32_t id;
-    MotorID motor_id;
-    bool direction;
-    float mm_per_second;
-    float mm_per_second_sq;
-    float mm_per_second_discont;
+    uint32_t id = 0;
+    MotorID motor_id = MotorID::MOTOR_X;
+    bool direction = false;
+    std::optional<float> mm_per_second = std::nullopt;
+    std::optional<float> mm_per_second_sq = std::nullopt;
+    std::optional<float> mm_per_second_discont = std::nullopt;
 };
 
 struct GetLimitSwitchesMessage {
@@ -188,10 +194,24 @@ struct StopMotorMessage {
     uint32_t id;
 };
 
+struct GetMoveParamsMessage {
+    uint32_t id;
+    MotorID motor_id;
+};
+
+struct GetMoveParamsResponse {
+    uint32_t responding_to_id;
+    MotorID motor_id;
+    float velocity;
+    float acceleration;
+    float velocity_discont;
+};
+
 using HostCommsMessage =
     ::std::variant<std::monostate, IncomingMessageFromHost, ForceUSBDisconnect,
                    ErrorMessage, AcknowledgePrevious, GetSystemInfoResponse,
-                   GetTMCRegisterResponse, GetLimitSwitchesResponses>;
+                   GetTMCRegisterResponse, GetLimitSwitchesResponses,
+                   GetMoveParamsResponse>;
 
 using SystemMessage =
     ::std::variant<std::monostate, AcknowledgePrevious, GetSystemInfoMessage,
@@ -200,12 +220,13 @@ using SystemMessage =
 using MotorDriverMessage =
     ::std::variant<std::monostate, SetTMCRegisterMessage, GetTMCRegisterMessage,
                    PollTMCRegisterMessage, StopPollTMCRegisterMessage,
-                   SetMotorCurrentMessage>;
+                   SetMotorCurrentMessage, SetMicrostepsMessage>;
 
 using MotorMessage =
     ::std::variant<std::monostate, MotorEnableMessage, MoveMotorInStepsMessage,
                    MoveToLimitSwitchMessage, StopMotorMessage,
                    MoveCompleteMessage, GetLimitSwitchesMessage,
-                   MoveMotorInMmMessage>;
+                   MoveMotorInMmMessage, SetMicrostepsMessage,
+                   GetMoveParamsMessage>;
 
 };  // namespace messages
diff --git a/stm32-modules/include/flex-stacker/flex-stacker/motor_driver_task.hpp b/stm32-modules/include/flex-stacker/flex-stacker/motor_driver_task.hpp
index 8b7050bd..bc297e6e 100644
--- a/stm32-modules/include/flex-stacker/flex-stacker/motor_driver_task.hpp
+++ b/stm32-modules/include/flex-stacker/flex-stacker/motor_driver_task.hpp
@@ -239,6 +239,24 @@ class MotorDriverTask {
         static_cast<void>(tmc2160_interface);
     }
 
+    template <tmc2160::TMC2160InterfacePolicy Policy>
+    auto visit_message(const messages::SetMicrostepsMessage& m,
+                       tmc2160::TMC2160Interface<Policy>& tmc2160_interface)
+        -> void {
+        driver_conf_from_id(m.motor_id).chopconf.mres = m.microsteps_power;
+        if (!_tmc2160.update_chopconf(driver_conf_from_id(m.motor_id),
+                                      tmc2160_interface, m.motor_id)) {
+            auto response = messages::AcknowledgePrevious{
+                .responding_to_id = m.id,
+                .with_error = errors::ErrorCode::TMC2160_WRITE_ERROR};
+            static_cast<void>(_task_registry->send_to_address(
+                response, Queues::HostCommsAddress));
+            return;
+        };
+        static_cast<void>(
+            _task_registry->send_to_address(m, Queues::MotorAddress));
+    }
+
     template <tmc2160::TMC2160InterfacePolicy Policy>
     auto visit_message(const messages::SetMotorCurrentMessage& m,
                        tmc2160::TMC2160Interface<Policy>& tmc2160_interface)
diff --git a/stm32-modules/include/flex-stacker/flex-stacker/motor_task.hpp b/stm32-modules/include/flex-stacker/flex-stacker/motor_task.hpp
index d41d3fb9..0643535c 100644
--- a/stm32-modules/include/flex-stacker/flex-stacker/motor_task.hpp
+++ b/stm32-modules/include/flex-stacker/flex-stacker/motor_task.hpp
@@ -48,6 +48,46 @@ static constexpr struct lms::LinearMotionSystemConfig<lms::GearBoxConfig>
     .steps_per_rev = 200, .microstep = 16,
 };
 
+struct MotorState {
+    // NOLINTNEXTLINE(misc-non-private-member-variables-in-classes)
+    float steps_per_mm;
+    // NOLINTNEXTLINE(misc-non-private-member-variables-in-classes)
+    float speed_mm_per_sec;
+    // NOLINTNEXTLINE(misc-non-private-member-variables-in-classes)
+    float accel_mm_per_sec_sq;
+    // NOLINTNEXTLINE(misc-non-private-member-variables-in-classes)
+    float speed_mm_per_sec_discont;
+    [[nodiscard]] auto get_speed() const -> float {
+        return speed_mm_per_sec * steps_per_mm;
+    }
+    [[nodiscard]] auto get_accel() const -> float {
+        return accel_mm_per_sec_sq * steps_per_mm * steps_per_mm;
+    }
+    [[nodiscard]] auto get_speed_discont() const -> float {
+        return speed_mm_per_sec_discont * steps_per_mm;
+    }
+    [[nodiscard]] auto get_distance(float mm) const -> float {
+        return mm * steps_per_mm;
+    }
+};
+
+struct XState {
+    static constexpr float DEFAULT_SPEED = 200.0;
+    static constexpr float DEFAULT_ACCELERATION = 50.0;
+    static constexpr float DEFAULT_SPEED_DISCONT = 5.0;
+};
+
+struct ZState {
+    static constexpr float DEFAULT_SPEED = 200.0;
+    static constexpr float DEFAULT_ACCELERATION = 50.0;
+    static constexpr float DEFAULT_SPEED_DISCONT = 5.0;
+};
+struct LState {
+    static constexpr float DEFAULT_SPEED = 200.0;
+    static constexpr float DEFAULT_ACCELERATION = 50.0;
+    static constexpr float DEFAULT_SPEED_DISCONT = 5.0;
+};
+
 template <template <class> class QueueImpl>
 requires MessageQueue<QueueImpl<Message>, Message>
 class MotorTask {
@@ -88,16 +128,16 @@ class MotorTask {
         }
     }
 
-    auto steps_per_mm(MotorID motor_id) -> float {
+    auto motor_state(MotorID motor_id) -> MotorState& {
         switch (motor_id) {
             case MotorID::MOTOR_X:
-                return motor_x_config.get_usteps_per_mm();
+                return _x_state;
             case MotorID::MOTOR_Z:
-                return motor_z_config.get_usteps_per_mm();
+                return _z_state;
             case MotorID::MOTOR_L:
-                return motor_l_config.get_usteps_per_mm();
+                return _l_state;
             default:
-                return motor_x_config.get_usteps_per_mm();
+                return _x_state;
         }
     }
 
@@ -169,24 +209,46 @@ class MotorTask {
         -> void {
         static_cast<void>(policy);
         auto direction = m.mm > 0;
-        auto s_per_m = steps_per_mm(m.motor_id);
+        if (m.mm_per_second.has_value()) {
+            motor_state(m.motor_id).speed_mm_per_sec = m.mm_per_second.value();
+        }
+        if (m.mm_per_second_sq.has_value()) {
+            motor_state(m.motor_id).accel_mm_per_sec_sq =
+                m.mm_per_second_sq.value();
+        }
+        if (m.mm_per_second_discont.has_value()) {
+            motor_state(m.motor_id).speed_mm_per_sec_discont =
+                m.mm_per_second_discont.value();
+        }
         controller_from_id(m.motor_id)
-            .start_fixed_movement(m.id, direction, std::abs(m.mm * s_per_m),
-                                  m.mm_per_second_discont * s_per_m,
-                                  m.mm_per_second * s_per_m,
-                                  m.mm_per_second_sq * s_per_m * s_per_m);
+            .start_fixed_movement(
+                m.id, direction,
+                motor_state(m.motor_id).get_distance(std::abs(m.mm)),
+                motor_state(m.motor_id).get_speed_discont(),
+                motor_state(m.motor_id).get_speed(),
+                motor_state(m.motor_id).get_accel());
     }
 
     template <MotorControlPolicy Policy>
     auto visit_message(const messages::MoveToLimitSwitchMessage& m,
                        Policy& policy) -> void {
         static_cast<void>(policy);
-        auto s_per_m = steps_per_mm(m.motor_id);
+        if (m.mm_per_second.has_value()) {
+            motor_state(m.motor_id).speed_mm_per_sec = m.mm_per_second.value();
+        }
+        if (m.mm_per_second_sq.has_value()) {
+            motor_state(m.motor_id).accel_mm_per_sec_sq =
+                m.mm_per_second_sq.value();
+        }
+        if (m.mm_per_second_discont.has_value()) {
+            motor_state(m.motor_id).speed_mm_per_sec_discont =
+                m.mm_per_second_discont.value();
+        }
         controller_from_id(m.motor_id)
             .start_movement(m.id, m.direction,
-                            m.mm_per_second_discont * s_per_m,
-                            m.mm_per_second * s_per_m,
-                            m.mm_per_second_sq * s_per_m * s_per_m);
+                            motor_state(m.motor_id).get_speed_discont(),
+                            motor_state(m.motor_id).get_speed(),
+                            motor_state(m.motor_id).get_accel());
     }
 
     template <MotorControlPolicy Policy>
@@ -229,12 +291,82 @@ class MotorTask {
             response, Queues::HostCommsAddress));
     }
 
+    template <MotorControlPolicy Policy>
+    auto visit_message(const messages::SetMicrostepsMessage& m, Policy& policy)
+        -> void {
+        static_cast<void>(policy);
+        // sent from the driver task so we know we've written to driver
+        // successfully
+        switch (m.motor_id) {
+            case MotorID::MOTOR_X:
+                _x_mech_conf.microstep =
+                    static_cast<float>(pow(2, m.microsteps_power));
+                _x_state.steps_per_mm = _x_mech_conf.get_usteps_per_mm();
+                break;
+            case MotorID::MOTOR_Z:
+                _z_mech_conf.microstep =
+                    static_cast<float>(pow(2, m.microsteps_power));
+                _z_state.steps_per_mm = _z_mech_conf.get_usteps_per_mm();
+                break;
+            case MotorID::MOTOR_L:
+                _l_mech_conf.microstep =
+                    static_cast<float>(pow(2, m.microsteps_power));
+                _l_state.steps_per_mm = _l_mech_conf.get_usteps_per_mm();
+                break;
+            default:
+                break;
+        }
+        auto response = messages::AcknowledgePrevious{.responding_to_id = m.id};
+        static_cast<void>(_task_registry->send_to_address(
+            response, Queues::HostCommsAddress));
+    }
+
+    template <MotorControlPolicy Policy>
+    auto visit_message(const messages::GetMoveParamsMessage& m, Policy& policy)
+        -> void {
+        static_cast<void>(policy);
+        auto response = messages::GetMoveParamsResponse{
+            .responding_to_id = m.id,
+            .motor_id = m.motor_id,
+            .velocity = motor_state(m.motor_id).speed_mm_per_sec,
+            .acceleration = motor_state(m.motor_id).accel_mm_per_sec_sq,
+            .velocity_discont =
+                motor_state(m.motor_id).speed_mm_per_sec_discont,
+        };
+        static_cast<void>(_task_registry->send_to_address(
+            response, Queues::HostCommsAddress));
+    }
+
     Queue& _message_queue;
     Aggregator* _task_registry;
     Controller& _x_controller;
     Controller& _z_controller;
     Controller& _l_controller;
     bool _initialized;
+    lms::LinearMotionSystemConfig<lms::LeadScrewConfig> _x_mech_conf =
+        motor_x_config;
+    lms::LinearMotionSystemConfig<lms::LeadScrewConfig> _z_mech_conf =
+        motor_z_config;
+    lms::LinearMotionSystemConfig<lms::GearBoxConfig> _l_mech_conf =
+        motor_l_config;
+    MotorState _x_state{
+        .steps_per_mm = motor_x_config.get_usteps_per_mm(),
+        .speed_mm_per_sec = XState::DEFAULT_SPEED,
+        .accel_mm_per_sec_sq = XState::DEFAULT_SPEED,
+        .speed_mm_per_sec_discont = XState::DEFAULT_SPEED_DISCONT,
+    };
+    MotorState _z_state{
+        .steps_per_mm = motor_z_config.get_usteps_per_mm(),
+        .speed_mm_per_sec = XState::DEFAULT_SPEED,
+        .accel_mm_per_sec_sq = XState::DEFAULT_SPEED,
+        .speed_mm_per_sec_discont = XState::DEFAULT_SPEED_DISCONT,
+    };
+    MotorState _l_state{
+        .steps_per_mm = motor_l_config.get_usteps_per_mm(),
+        .speed_mm_per_sec = LState::DEFAULT_SPEED,
+        .accel_mm_per_sec_sq = LState::DEFAULT_SPEED,
+        .speed_mm_per_sec_discont = LState::DEFAULT_SPEED_DISCONT,
+    };
 };
 
 };  // namespace motor_task
diff --git a/stm32-modules/include/flex-stacker/flex-stacker/tmc2160.hpp b/stm32-modules/include/flex-stacker/flex-stacker/tmc2160.hpp
index c1a29d9b..7e8f80bb 100644
--- a/stm32-modules/include/flex-stacker/flex-stacker/tmc2160.hpp
+++ b/stm32-modules/include/flex-stacker/flex-stacker/tmc2160.hpp
@@ -82,6 +82,14 @@ class TMC2160 {
                             motor_id);
     }
 
+    template <tmc2160::TMC2160InterfacePolicy Policy>
+    auto update_chopconf(const TMC2160RegisterMap& registers,
+                         tmc2160::TMC2160Interface<Policy>& policy,
+                         MotorID motor_id) -> bool {
+        return set_register(verify_chopconf(registers.chopconf), policy,
+                            motor_id);
+    }
+
     static auto verify_gconf(GConfig reg) -> GConfig {
         reg.test_mode = 0;
         return reg;