Apply const_float_t for AVR

Marlin/src/HAL/AVR/fastio.cpp

@@ -241,7 +241,7 @@ uint8_t extDigitalRead(const int8_t pin) {
  *
  * DC values -1.0 to 1.0. Negative duty cycle inverts the pulse.
  */
-uint16_t set_pwm_frequency_hz(const_float_t hz, const float dca, const float dcb, const float dcc) {
+uint16_t set_pwm_frequency_hz(const_float_t hz, const_float_t dca, const_float_t dcb, const_float_t dcc) {
   float count = 0;
   if (hz > 0 && (dca || dcb || dcc)) {
     count = float(F_CPU) / hz;            // 1x prescaler, TOP for 16MHz base freq.

Marlin/src/feature/backlash.cpp

@@ -181,13 +181,13 @@ class Backlash::StepAdjuster {
     correction = v;
   }
 
-  void Backlash::set_distance_mm(const AxisEnum axis, const float v) {
+  void Backlash::set_distance_mm(const AxisEnum axis, const_float_t v) {
     StepAdjuster adjuster;
     distance_mm[axis] = v;
   }
 
   #ifdef BACKLASH_SMOOTHING_MM
-    void Backlash::set_smoothing_mm(const float v) {
+    void Backlash::set_smoothing_mm(const_float_t v) {
       StepAdjuster adjuster;
       smoothing_mm = v;
     }

Marlin/src/feature/backlash.h

@@ -78,12 +78,12 @@ class Backlash {
   #if ENABLED(BACKLASH_GCODE)
     static void set_correction_uint8(const uint8_t v);
     static uint8_t get_correction_uint8() { return correction; }
-    static void set_correction(const float v) { set_correction_uint8(_MAX(0, _MIN(1.0, v)) * all_on + 0.5f); }
+    static void set_correction(const_float_t v) { set_correction_uint8(_MAX(0, _MIN(1.0, v)) * all_on + 0.5f); }
     static float get_correction() { return float(get_correction_uint8()) / all_on; }
-    static void set_distance_mm(const AxisEnum axis, const float v);
+    static void set_distance_mm(const AxisEnum axis, const_float_t v);
     static float get_distance_mm(const AxisEnum axis) {return distance_mm[axis];}
     #ifdef BACKLASH_SMOOTHING_MM
-      static void set_smoothing_mm(const float v);
+      static void set_smoothing_mm(const_float_t v);
       static float get_smoothing_mm() {return smoothing_mm;}
     #endif
   #endif

Marlin/src/feature/bedlevel/abl/bbl.cpp

@@ -220,7 +220,7 @@ void LevelingBilinear::print_leveling_grid(const bed_mesh_t* _z_values/*=nullptr
     return z_values[x - 1][y - 1];
   }
 
-  float LevelingBilinear::virt_cmr(const float p[4], const uint8_t i, const float t) {
+  float LevelingBilinear::virt_cmr(const float p[4], const uint8_t i, const_float_t t) {
     return (
         p[i-1] * -t * sq(1 - t)
       + p[i]   * (2 - 5 * sq(t) + 3 * t * sq(t))

Marlin/src/feature/bedlevel/abl/bbl.h

@@ -44,7 +44,7 @@ class LevelingBilinear {
     static xy_float_t grid_factor_virt;
 
     static float virt_coord(const uint8_t x, const uint8_t y);
-    static float virt_cmr(const float p[4], const uint8_t i, const float t);
+    static float virt_cmr(const float p[4], const uint8_t i, const_float_t t);
     static float virt_2cmr(const uint8_t x, const uint8_t y, const_float_t tx, const_float_t ty);
     static void subdivide_mesh();
   #endif

Marlin/src/feature/digipot/digipot.h

@@ -27,7 +27,7 @@
 class DigipotI2C {
 public:
   static void init();
-  static void set_current(const uint8_t channel, const float current);
+  static void set_current(const uint8_t channel, const_float_t current);
 };
 
 extern DigipotI2C digipot_i2c;

Marlin/src/feature/digipot/digipot_mcp4018.cpp

@@ -44,7 +44,7 @@
 #define DIGIPOT_A4988_FACTOR            ((DIGIPOT_MCP4018_MAX_VALUE) / DIGIPOT_A4988_Itripmax(DIGIPOT_A4988_Vrefmax))
 #define DIGIPOT_A4988_MAX_CURRENT       2.0
 
-static byte current_to_wiper(const float current) {
+static byte current_to_wiper(const_float_t current) {
   const int16_t value = TERN(DIGIPOT_USE_RAW_VALUES, current, CEIL(current * DIGIPOT_A4988_FACTOR));
   return byte(constrain(value, 0, DIGIPOT_MCP4018_MAX_VALUE));
 }
@@ -83,7 +83,7 @@ static void digipot_i2c_send(const uint8_t channel, const byte v) {
 }
 
 // This is for the MCP4018 I2C based digipot
-void DigipotI2C::set_current(const uint8_t channel, const float current) {
+void DigipotI2C::set_current(const uint8_t channel, const_float_t current) {
   const float ival = _MIN(_MAX(current, 0), float(DIGIPOT_MCP4018_MAX_VALUE));
   digipot_i2c_send(channel, current_to_wiper(ival));
 }

Marlin/src/feature/digipot/digipot_mcp4451.cpp

@@ -48,7 +48,7 @@
   #define DIGIPOT_I2C_MAX_CURRENT   2.5f
 #endif
 
-static byte current_to_wiper(const float current) {
+static byte current_to_wiper(const_float_t current) {
   return byte(TERN(DIGIPOT_USE_RAW_VALUES, current, CEIL(DIGIPOT_I2C_FACTOR * current)));
 }
 
@@ -66,7 +66,7 @@ static void digipot_i2c_send(const byte addr, const byte a, const byte b) {
 }
 
 // This is for the MCP4451 I2C based digipot
-void DigipotI2C::set_current(const uint8_t channel, const float current) {
+void DigipotI2C::set_current(const uint8_t channel, const_float_t current) {
   // These addresses are specific to Azteeg X3 Pro, can be set to others.
   // In this case first digipot is at address A0=0, A1=0, second one is at A0=0, A1=1
   const byte addr = channel < 4 ? DIGIPOT_I2C_ADDRESS_A : DIGIPOT_I2C_ADDRESS_B; // channel 0-3 vs 4-7

Marlin/src/feature/encoder_i2c.h

@@ -277,7 +277,7 @@ class I2CPositionEncodersMgr {
       SERIAL_ECHO_TERNARY(encoders[idx].get_ec_enabled(), " axis is ", "en", "dis", "abled.\n");
     }
 
-    static void set_ec_threshold(const int8_t idx, const float newThreshold, const AxisEnum axis) {
+    static void set_ec_threshold(const int8_t idx, const_float_t newThreshold, const AxisEnum axis) {
       CHECK_IDX();
       encoders[idx].set_ec_threshold(newThreshold);
       SERIAL_ECHOLNPGM("Error correct threshold for ", AS_CHAR(AXIS_CHAR(axis)), " axis set to ", newThreshold, "mm.");

Marlin/src/feature/mixing.h

@@ -94,7 +94,7 @@ class Mixer {
   static void refresh_collector(const float proportion=1.0, const uint8_t t=selected_vtool, float (&c)[MIXING_STEPPERS]=collector);
 
   // Used up to Planner level
-  FORCE_INLINE static void set_collector(const uint8_t c, const float f) { collector[c] = _MAX(f, 0.0f); }
+  FORCE_INLINE static void set_collector(const uint8_t c, const_float_t f) { collector[c] = _MAX(f, 0.0f); }
 
   static void normalize(const uint8_t tool_index);
   FORCE_INLINE static void normalize() { normalize(selected_vtool); }

Marlin/src/feature/pause.cpp

@@ -180,9 +180,7 @@ static bool ensure_safe_temperature(const bool wait=true, const PauseMode mode=P
  * Returns 'true' if load was completed, 'false' for abort
  */
 bool load_filament(const_float_t slow_load_length/*=0*/, const_float_t fast_load_length/*=0*/, const_float_t purge_length/*=0*/, const int8_t max_beep_count/*=0*/,
-                   const bool show_lcd/*=false*/, const bool pause_for_user/*=false*/,
-                   const PauseMode mode/*=PAUSE_MODE_PAUSE_PRINT*/
-                   DXC_ARGS
+  const bool show_lcd/*=false*/, const bool pause_for_user/*=false*/, const PauseMode mode/*=PAUSE_MODE_PAUSE_PRINT*/ DXC_ARGS
 ) {
   DEBUG_SECTION(lf, "load_filament", true);
   DEBUG_ECHOLNPGM("... slowlen:", slow_load_length, " fastlen:", fast_load_length, " purgelen:", purge_length, " maxbeep:", max_beep_count, " showlcd:", show_lcd, " pauseforuser:", pause_for_user, " pausemode:", mode DXC_SAY);

Marlin/src/feature/pause.h

@@ -118,7 +118,7 @@ bool unload_filament(
   const bool      show_lcd=false,                             // Set LCD status messages?
   const PauseMode mode=PAUSE_MODE_PAUSE_PRINT                 // Pause Mode to apply
   #if BOTH(FILAMENT_UNLOAD_ALL_EXTRUDERS, MIXING_EXTRUDER)
-    , const_float_t mix_multiplier=1.0f                       // Extrusion multiplier (for a Mixing Extruder)
+    , const float mix_multiplier=1.0f                       // Extrusion multiplier (for a Mixing Extruder)
   #endif
 );
 

Marlin/src/feature/tmc_util.h

@@ -85,24 +85,24 @@ class TMCStorage {
 template<class TMC, char AXIS_LETTER, char DRIVER_ID, AxisEnum AXIS_ID>
 class TMCMarlin : public TMC, public TMCStorage<AXIS_LETTER, DRIVER_ID> {
   public:
-    TMCMarlin(const uint16_t cs_pin, const float RS) :
+    TMCMarlin(const uint16_t cs_pin, const_float_t RS) :
       TMC(cs_pin, RS)
       {}
-    TMCMarlin(const uint16_t cs_pin, const float RS, const uint8_t axis_chain_index) :
+    TMCMarlin(const uint16_t cs_pin, const_float_t RS, const uint8_t axis_chain_index) :
       TMC(cs_pin, RS, axis_chain_index)
       {}
-    TMCMarlin(const uint16_t CS, const float RS, const uint16_t pinMOSI, const uint16_t pinMISO, const uint16_t pinSCK) :
+    TMCMarlin(const uint16_t CS, const_float_t RS, const uint16_t pinMOSI, const uint16_t pinMISO, const uint16_t pinSCK) :
       TMC(CS, RS, pinMOSI, pinMISO, pinSCK)
       {}
-    TMCMarlin(const uint16_t CS, const float RS, const uint16_t pinMOSI, const uint16_t pinMISO, const uint16_t pinSCK, const uint8_t axis_chain_index) :
+    TMCMarlin(const uint16_t CS, const_float_t RS, const uint16_t pinMOSI, const uint16_t pinMISO, const uint16_t pinSCK, const uint8_t axis_chain_index) :
       TMC(CS, RS, pinMOSI, pinMISO, pinSCK,  axis_chain_index)
       {}
     uint16_t rms_current() { return TMC::rms_current(); }
     void rms_current(uint16_t mA) {
       this->val_mA = mA;
       TMC::rms_current(mA);
     }
-    void rms_current(const uint16_t mA, const float mult) {
+    void rms_current(const uint16_t mA, const_float_t mult) {
       this->val_mA = mA;
       TMC::rms_current(mA, mult);
     }
@@ -162,13 +162,13 @@ class TMCMarlin : public TMC, public TMCStorage<AXIS_LETTER, DRIVER_ID> {
 template<char AXIS_LETTER, char DRIVER_ID, AxisEnum AXIS_ID>
 class TMCMarlin<TMC2208Stepper, AXIS_LETTER, DRIVER_ID, AXIS_ID> : public TMC2208Stepper, public TMCStorage<AXIS_LETTER, DRIVER_ID> {
   public:
-    TMCMarlin(Stream * SerialPort, const float RS, const uint8_t) :
+    TMCMarlin(Stream * SerialPort, const_float_t RS, const uint8_t) :
       TMC2208Stepper(SerialPort, RS)
       {}
-    TMCMarlin(Stream * SerialPort, const float RS, uint8_t addr, const uint16_t mul_pin1, const uint16_t mul_pin2) :
+    TMCMarlin(Stream * SerialPort, const_float_t RS, uint8_t addr, const uint16_t mul_pin1, const uint16_t mul_pin2) :
       TMC2208Stepper(SerialPort, RS, addr, mul_pin1, mul_pin2)
      {}
-    TMCMarlin(const uint16_t RX, const uint16_t TX, const float RS, const uint8_t) :
+    TMCMarlin(const uint16_t RX, const uint16_t TX, const_float_t RS, const uint8_t) :
       TMC2208Stepper(RX, TX, RS)
       {}
 
@@ -177,7 +177,7 @@ class TMCMarlin<TMC2208Stepper, AXIS_LETTER, DRIVER_ID, AXIS_ID> : public TMC220
       this->val_mA = mA;
       TMC2208Stepper::rms_current(mA);
     }
-    void rms_current(const uint16_t mA, const float mult) {
+    void rms_current(const uint16_t mA, const_float_t mult) {
       this->val_mA = mA;
       TMC2208Stepper::rms_current(mA, mult);
     }
@@ -219,10 +219,10 @@ class TMCMarlin<TMC2208Stepper, AXIS_LETTER, DRIVER_ID, AXIS_ID> : public TMC220
 template<char AXIS_LETTER, char DRIVER_ID, AxisEnum AXIS_ID>
 class TMCMarlin<TMC2209Stepper, AXIS_LETTER, DRIVER_ID, AXIS_ID> : public TMC2209Stepper, public TMCStorage<AXIS_LETTER, DRIVER_ID> {
   public:
-    TMCMarlin(Stream * SerialPort, const float RS, const uint8_t addr) :
+    TMCMarlin(Stream * SerialPort, const_float_t RS, const uint8_t addr) :
       TMC2209Stepper(SerialPort, RS, addr)
       {}
-    TMCMarlin(const uint16_t RX, const uint16_t TX, const float RS, const uint8_t addr) :
+    TMCMarlin(const uint16_t RX, const uint16_t TX, const_float_t RS, const uint8_t addr) :
       TMC2209Stepper(RX, TX, RS, addr)
       {}
     uint8_t get_address() { return slave_address; }
@@ -231,7 +231,7 @@ class TMCMarlin<TMC2209Stepper, AXIS_LETTER, DRIVER_ID, AXIS_ID> : public TMC220
       this->val_mA = mA;
       TMC2209Stepper::rms_current(mA);
     }
-    void rms_current(const uint16_t mA, const float mult) {
+    void rms_current(const uint16_t mA, const_float_t mult) {
       this->val_mA = mA;
       TMC2209Stepper::rms_current(mA, mult);
     }
@@ -287,10 +287,10 @@ class TMCMarlin<TMC2209Stepper, AXIS_LETTER, DRIVER_ID, AXIS_ID> : public TMC220
 template<char AXIS_LETTER, char DRIVER_ID, AxisEnum AXIS_ID>
 class TMCMarlin<TMC2660Stepper, AXIS_LETTER, DRIVER_ID, AXIS_ID> : public TMC2660Stepper, public TMCStorage<AXIS_LETTER, DRIVER_ID> {
   public:
-    TMCMarlin(const uint16_t cs_pin, const float RS, const uint8_t) :
+    TMCMarlin(const uint16_t cs_pin, const_float_t RS, const uint8_t) :
       TMC2660Stepper(cs_pin, RS)
       {}
-    TMCMarlin(const uint16_t CS, const float RS, const uint16_t pinMOSI, const uint16_t pinMISO, const uint16_t pinSCK, const uint8_t) :
+    TMCMarlin(const uint16_t CS, const_float_t RS, const uint16_t pinMOSI, const uint16_t pinMISO, const uint16_t pinSCK, const uint8_t) :
       TMC2660Stepper(CS, RS, pinMOSI, pinMISO, pinSCK)
       {}
     uint16_t rms_current() { return TMC2660Stepper::rms_current(); }

Marlin/src/gcode/calibrate/G33.cpp

@@ -180,7 +180,7 @@ static float calibration_probe(const xy_pos_t &xy, const bool stow, const bool p
 /**
  *  - Probe a grid
  */
-static bool probe_calibration_points(float z_pt[NPP + 1], const int8_t probe_points, const float dcr, const bool towers_set, const bool stow_after_each, const bool probe_at_offset) {
+static bool probe_calibration_points(float z_pt[NPP + 1], const int8_t probe_points, const_float_t dcr, const bool towers_set, const bool stow_after_each, const bool probe_at_offset) {
   const bool _0p_calibration      = probe_points == 0,
              _1p_calibration      = probe_points == 1 || probe_points == -1,
              _4p_calibration      = probe_points == 2,
@@ -264,7 +264,7 @@ static bool probe_calibration_points(float z_pt[NPP + 1], const int8_t probe_poi
  *  - formulae for approximative forward kinematics in the end-stop displacement matrix
  *  - definition of the matrix scaling parameters
  */
-static void reverse_kinematics_probe_points(float z_pt[NPP + 1], abc_float_t mm_at_pt_axis[NPP + 1], const float dcr) {
+static void reverse_kinematics_probe_points(float z_pt[NPP + 1], abc_float_t mm_at_pt_axis[NPP + 1], const_float_t dcr) {
   xyz_pos_t pos{0};
 
   LOOP_CAL_ALL(rad) {
@@ -276,7 +276,7 @@ static void reverse_kinematics_probe_points(float z_pt[NPP + 1], abc_float_t mm_
   }
 }
 
-static void forward_kinematics_probe_points(abc_float_t mm_at_pt_axis[NPP + 1], float z_pt[NPP + 1], const float dcr) {
+static void forward_kinematics_probe_points(abc_float_t mm_at_pt_axis[NPP + 1], float z_pt[NPP + 1], const_float_t dcr) {
   const float r_quot = dcr / delta_radius;
 
   #define ZPP(N,I,A) (((1.0f + r_quot * (N)) / 3.0f) * mm_at_pt_axis[I].A)
@@ -295,7 +295,7 @@ static void forward_kinematics_probe_points(abc_float_t mm_at_pt_axis[NPP + 1],
   z_pt[_AB] = Zp1(_AB, a) + Zp1(_AB, b) + Zm2(_AB, c);
 }
 
-static void calc_kinematics_diff_probe_points(float z_pt[NPP + 1], const float dcr, abc_float_t delta_e, const float delta_r, abc_float_t delta_t) {
+static void calc_kinematics_diff_probe_points(float z_pt[NPP + 1], const_float_t dcr, abc_float_t delta_e, const_float_t delta_r, abc_float_t delta_t) {
   const float z_center = z_pt[CEN];
   abc_float_t diff_mm_at_pt_axis[NPP + 1], new_mm_at_pt_axis[NPP + 1];
 
@@ -317,12 +317,12 @@ static void calc_kinematics_diff_probe_points(float z_pt[NPP + 1], const float d
   recalc_delta_settings();
 }
 
-static float auto_tune_h(const float dcr) {
+static float auto_tune_h(const_float_t dcr) {
   const float r_quot = dcr / delta_radius;
   return RECIPROCAL(r_quot / (2.0f / 3.0f));  // (2/3)/CR
 }
 
-static float auto_tune_r(const float dcr) {
+static float auto_tune_r(const_float_t dcr) {
   constexpr float diff = 0.01f, delta_r = diff;
   float r_fac = 0.0f, z_pt[NPP + 1] = { 0.0f };
   abc_float_t delta_e = { 0.0f }, delta_t = { 0.0f };
@@ -333,7 +333,7 @@ static float auto_tune_r(const float dcr) {
   return r_fac;
 }
 
-static float auto_tune_a(const float dcr) {
+static float auto_tune_a(const_float_t dcr) {
   constexpr float diff = 0.01f, delta_r = 0.0f;
   float a_fac = 0.0f, z_pt[NPP + 1] = { 0.0f };
   abc_float_t delta_e = { 0.0f }, delta_t = { 0.0f };

Marlin/src/gcode/calibrate/G425.cpp

@@ -130,7 +130,7 @@ struct measurements_t {
   class restorer_smoothing {
     const float val_;
   public:
-    restorer_smoothing(const float temp_val) : val_(backlash.get_smoothing_mm()) { backlash.set_smoothing_mm(temp_val); }
+    restorer_smoothing(const_float_t temp_val) : val_(backlash.get_smoothing_mm()) { backlash.set_smoothing_mm(temp_val); }
     ~restorer_smoothing() { backlash.set_smoothing_mm(val_); }
   };
 
@@ -149,7 +149,7 @@ inline void calibration_move() {
  *   m                  in     - Measurement record
  *   uncertainty        in     - How far away from the object top to park
  */
-inline void park_above_object(measurements_t &m, const float uncertainty) {
+inline void park_above_object(measurements_t &m, const_float_t uncertainty) {
   // Move to safe distance above calibration object
   current_position.z = m.obj_center.z + dimensions.z / 2 + uncertainty;
   calibration_move();
@@ -226,7 +226,7 @@ float measuring_movement(const AxisEnum axis, const int dir, const bool stop_sta
  *   backlash_ptr       in/out - When not nullptr, measure and record axis backlash
  *   uncertainty        in     - If uncertainty is CALIBRATION_MEASUREMENT_UNKNOWN, do a fast probe.
  */
-inline float measure(const AxisEnum axis, const int dir, const bool stop_state, float * const backlash_ptr, const float uncertainty) {
+inline float measure(const AxisEnum axis, const int dir, const bool stop_state, float * const backlash_ptr, const_float_t uncertainty) {
   const bool fast = uncertainty == CALIBRATION_MEASUREMENT_UNKNOWN;
 
   // Save the current position of the specified axis
@@ -257,7 +257,7 @@ inline float measure(const AxisEnum axis, const int dir, const bool stop_state,
  *   probe_top_at_edge  in     - When probing sides, probe top of calibration object nearest edge
  *                               to find out height of edge
  */
-inline void probe_side(measurements_t &m, const float uncertainty, const side_t side, const bool probe_top_at_edge=false) {
+inline void probe_side(measurements_t &m, const_float_t uncertainty, const side_t side, const bool probe_top_at_edge=false) {
   const xyz_float_t dimensions = CALIBRATION_OBJECT_DIMENSIONS;
   AxisEnum axis;
   float dir = 1;
@@ -333,7 +333,7 @@ inline void probe_side(measurements_t &m, const float uncertainty, const side_t
  *   m                  in/out - Measurement record: center, backlash and error values be updated.
  *   uncertainty        in     - How far away from the calibration object to begin probing
  */
-inline void probe_sides(measurements_t &m, const float uncertainty) {
+inline void probe_sides(measurements_t &m, const_float_t uncertainty) {
   #if ENABLED(CALIBRATION_MEASURE_AT_TOP_EDGES)
     constexpr bool probe_top_at_edge = true;
   #else
@@ -629,7 +629,7 @@ inline void probe_sides(measurements_t &m, const float uncertainty) {
  *   m              in/out - Measurement record, updated with new readings
  *   uncertainty    in     - How far away from the object to begin probing
  */
-inline void calibrate_backlash(measurements_t &m, const float uncertainty) {
+inline void calibrate_backlash(measurements_t &m, const_float_t uncertainty) {
   // Backlash compensation should be off while measuring backlash
 
   {
@@ -745,7 +745,7 @@ inline void update_measurements(measurements_t &m, const AxisEnum axis) {
  * Prerequisites:
  *    - Call calibrate_backlash() beforehand for best accuracy
  */
-inline void calibrate_toolhead(measurements_t &m, const float uncertainty, const uint8_t extruder) {
+inline void calibrate_toolhead(measurements_t &m, const_float_t uncertainty, const uint8_t extruder) {
   TEMPORARY_BACKLASH_CORRECTION(backlash.all_on);
   TEMPORARY_BACKLASH_SMOOTHING(0.0f);
 
@@ -785,7 +785,7 @@ inline void calibrate_toolhead(measurements_t &m, const float uncertainty, const
  *   m              in/out - Measurement record, updated with new readings
  *   uncertainty    in     - How far away from the object to begin probing
  */
-inline void calibrate_all_toolheads(measurements_t &m, const float uncertainty) {
+inline void calibrate_all_toolheads(measurements_t &m, const_float_t uncertainty) {
   TEMPORARY_BACKLASH_CORRECTION(backlash.all_on);
   TEMPORARY_BACKLASH_SMOOTHING(0.0f);
 

Marlin/src/gcode/feature/camera/M240.cpp

@@ -47,7 +47,7 @@
   #endif
 
   #ifdef PHOTO_RETRACT_MM
-    inline void e_move_m240(const float length, const_feedRate_t fr_mm_s) {
+    inline void e_move_m240(const_float_t length, const_feedRate_t fr_mm_s) {
       if (length && thermalManager.hotEnoughToExtrude(active_extruder))
         unscaled_e_move(length, fr_mm_s);
     }