♻️ Motion encapsulation

Author: thinkyhead

Marlin/src/MarlinCore.cpp

@@ -361,7 +361,7 @@ void startOrResumeJob() {
   if (!printingIsPaused()) {
     TERN_(GCODE_REPEAT_MARKERS, repeat.reset());
     TERN_(CANCEL_OBJECTS, cancelable.reset());
-    TERN_(LCD_SHOW_E_TOTAL, e_move_accumulator = 0);
+    TERN_(LCD_SHOW_E_TOTAL, motion.e_move_accumulator = 0);
     TERN_(SET_REMAINING_TIME, ui.reset_remaining_time());
     TERN_(HAS_PRUSA_MMU3, MMU3::operation_statistics.reset_per_print_stats());
   }
@@ -375,7 +375,7 @@ void startOrResumeJob() {
     card.abortFilePrintNow(TERN_(SD_RESORT, true));
 
     queue.clear();
-    quickstop_stepper();
+    motion.quickstop_stepper();
 
     print_job_timer.abort();
 
@@ -686,18 +686,18 @@ inline void manage_inactivity(const bool no_stepper_sleep=false) {
   #endif
 
   #if ENABLED(EXTRUDER_RUNOUT_PREVENT)
-    if (thermalManager.degHotend(active_extruder) > (EXTRUDER_RUNOUT_MINTEMP)
+    if (thermalManager.degHotend(motion.extruder) > (EXTRUDER_RUNOUT_MINTEMP)
       && ELAPSED(ms, gcode.previous_move_ms, SEC_TO_MS(EXTRUDER_RUNOUT_SECONDS))
       && !planner.has_blocks_queued()
     ) {
-      const int8_t e_stepper = TERN(HAS_SWITCHING_EXTRUDER, active_extruder >> 1, active_extruder);
+      const int8_t e_stepper = TERN(HAS_SWITCHING_EXTRUDER, motion.extruder >> 1, motion.extruder);
       const bool e_off = !stepper.AXIS_IS_ENABLED(E_AXIS, e_stepper);
       if (e_off) stepper.ENABLE_EXTRUDER(e_stepper);
 
-      const float olde = current_position.e;
-      current_position.e += EXTRUDER_RUNOUT_EXTRUDE;
-      line_to_current_position(MMM_TO_MMS(EXTRUDER_RUNOUT_SPEED));
-      current_position.e = olde;
+      const float olde = motion.position.e;
+      motion.position.e += EXTRUDER_RUNOUT_EXTRUDE;
+      motion.line_to_current_position(MMM_TO_MMS(EXTRUDER_RUNOUT_SPEED));
+      motion.position.e = olde;
       planner.set_e_position_mm(olde);
       planner.synchronize();
 
@@ -712,8 +712,8 @@ inline void manage_inactivity(const bool no_stepper_sleep=false) {
     if (delayed_move_time && ELAPSED(ms, delayed_move_time) && IsRunning()) {
       // travel moves have been received so enact them
       delayed_move_time = 0xFFFFFFFFUL; // force moves to be done
-      destination = current_position;
-      prepare_line_to_destination();
+      motion.destination = motion.position;
+      motion.prepare_line_to_destination();
       planner.synchronize();
     }
   #endif
@@ -792,7 +792,7 @@ void idle(const bool no_stepper_sleep/*=false*/) {
   if (marlin_state == MarlinState::MF_INITIALIZING) goto IDLE_DONE;
 
   // TODO: Still causing errors
-  TERN_(TOOL_SENSOR, (void)check_tool_sensor_stats(active_extruder, true));
+  TERN_(TOOL_SENSOR, (void)check_tool_sensor_stats(motion.extruder, true));
 
   // Handle filament runout sensors
   #if HAS_FILAMENT_SENSOR
@@ -856,7 +856,7 @@ void idle(const bool no_stepper_sleep/*=false*/) {
       TERN_(AUTO_REPORT_TEMPERATURES, thermalManager.auto_reporter.tick());
       TERN_(AUTO_REPORT_FANS, fan_check.auto_reporter.tick());
       TERN_(AUTO_REPORT_SD_STATUS, card.auto_reporter.tick());
-      TERN_(AUTO_REPORT_POSITION, position_auto_reporter.tick());
+      TERN_(AUTO_REPORT_POSITION, motion.position_auto_reporter.tick());
       TERN_(BUFFER_MONITORING, queue.auto_report_buffer_statistics());
     }
   #endif
@@ -1385,9 +1385,9 @@ void setup() {
     SETUP_RUN(touchBt.init());
   #endif
 
-  TERN_(HAS_HOME_OFFSET, current_position += home_offset); // Init current position based on home_offset
+  TERN_(HAS_HOME_OFFSET, motion.position += motion.home_offset); // Init current position based on home_offset
 
-  sync_plan_position();               // Vital to init stepper/planner equivalent for current_position
+  motion.sync_plan_position();        // Vital to init stepper/planner equivalent for motion.position
 
   SETUP_RUN(thermalManager.init());   // Initialize temperature loop
 

Marlin/src/core/debug_section.h

@@ -41,6 +41,6 @@ class SectionLog {
     SERIAL_ECHO(fpre);
     if (the_msg) SERIAL_ECHO(C(' '), the_msg);
     SERIAL_CHAR(' ');
-    print_xyz(xyz_pos_t(current_position));
+    print_xyz(xyz_pos_t(motion.position));
   }
 };

Marlin/src/core/utility.cpp

@@ -143,19 +143,19 @@ void safe_delay(millis_t ms) {
           SERIAL_ECHOPGM("ABL Adjustment");
           LOOP_NUM_AXES(a) {
             SERIAL_ECHOPGM_P((PGM_P)pgm_read_ptr(&SP_AXIS_STR[a]));
-            serial_offset(planner.get_axis_position_mm((AxisEnum)a) - current_position[a]);
+            serial_offset(planner.get_axis_position_mm((AxisEnum)a) - motion.position[a]);
           }
         #else
           #if ENABLED(AUTO_BED_LEVELING_UBL)
             SERIAL_ECHOPGM("UBL Adjustment Z");
           #elif ENABLED(AUTO_BED_LEVELING_BILINEAR)
             SERIAL_ECHOPGM("ABL Adjustment Z");
           #endif
-          const float rz = bedlevel.get_z_correction(current_position);
+          const float rz = bedlevel.get_z_correction(motion.position);
           SERIAL_ECHO(ftostr43sign(rz, '+'));
           #if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
             if (planner.z_fade_height)
-              SERIAL_ECHO(F(" ("), ftostr43sign(rz * planner.fade_scaling_factor_for_z(current_position.z), '+'), C(')'));
+              SERIAL_ECHO(F(" ("), ftostr43sign(rz * planner.fade_scaling_factor_for_z(motion.position.z), '+'), C(')'));
           #endif
         #endif
       }
@@ -170,11 +170,11 @@ void safe_delay(millis_t ms) {
       if (planner.leveling_active) {
         SERIAL_ECHOLNPGM(" (enabled)");
         const float z_offset = bedlevel.get_z_offset(),
-                    z_correction = bedlevel.get_z_correction(current_position);
+                    z_correction = bedlevel.get_z_correction(motion.position);
         SERIAL_ECHOPGM("MBL Adjustment Z", ftostr43sign(z_offset + z_correction, '+'));
         #if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
           if (planner.z_fade_height) {
-            SERIAL_ECHO(F(" ("), ftostr43sign(z_offset + z_correction * planner.fade_scaling_factor_for_z(current_position.z), '+'), C(')'));
+            SERIAL_ECHO(F(" ("), ftostr43sign(z_offset + z_correction * planner.fade_scaling_factor_for_z(motion.position.z), '+'), C(')'));
           }
         #endif
       }

Marlin/src/feature/babystep.cpp

@@ -60,7 +60,7 @@ void Babystep::add_mm(const AxisEnum axis, const float mm) {
 
 #if ENABLED(BD_SENSOR)
   void Babystep::set_mm(const AxisEnum axis, const float mm) {
-    //if (DISABLED(BABYSTEP_WITHOUT_HOMING) && axis_should_home(axis)) return;
+    //if (DISABLED(BABYSTEP_WITHOUT_HOMING) && motion.axis_should_home(axis)) return;
     const int16_t distance = mm * planner.settings.axis_steps_per_mm[axis];
     accum = distance; // Count up babysteps for the UI
     steps[BS_AXIS_IND(axis)] = distance;
@@ -71,7 +71,7 @@ void Babystep::add_mm(const AxisEnum axis, const float mm) {
 #endif
 
 bool Babystep::can_babystep(const AxisEnum axis) {
-  return (ENABLED(BABYSTEP_WITHOUT_HOMING) || !axis_should_home(axis));
+  return (ENABLED(BABYSTEP_WITHOUT_HOMING) || !motion.axis_should_home(axis));
 }
 
 void Babystep::add_steps(const AxisEnum axis, const int16_t distance) {

Marlin/src/feature/backlash.cpp

@@ -224,12 +224,12 @@ class Backlash::StepAdjuster {
   void Backlash::measure_with_probe() {
     if (measured_count.z == 255) return;
 
-    const float start_height = current_position.z;
-    while (current_position.z < (start_height + BACKLASH_MEASUREMENT_LIMIT) && PROBE_TRIGGERED())
-      do_blocking_move_to_z(current_position.z + BACKLASH_MEASUREMENT_RESOLUTION, MMM_TO_MMS(BACKLASH_MEASUREMENT_FEEDRATE));
+    const float start_height = motion.position.z;
+    while (motion.position.z < (start_height + BACKLASH_MEASUREMENT_LIMIT) && PROBE_TRIGGERED())
+      motion.blocking_move_z(motion.position.z + BACKLASH_MEASUREMENT_RESOLUTION, MMM_TO_MMS(BACKLASH_MEASUREMENT_FEEDRATE));
 
     // The backlash from all probe points is averaged, so count the number of measurements
-    measured_mm.z += current_position.z - start_height;
+    measured_mm.z += motion.position.z - start_height;
     measured_count.z++;
   }
 

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

@@ -371,21 +371,21 @@ float LevelingBilinear::get_z_correction(const xy_pos_t &raw) {
    */
   void LevelingBilinear::line_to_destination(const feedRate_t scaled_fr_mm_s, uint16_t x_splits, uint16_t y_splits) {
     // Get current and destination cells for this line
-    xy_int_t c1 { CELL_INDEX(x, current_position.x), CELL_INDEX(y, current_position.y) },
-             c2 { CELL_INDEX(x, destination.x), CELL_INDEX(y, destination.y) };
+    xy_int_t c1 { CELL_INDEX(x, motion.position.x), CELL_INDEX(y, motion.position.y) },
+             c2 { CELL_INDEX(x, motion.destination.x), CELL_INDEX(y, motion.destination.y) };
     LIMIT(c1.x, 0, ABL_BG_POINTS_X - 2);
     LIMIT(c1.y, 0, ABL_BG_POINTS_Y - 2);
     LIMIT(c2.x, 0, ABL_BG_POINTS_X - 2);
     LIMIT(c2.y, 0, ABL_BG_POINTS_Y - 2);
 
     // Start and end in the same cell? No split needed.
     if (c1 == c2) {
-      current_position = destination;
-      line_to_current_position(scaled_fr_mm_s);
+      motion.position = motion.destination;
+      motion.line_to_current_position(scaled_fr_mm_s);
       return;
     }
 
-    #define LINE_SEGMENT_END(A) (current_position.A + (destination.A - current_position.A) * normalized_dist)
+    #define LINE_SEGMENT_END(A) (motion.position.A + (motion.destination.A - motion.position.A) * normalized_dist)
 
     float normalized_dist;
     xyze_pos_t end;
@@ -396,36 +396,36 @@ float LevelingBilinear::get_z_correction(const xy_pos_t &raw) {
     if (c2.x != c1.x && TEST(x_splits, gc.x)) {
       // Split on the X grid line
       CBI(x_splits, gc.x);
-      end = destination;
-      destination.x = grid_start.x + ABL_BG_SPACING(x) * gc.x;
-      normalized_dist = (destination.x - current_position.x) / (end.x - current_position.x);
-      destination.y = LINE_SEGMENT_END(y);
+      end = motion.destination;
+      motion.destination.x = grid_start.x + ABL_BG_SPACING(x) * gc.x;
+      normalized_dist = (motion.destination.x - motion.position.x) / (end.x - motion.position.x);
+      motion.destination.y = LINE_SEGMENT_END(y);
     }
     // Crosses on the Y and not already split on this Y?
     else if (c2.y != c1.y && TEST(y_splits, gc.y)) {
       // Split on the Y grid line
       CBI(y_splits, gc.y);
-      end = destination;
-      destination.y = grid_start.y + ABL_BG_SPACING(y) * gc.y;
-      normalized_dist = (destination.y - current_position.y) / (end.y - current_position.y);
-      destination.x = LINE_SEGMENT_END(x);
+      end = motion.destination;
+      motion.destination.y = grid_start.y + ABL_BG_SPACING(y) * gc.y;
+      normalized_dist = (motion.destination.y - motion.position.y) / (end.y - motion.position.y);
+      motion.destination.x = LINE_SEGMENT_END(x);
     }
     else {
       // Must already have been split on these border(s)
       // This should be a rare case.
-      current_position = destination;
-      line_to_current_position(scaled_fr_mm_s);
+      motion.position = motion.destination;
+      motion.line_to_current_position(scaled_fr_mm_s);
       return;
     }
 
-    destination.z = LINE_SEGMENT_END(z);
-    destination.e = LINE_SEGMENT_END(e);
+    motion.destination.z = LINE_SEGMENT_END(z);
+    motion.destination.e = LINE_SEGMENT_END(e);
 
     // Do the split and look for more borders
     line_to_destination(scaled_fr_mm_s, x_splits, y_splits);
 
     // Restore destination from stack
-    destination = end;
+    motion.destination = end;
     line_to_destination(scaled_fr_mm_s, x_splits, y_splits);
   }
 

Marlin/src/feature/bedlevel/bdl/bdl.cpp

@@ -73,8 +73,8 @@ void BDS_Leveling::init(uint8_t _sda, uint8_t _scl, uint16_t delay_s) {
   config_state = BDS_IDLE;
   const int ret = BD_I2C_SENSOR.i2c_init(_sda, _scl, BD_SENSOR_I2C_ADDR, delay_s);
   if (ret != 1) SERIAL_ECHOLNPGM("BD Sensor Init Fail (", ret, ")");
-  sync_plan_position();
-  pos_zero_offset = planner.get_axis_position_mm(Z_AXIS) - current_position.z;
+  motion.sync_plan_position();
+  pos_zero_offset = planner.get_axis_position_mm(Z_AXIS) - motion.position.z;
   SERIAL_ECHOLNPGM("BD Sensor Zero Offset:", pos_zero_offset);
 }
 
@@ -120,27 +120,27 @@ void BDS_Leveling::process() {
 
     uint16_t tmp = 0;
     const float cur_z = planner.get_axis_position_mm(Z_AXIS) - pos_zero_offset;
-    static float old_cur_z = cur_z, old_buf_z = current_position.z;
+    static float old_cur_z = cur_z, old_buf_z = motion.position.z;
     tmp = BD_I2C_SENSOR.BD_i2c_read();
     if (BD_I2C_SENSOR.BD_Check_OddEven(tmp) && good_data(tmp)) {
       const float z_sensor = interpret(tmp);
       #if ENABLED(BABYSTEPPING)
         if (config_state > 0) {
           if (cur_z < config_state * 0.1f
             && old_cur_z == cur_z
-            && old_buf_z == current_position.z
+            && old_buf_z == motion.position.z
             && z_sensor < (MAX_BD_HEIGHT) - 0.1f
           ) {
             babystep.set_mm(Z_AXIS, cur_z - z_sensor);
-            DEBUG_ECHOLNPGM("BD:", z_sensor, ", Z:", cur_z, "|", current_position.z);
+            DEBUG_ECHOLNPGM("BD:", z_sensor, ", Z:", cur_z, "|", motion.position.z);
           }
           else
             babystep.set_mm(Z_AXIS, 0);
         }
       #endif
 
       old_cur_z = cur_z;
-      old_buf_z = current_position.z;
+      old_buf_z = motion.position.z;
       endstops.bdp_state_update(z_sensor <= BD_SENSOR_HOME_Z_POSITION);
 
       #if HAS_STATUS_MESSAGE
@@ -159,7 +159,7 @@ void BDS_Leveling::process() {
       kill(F("BDsensor connect Err!"));
     }
 
-    DEBUG_ECHOLNPGM("BD:", tmp & 0x3FF, " Z:", cur_z, "|", current_position.z);
+    DEBUG_ECHOLNPGM("BD:", tmp & 0x3FF, " Z:", cur_z, "|", motion.position.z);
     if (TERN0(DEBUG_OUT_BD, BD_I2C_SENSOR.BD_Check_OddEven(tmp) == 0)) DEBUG_ECHOLNPGM("CRC error");
 
     if (!good_data(tmp)) {
@@ -205,15 +205,15 @@ void BDS_Leveling::process() {
         SERIAL_ECHOLNPGM("c_z0:", planner.get_axis_position_mm(Z_AXIS), "-", pos_zero_offset);
 
         // Move the z axis instead of enabling the Z axis with M17
-        // TODO: Use do_blocking_move_to_z for synchronized move.
-        current_position.z = 0;
-        sync_plan_position();
+        // TODO: Use motion.blocking_move_z for synchronized move.
+        motion.position.z = 0;
+        motion.sync_plan_position();
         gcode.process_subcommands_now(F("G1Z0.05"));
         safe_delay(300);
         gcode.process_subcommands_now(F("G1Z0.00"));
         safe_delay(300);
-        current_position.z = 0;
-        sync_plan_position();
+        motion.position.z = 0;
+        motion.sync_plan_position();
         //safe_delay(1000);
 
         while ((planner.get_axis_position_mm(Z_AXIS) - pos_zero_offset) > 0.00001f) {
@@ -236,10 +236,10 @@ void BDS_Leveling::process() {
         }
         else {
           char tmp_1[32];
-          // TODO: Use prepare_internal_move_to_destination to guarantee machine space
+          // TODO: Use motion.prepare_internal_move_to_destination to guarantee machine space
           sprintf_P(tmp_1, PSTR("G1Z%d.%d"), int(zpos), int(zpos * 10) % 10);
           gcode.process_subcommands_now(tmp_1);
-          SERIAL_ECHO(tmp_1); SERIAL_ECHOLNPGM(", Z:", current_position.z);
+          SERIAL_ECHO(tmp_1); SERIAL_ECHOLNPGM(", Z:", motion.position.z);
           uint16_t failcount = 300;
           for (float tmp_k = 0; abs(zpos - tmp_k) > 0.006f && failcount--;) {
             tmp_k = planner.get_axis_position_mm(Z_AXIS) - pos_zero_offset;

Marlin/src/feature/bedlevel/bedlevel.cpp

@@ -66,21 +66,21 @@ void set_bed_leveling_enabled(const bool enable/*=true*/) {
     auto _report_leveling = []{
       if (DEBUGGING(LEVELING)) {
         if (planner.leveling_active)
-          DEBUG_POS("Leveling ON", current_position);
+          DEBUG_POS("Leveling ON", motion.position);
         else
-          DEBUG_POS("Leveling OFF", current_position);
+          DEBUG_POS("Leveling OFF", motion.position);
       }
     };
 
     _report_leveling();
     planner.synchronize();
 
     // Get the corrected leveled / unleveled position
-    planner.apply_modifiers(current_position, true);    // Physical position with all modifiers
-    FLIP(planner.leveling_active);                      // Toggle leveling between apply and unapply
-    planner.unapply_modifiers(current_position, true);  // Logical position with modifiers removed
+    planner.apply_modifiers(motion.position, true);   // Physical position with all modifiers
+    FLIP(planner.leveling_active);                    // Toggle leveling between apply and unapply
+    planner.unapply_modifiers(motion.position, true); // Logical position with modifiers removed
 
-    sync_plan_position();
+    motion.sync_plan_position();
     _report_leveling();
   }
 }
@@ -101,10 +101,10 @@ TemporaryBedLevelingState::TemporaryBedLevelingState(const bool enable) : saved(
     planner.set_z_fade_height(zfh);
 
     if (leveling_was_active) {
-      const xyz_pos_t oldpos = current_position;
+      const xyz_pos_t oldpos = motion.position;
       set_bed_leveling_enabled(true);
-      if (do_report && oldpos != current_position)
-        report_current_position();
+      if (do_report && oldpos != motion.position)
+        motion.report_position();
     }
   }
 
@@ -198,16 +198,16 @@ void reset_bed_level() {
     #else
       #warning "It's recommended to set some MANUAL_PROBE_START_Z value for manual leveling."
     #endif
-    #if Z_CLEARANCE_BETWEEN_MANUAL_PROBES > 0     // A probe/obstacle clearance exists so there is a raise:
+    #if Z_CLEARANCE_BETWEEN_MANUAL_PROBES > 0   // A probe/obstacle clearance exists so there is a raise:
       #ifndef MANUAL_PROBE_START_Z
-        const float finalz = current_position.z;  // - Use the current Z for starting-Z if no MANUAL_PROBE_START_Z was provided
+        const float finalz = motion.position.z; // - Use the current Z for starting-Z if no MANUAL_PROBE_START_Z was provided
       #endif
-      do_blocking_move_to_xy_z(pos, Z_CLEARANCE_BETWEEN_MANUAL_PROBES); // - Raise Z, then move to the new XY
-      do_blocking_move_to_z(finalz);              // - Lower down to the starting Z height, ready for adjustment!
-    #elif defined(MANUAL_PROBE_START_Z)           // A starting-Z was provided, but there's no raise:
-      do_blocking_move_to_xy_z(pos, finalz);      // - Move in XY then down to the starting Z height, ready for adjustment!
-    #else                                         // Zero raise and no starting Z height either:
-      do_blocking_move_to_xy(pos);                // - Move over with no raise, ready for adjustment!
+      motion.blocking_move_xy_z(pos, Z_CLEARANCE_BETWEEN_MANUAL_PROBES); // - Raise Z, then move to the new XY
+      motion.blocking_move_z(finalz);           // - Lower down to the starting Z height, ready for adjustment!
+    #elif defined(MANUAL_PROBE_START_Z)         // A starting-Z was provided, but there's no raise:
+      motion.blocking_move_xy_z(pos, finalz);   // - Move in XY then down to the starting Z height, ready for adjustment!
+    #else                                       // Zero raise and no starting Z height either:
+      motion.blocking_move_xy(pos);             // - Move over with no raise, ready for adjustment!
     #endif
 
     TERN_(LCD_BED_LEVELING, ui.wait_for_move = false);