♻️ Refactor axis counts and loops
This commit is contained in:
		
				
					committed by
					
						
						Scott Lahteine
					
				
			
			
				
	
			
			
			
						parent
						
							f7d28ce1d6
						
					
				
				
					commit
					26a244325b
				
			@@ -220,7 +220,7 @@ void GcodeSuite::G28() {
 | 
			
		||||
 | 
			
		||||
  #if ENABLED(MARLIN_DEV_MODE)
 | 
			
		||||
    if (parser.seen_test('S')) {
 | 
			
		||||
      LOOP_XYZ(a) set_axis_is_at_home((AxisEnum)a);
 | 
			
		||||
      LOOP_LINEAR_AXES(a) set_axis_is_at_home((AxisEnum)a);
 | 
			
		||||
      sync_plan_position();
 | 
			
		||||
      SERIAL_ECHOLNPGM("Simulated Homing");
 | 
			
		||||
      report_current_position();
 | 
			
		||||
 
 | 
			
		||||
@@ -347,7 +347,7 @@ static float auto_tune_a() {
 | 
			
		||||
  abc_float_t delta_e = { 0.0f }, delta_t = { 0.0f };
 | 
			
		||||
 | 
			
		||||
  delta_t.reset();
 | 
			
		||||
  LOOP_XYZ(axis) {
 | 
			
		||||
  LOOP_LINEAR_AXES(axis) {
 | 
			
		||||
    delta_t[axis] = diff;
 | 
			
		||||
    calc_kinematics_diff_probe_points(z_pt, delta_e, delta_r, delta_t);
 | 
			
		||||
    delta_t[axis] = 0;
 | 
			
		||||
@@ -525,7 +525,7 @@ void GcodeSuite::G33() {
 | 
			
		||||
 | 
			
		||||
        case 1:
 | 
			
		||||
          test_precision = 0.0f; // forced end
 | 
			
		||||
          LOOP_XYZ(axis) e_delta[axis] = +Z4(CEN);
 | 
			
		||||
          LOOP_LINEAR_AXES(axis) e_delta[axis] = +Z4(CEN);
 | 
			
		||||
          break;
 | 
			
		||||
 | 
			
		||||
        case 2:
 | 
			
		||||
@@ -573,14 +573,14 @@ void GcodeSuite::G33() {
 | 
			
		||||
      // Normalize angles to least-squares
 | 
			
		||||
      if (_angle_results) {
 | 
			
		||||
        float a_sum = 0.0f;
 | 
			
		||||
        LOOP_XYZ(axis) a_sum += delta_tower_angle_trim[axis];
 | 
			
		||||
        LOOP_XYZ(axis) delta_tower_angle_trim[axis] -= a_sum / 3.0f;
 | 
			
		||||
        LOOP_LINEAR_AXES(axis) a_sum += delta_tower_angle_trim[axis];
 | 
			
		||||
        LOOP_LINEAR_AXES(axis) delta_tower_angle_trim[axis] -= a_sum / 3.0f;
 | 
			
		||||
      }
 | 
			
		||||
 | 
			
		||||
      // adjust delta_height and endstops by the max amount
 | 
			
		||||
      const float z_temp = _MAX(delta_endstop_adj.a, delta_endstop_adj.b, delta_endstop_adj.c);
 | 
			
		||||
      delta_height -= z_temp;
 | 
			
		||||
      LOOP_XYZ(axis) delta_endstop_adj[axis] -= z_temp;
 | 
			
		||||
      LOOP_LINEAR_AXES(axis) delta_endstop_adj[axis] -= z_temp;
 | 
			
		||||
    }
 | 
			
		||||
    recalc_delta_settings();
 | 
			
		||||
    NOMORE(zero_std_dev_min, zero_std_dev);
 | 
			
		||||
 
 | 
			
		||||
@@ -55,8 +55,8 @@ void GcodeSuite::M425() {
 | 
			
		||||
    }
 | 
			
		||||
  };
 | 
			
		||||
 | 
			
		||||
  LOOP_XYZ(a) {
 | 
			
		||||
    if (axis_can_calibrate(a) && parser.seen(XYZ_CHAR(a))) {
 | 
			
		||||
  LOOP_LINEAR_AXES(a) {
 | 
			
		||||
    if (axis_can_calibrate(a) && parser.seen(AXIS_CHAR(a))) {
 | 
			
		||||
      planner.synchronize();
 | 
			
		||||
      backlash.distance_mm[a] = parser.has_value() ? parser.value_linear_units() : backlash.get_measurement(AxisEnum(a));
 | 
			
		||||
      noArgs = false;
 | 
			
		||||
@@ -83,8 +83,8 @@ void GcodeSuite::M425() {
 | 
			
		||||
    SERIAL_ECHOLNPGM("active:");
 | 
			
		||||
    SERIAL_ECHOLNPAIR("  Correction Amount/Fade-out:     F", backlash.get_correction(), " (F1.0 = full, F0.0 = none)");
 | 
			
		||||
    SERIAL_ECHOPGM("  Backlash Distance (mm):        ");
 | 
			
		||||
    LOOP_XYZ(a) if (axis_can_calibrate(a)) {
 | 
			
		||||
      SERIAL_CHAR(' ', XYZ_CHAR(a));
 | 
			
		||||
    LOOP_LINEAR_AXES(a) if (axis_can_calibrate(a)) {
 | 
			
		||||
      SERIAL_CHAR(' ', AXIS_CHAR(a));
 | 
			
		||||
      SERIAL_ECHO(backlash.distance_mm[a]);
 | 
			
		||||
      SERIAL_EOL();
 | 
			
		||||
    }
 | 
			
		||||
@@ -96,8 +96,8 @@ void GcodeSuite::M425() {
 | 
			
		||||
    #if ENABLED(MEASURE_BACKLASH_WHEN_PROBING)
 | 
			
		||||
      SERIAL_ECHOPGM("  Average measured backlash (mm):");
 | 
			
		||||
      if (backlash.has_any_measurement()) {
 | 
			
		||||
        LOOP_XYZ(a) if (axis_can_calibrate(a) && backlash.has_measurement(AxisEnum(a))) {
 | 
			
		||||
          SERIAL_CHAR(' ', XYZ_CHAR(a));
 | 
			
		||||
        LOOP_LINEAR_AXES(a) if (axis_can_calibrate(a) && backlash.has_measurement(AxisEnum(a))) {
 | 
			
		||||
          SERIAL_CHAR(' ', AXIS_CHAR(a));
 | 
			
		||||
          SERIAL_ECHO(backlash.get_measurement(AxisEnum(a)));
 | 
			
		||||
        }
 | 
			
		||||
      }
 | 
			
		||||
 
 | 
			
		||||
@@ -39,11 +39,11 @@
 | 
			
		||||
   */
 | 
			
		||||
  void GcodeSuite::M666() {
 | 
			
		||||
    DEBUG_SECTION(log_M666, "M666", DEBUGGING(LEVELING));
 | 
			
		||||
    LOOP_XYZ(i) {
 | 
			
		||||
      if (parser.seen(XYZ_CHAR(i))) {
 | 
			
		||||
    LOOP_LINEAR_AXES(i) {
 | 
			
		||||
      if (parser.seen(AXIS_CHAR(i))) {
 | 
			
		||||
        const float v = parser.value_linear_units();
 | 
			
		||||
        if (v * Z_HOME_DIR <= 0) delta_endstop_adj[i] = v;
 | 
			
		||||
        if (DEBUGGING(LEVELING)) DEBUG_ECHOLNPAIR("delta_endstop_adj[", AS_CHAR(XYZ_CHAR(i)), "] = ", delta_endstop_adj[i]);
 | 
			
		||||
        if (DEBUGGING(LEVELING)) DEBUG_ECHOLNPAIR("delta_endstop_adj[", AS_CHAR(AXIS_CHAR(i)), "] = ", delta_endstop_adj[i]);
 | 
			
		||||
      }
 | 
			
		||||
    }
 | 
			
		||||
  }
 | 
			
		||||
 
 | 
			
		||||
@@ -86,7 +86,7 @@ void GcodeSuite::M852() {
 | 
			
		||||
 | 
			
		||||
  // When skew is changed the current position changes
 | 
			
		||||
  if (setval) {
 | 
			
		||||
    set_current_from_steppers_for_axis(ALL_AXES);
 | 
			
		||||
    set_current_from_steppers_for_axis(ALL_AXES_MASK);
 | 
			
		||||
    sync_plan_position();
 | 
			
		||||
    report_current_position();
 | 
			
		||||
  }
 | 
			
		||||
 
 | 
			
		||||
@@ -86,7 +86,7 @@ void GcodeSuite::M201() {
 | 
			
		||||
    if (parser.seenval('G')) planner.xy_freq_min_speed_factor = constrain(parser.value_float(), 1, 100) / 100;
 | 
			
		||||
  #endif
 | 
			
		||||
 | 
			
		||||
  LOOP_XYZE(i) {
 | 
			
		||||
  LOOP_LOGICAL_AXES(i) {
 | 
			
		||||
    if (parser.seenval(axis_codes[i])) {
 | 
			
		||||
      const uint8_t a = (i == E_AXIS ? uint8_t(E_AXIS_N(target_extruder)) : i);
 | 
			
		||||
      planner.set_max_acceleration(a, parser.value_axis_units((AxisEnum)a));
 | 
			
		||||
@@ -104,7 +104,7 @@ void GcodeSuite::M203() {
 | 
			
		||||
  const int8_t target_extruder = get_target_extruder_from_command();
 | 
			
		||||
  if (target_extruder < 0) return;
 | 
			
		||||
 | 
			
		||||
  LOOP_XYZE(i)
 | 
			
		||||
  LOOP_LOGICAL_AXES(i)
 | 
			
		||||
    if (parser.seenval(axis_codes[i])) {
 | 
			
		||||
      const uint8_t a = (i == E_AXIS ? uint8_t(E_AXIS_N(target_extruder)) : i);
 | 
			
		||||
      planner.set_max_feedrate(a, parser.value_axis_units((AxisEnum)a));
 | 
			
		||||
 
 | 
			
		||||
@@ -67,7 +67,7 @@ void GcodeSuite::M92() {
 | 
			
		||||
  if (!parser.seen("XYZE" TERN_(MAGIC_NUMBERS_GCODE, "HL")))
 | 
			
		||||
    return report_M92(true, target_extruder);
 | 
			
		||||
 | 
			
		||||
  LOOP_XYZE(i) {
 | 
			
		||||
  LOOP_LOGICAL_AXES(i) {
 | 
			
		||||
    if (parser.seenval(axis_codes[i])) {
 | 
			
		||||
      if (i == E_AXIS) {
 | 
			
		||||
        const float value = parser.value_per_axis_units((AxisEnum)(E_AXIS_N(target_extruder)));
 | 
			
		||||
 
 | 
			
		||||
@@ -34,7 +34,7 @@
 | 
			
		||||
 */
 | 
			
		||||
void GcodeSuite::M350() {
 | 
			
		||||
  if (parser.seen('S')) LOOP_LE_N(i, 4) stepper.microstep_mode(i, parser.value_byte());
 | 
			
		||||
  LOOP_XYZE(i) if (parser.seen(axis_codes[i])) stepper.microstep_mode(i, parser.value_byte());
 | 
			
		||||
  LOOP_LOGICAL_AXES(i) if (parser.seen(axis_codes[i])) stepper.microstep_mode(i, parser.value_byte());
 | 
			
		||||
  if (parser.seen('B')) stepper.microstep_mode(4, parser.value_byte());
 | 
			
		||||
  stepper.microstep_readings();
 | 
			
		||||
}
 | 
			
		||||
@@ -46,15 +46,15 @@ void GcodeSuite::M350() {
 | 
			
		||||
void GcodeSuite::M351() {
 | 
			
		||||
  if (parser.seenval('S')) switch (parser.value_byte()) {
 | 
			
		||||
    case 1:
 | 
			
		||||
      LOOP_XYZE(i) if (parser.seenval(axis_codes[i])) stepper.microstep_ms(i, parser.value_byte(), -1, -1);
 | 
			
		||||
      LOOP_LOGICAL_AXES(i) if (parser.seenval(axis_codes[i])) stepper.microstep_ms(i, parser.value_byte(), -1, -1);
 | 
			
		||||
      if (parser.seenval('B')) stepper.microstep_ms(4, parser.value_byte(), -1, -1);
 | 
			
		||||
      break;
 | 
			
		||||
    case 2:
 | 
			
		||||
      LOOP_XYZE(i) if (parser.seenval(axis_codes[i])) stepper.microstep_ms(i, -1, parser.value_byte(), -1);
 | 
			
		||||
      LOOP_LOGICAL_AXES(i) if (parser.seenval(axis_codes[i])) stepper.microstep_ms(i, -1, parser.value_byte(), -1);
 | 
			
		||||
      if (parser.seenval('B')) stepper.microstep_ms(4, -1, parser.value_byte(), -1);
 | 
			
		||||
      break;
 | 
			
		||||
    case 3:
 | 
			
		||||
      LOOP_XYZE(i) if (parser.seenval(axis_codes[i])) stepper.microstep_ms(i, -1, -1, parser.value_byte());
 | 
			
		||||
      LOOP_LOGICAL_AXES(i) if (parser.seenval(axis_codes[i])) stepper.microstep_ms(i, -1, -1, parser.value_byte());
 | 
			
		||||
      if (parser.seenval('B')) stepper.microstep_ms(4, -1, -1, parser.value_byte());
 | 
			
		||||
      break;
 | 
			
		||||
  }
 | 
			
		||||
 
 | 
			
		||||
@@ -141,7 +141,7 @@
 | 
			
		||||
 | 
			
		||||
        HOTEND_LOOP() {
 | 
			
		||||
          DEBUG_ECHOPAIR_P(SP_T_STR, e);
 | 
			
		||||
          LOOP_XYZ(a) DEBUG_ECHOPAIR("  hotend_offset[", e, "].", AS_CHAR(XYZ_CHAR(a) | 0x20), "=", hotend_offset[e][a]);
 | 
			
		||||
          LOOP_LINEAR_AXES(a) DEBUG_ECHOPAIR("  hotend_offset[", e, "].", AS_CHAR(AXIS_CHAR(a) | 0x20), "=", hotend_offset[e][a]);
 | 
			
		||||
          DEBUG_EOL();
 | 
			
		||||
        }
 | 
			
		||||
        DEBUG_EOL();
 | 
			
		||||
 
 | 
			
		||||
@@ -234,7 +234,7 @@ void GcodeSuite::M906() {
 | 
			
		||||
    const uint8_t index = parser.byteval('I');
 | 
			
		||||
  #endif
 | 
			
		||||
 | 
			
		||||
  LOOP_XYZE(i) if (uint16_t value = parser.intval(axis_codes[i])) {
 | 
			
		||||
  LOOP_LOGICAL_AXES(i) if (uint16_t value = parser.intval(axis_codes[i])) {
 | 
			
		||||
 | 
			
		||||
    report_current = false;
 | 
			
		||||
 | 
			
		||||
 
 | 
			
		||||
@@ -44,7 +44,7 @@
 | 
			
		||||
void GcodeSuite::M907() {
 | 
			
		||||
  #if HAS_MOTOR_CURRENT_SPI
 | 
			
		||||
 | 
			
		||||
    LOOP_XYZE(i) if (parser.seenval(axis_codes[i])) stepper.set_digipot_current(i, parser.value_int());
 | 
			
		||||
    LOOP_LOGICAL_AXES(i) if (parser.seenval(axis_codes[i])) stepper.set_digipot_current(i, parser.value_int());
 | 
			
		||||
    if (parser.seenval('B')) stepper.set_digipot_current(4, parser.value_int());
 | 
			
		||||
    if (parser.seenval('S')) LOOP_LE_N(i, 4) stepper.set_digipot_current(i, parser.value_int());
 | 
			
		||||
 | 
			
		||||
@@ -64,7 +64,7 @@ void GcodeSuite::M907() {
 | 
			
		||||
 | 
			
		||||
  #if HAS_MOTOR_CURRENT_I2C
 | 
			
		||||
    // this one uses actual amps in floating point
 | 
			
		||||
    LOOP_XYZE(i) if (parser.seenval(axis_codes[i])) digipot_i2c.set_current(i, parser.value_float());
 | 
			
		||||
    LOOP_LOGICAL_AXES(i) if (parser.seenval(axis_codes[i])) digipot_i2c.set_current(i, parser.value_float());
 | 
			
		||||
    // Additional extruders use B,C,D for channels 4,5,6.
 | 
			
		||||
    // TODO: Change these parameters because 'E' is used. B<index>?
 | 
			
		||||
    for (uint8_t i = E_AXIS + 1; i < DIGIPOT_I2C_NUM_CHANNELS; i++)
 | 
			
		||||
@@ -76,7 +76,7 @@ void GcodeSuite::M907() {
 | 
			
		||||
      const float dac_percent = parser.value_float();
 | 
			
		||||
      LOOP_LE_N(i, 4) stepper_dac.set_current_percent(i, dac_percent);
 | 
			
		||||
    }
 | 
			
		||||
    LOOP_XYZE(i) if (parser.seenval(axis_codes[i])) stepper_dac.set_current_percent(i, parser.value_float());
 | 
			
		||||
    LOOP_LOGICAL_AXES(i) if (parser.seenval(axis_codes[i])) stepper_dac.set_current_percent(i, parser.value_float());
 | 
			
		||||
  #endif
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
 
 | 
			
		||||
@@ -71,11 +71,11 @@ void GcodeSuite::G61(void) {
 | 
			
		||||
  else {
 | 
			
		||||
    if (parser.seen("XYZ")) {
 | 
			
		||||
      DEBUG_ECHOPAIR(STR_RESTORING_POS " S", slot);
 | 
			
		||||
      LOOP_XYZ(i) {
 | 
			
		||||
        destination[i] = parser.seen(XYZ_CHAR(i))
 | 
			
		||||
      LOOP_LINEAR_AXES(i) {
 | 
			
		||||
        destination[i] = parser.seen(AXIS_CHAR(i))
 | 
			
		||||
          ? stored_position[slot][i] + parser.value_axis_units((AxisEnum)i)
 | 
			
		||||
          : current_position[i];
 | 
			
		||||
        DEBUG_CHAR(' ', XYZ_CHAR(i));
 | 
			
		||||
        DEBUG_CHAR(' ', AXIS_CHAR(i));
 | 
			
		||||
        DEBUG_ECHO_F(destination[i]);
 | 
			
		||||
      }
 | 
			
		||||
      DEBUG_EOL();
 | 
			
		||||
 
 | 
			
		||||
@@ -32,12 +32,12 @@
 | 
			
		||||
 * M122: Debug TMC drivers
 | 
			
		||||
 */
 | 
			
		||||
void GcodeSuite::M122() {
 | 
			
		||||
  xyze_bool_t print_axis = ARRAY_N_1(XYZE, false);
 | 
			
		||||
  xyze_bool_t print_axis = ARRAY_N_1(LOGICAL_AXES, false);
 | 
			
		||||
 | 
			
		||||
  bool print_all = true;
 | 
			
		||||
  LOOP_XYZE(i) if (parser.seen(axis_codes[i])) { print_axis[i] = true; print_all = false; }
 | 
			
		||||
  LOOP_LOGICAL_AXES(i) if (parser.seen(axis_codes[i])) { print_axis[i] = true; print_all = false; }
 | 
			
		||||
 | 
			
		||||
  if (print_all) LOOP_XYZE(i) print_axis[i] = true;
 | 
			
		||||
  if (print_all) LOOP_LOGICAL_AXES(i) print_axis[i] = true;
 | 
			
		||||
 | 
			
		||||
  if (parser.boolval('I')) restore_stepper_drivers();
 | 
			
		||||
 | 
			
		||||
 
 | 
			
		||||
@@ -50,7 +50,7 @@ static void set_stealth_status(const bool enable, const int8_t target_extruder)
 | 
			
		||||
    const uint8_t index = parser.byteval('I');
 | 
			
		||||
  #endif
 | 
			
		||||
 | 
			
		||||
  LOOP_XYZE(i) if (parser.seen(axis_codes[i])) {
 | 
			
		||||
  LOOP_LOGICAL_AXES(i) if (parser.seen(axis_codes[i])) {
 | 
			
		||||
    switch (i) {
 | 
			
		||||
      case X_AXIS:
 | 
			
		||||
        #if AXIS_HAS_STEALTHCHOP(X)
 | 
			
		||||
 
 | 
			
		||||
@@ -52,7 +52,7 @@ void GcodeSuite::M906() {
 | 
			
		||||
    const uint8_t index = parser.byteval('I');
 | 
			
		||||
  #endif
 | 
			
		||||
 | 
			
		||||
  LOOP_XYZE(i) if (uint16_t value = parser.intval(axis_codes[i])) {
 | 
			
		||||
  LOOP_LOGICAL_AXES(i) if (uint16_t value = parser.intval(axis_codes[i])) {
 | 
			
		||||
    report = false;
 | 
			
		||||
    switch (i) {
 | 
			
		||||
      case X_AXIS:
 | 
			
		||||
 
 | 
			
		||||
@@ -209,7 +209,7 @@
 | 
			
		||||
    #if AXIS_IS_TMC(X) || AXIS_IS_TMC(X2) || AXIS_IS_TMC(Y) || AXIS_IS_TMC(Y2) || AXIS_IS_TMC(Z) || AXIS_IS_TMC(Z2) || AXIS_IS_TMC(Z3) || AXIS_IS_TMC(Z4)
 | 
			
		||||
      const uint8_t index = parser.byteval('I');
 | 
			
		||||
    #endif
 | 
			
		||||
    LOOP_XYZE(i) if (int32_t value = parser.longval(axis_codes[i])) {
 | 
			
		||||
    LOOP_LOGICAL_AXES(i) if (int32_t value = parser.longval(axis_codes[i])) {
 | 
			
		||||
      report = false;
 | 
			
		||||
      switch (i) {
 | 
			
		||||
        case X_AXIS:
 | 
			
		||||
@@ -338,7 +338,7 @@
 | 
			
		||||
 | 
			
		||||
    bool report = true;
 | 
			
		||||
    const uint8_t index = parser.byteval('I');
 | 
			
		||||
    LOOP_XYZ(i) if (parser.seen(XYZ_CHAR(i))) {
 | 
			
		||||
    LOOP_LINEAR_AXES(i) if (parser.seen(AXIS_CHAR(i))) {
 | 
			
		||||
      const int16_t value = parser.value_int();
 | 
			
		||||
      report = false;
 | 
			
		||||
      switch (i) {
 | 
			
		||||
 
 | 
			
		||||
@@ -149,8 +149,8 @@ void GcodeSuite::get_destination_from_command() {
 | 
			
		||||
  #endif
 | 
			
		||||
 | 
			
		||||
  // Get new XYZ position, whether absolute or relative
 | 
			
		||||
  LOOP_XYZ(i) {
 | 
			
		||||
    if ( (seen[i] = parser.seenval(XYZ_CHAR(i))) ) {
 | 
			
		||||
  LOOP_LINEAR_AXES(i) {
 | 
			
		||||
    if ( (seen[i] = parser.seenval(AXIS_CHAR(i))) ) {
 | 
			
		||||
      const float v = parser.value_axis_units((AxisEnum)i);
 | 
			
		||||
      if (skip_move)
 | 
			
		||||
        destination[i] = current_position[i];
 | 
			
		||||
 
 | 
			
		||||
@@ -39,7 +39,7 @@ bool GcodeSuite::select_coordinate_system(const int8_t _new) {
 | 
			
		||||
  xyz_float_t new_offset{0};
 | 
			
		||||
  if (WITHIN(_new, 0, MAX_COORDINATE_SYSTEMS - 1))
 | 
			
		||||
    new_offset = coordinate_system[_new];
 | 
			
		||||
  LOOP_XYZ(i) {
 | 
			
		||||
  LOOP_LINEAR_AXES(i) {
 | 
			
		||||
    if (position_shift[i] != new_offset[i]) {
 | 
			
		||||
      position_shift[i] = new_offset[i];
 | 
			
		||||
      update_workspace_offset((AxisEnum)i);
 | 
			
		||||
 
 | 
			
		||||
@@ -61,7 +61,7 @@ void GcodeSuite::G92() {
 | 
			
		||||
 | 
			
		||||
    #if ENABLED(CNC_COORDINATE_SYSTEMS) && !IS_SCARA
 | 
			
		||||
      case 1:                                                         // G92.1 - Zero the Workspace Offset
 | 
			
		||||
        LOOP_XYZ(i) if (position_shift[i]) {
 | 
			
		||||
        LOOP_LINEAR_AXES(i) if (position_shift[i]) {
 | 
			
		||||
          position_shift[i] = 0;
 | 
			
		||||
          update_workspace_offset((AxisEnum)i);
 | 
			
		||||
        }
 | 
			
		||||
@@ -70,7 +70,7 @@ void GcodeSuite::G92() {
 | 
			
		||||
 | 
			
		||||
    #if ENABLED(POWER_LOSS_RECOVERY)
 | 
			
		||||
      case 9:                                                         // G92.9 - Set Current Position directly (like Marlin 1.0)
 | 
			
		||||
        LOOP_XYZE(i) {
 | 
			
		||||
        LOOP_LOGICAL_AXES(i) {
 | 
			
		||||
          if (parser.seenval(axis_codes[i])) {
 | 
			
		||||
            if (i == E_AXIS) sync_E = true; else sync_XYZE = true;
 | 
			
		||||
            current_position[i] = parser.value_axis_units((AxisEnum)i);
 | 
			
		||||
@@ -80,7 +80,7 @@ void GcodeSuite::G92() {
 | 
			
		||||
    #endif
 | 
			
		||||
 | 
			
		||||
    case 0:
 | 
			
		||||
      LOOP_XYZE(i) {
 | 
			
		||||
      LOOP_LOGICAL_AXES(i) {
 | 
			
		||||
        if (parser.seenval(axis_codes[i])) {
 | 
			
		||||
          const float l = parser.value_axis_units((AxisEnum)i),       // Given axis coordinate value, converted to millimeters
 | 
			
		||||
                      v = i == E_AXIS ? l : LOGICAL_TO_NATIVE(l, i),  // Axis position in NATIVE space (applying the existing offset)
 | 
			
		||||
 
 | 
			
		||||
@@ -42,8 +42,8 @@ void M206_report() {
 | 
			
		||||
 * ***              In the 2.0 release, it will simply be disabled by default.
 | 
			
		||||
 */
 | 
			
		||||
void GcodeSuite::M206() {
 | 
			
		||||
  LOOP_XYZ(i)
 | 
			
		||||
    if (parser.seen(XYZ_CHAR(i)))
 | 
			
		||||
  LOOP_LINEAR_AXES(i)
 | 
			
		||||
    if (parser.seen(AXIS_CHAR(i)))
 | 
			
		||||
      set_home_offset((AxisEnum)i, parser.value_linear_units());
 | 
			
		||||
 | 
			
		||||
  #if ENABLED(MORGAN_SCARA)
 | 
			
		||||
@@ -72,7 +72,7 @@ void GcodeSuite::M428() {
 | 
			
		||||
  if (homing_needed_error()) return;
 | 
			
		||||
 | 
			
		||||
  xyz_float_t diff;
 | 
			
		||||
  LOOP_XYZ(i) {
 | 
			
		||||
  LOOP_LINEAR_AXES(i) {
 | 
			
		||||
    diff[i] = base_home_pos((AxisEnum)i) - current_position[i];
 | 
			
		||||
    if (!WITHIN(diff[i], -20, 20) && home_dir((AxisEnum)i) > 0)
 | 
			
		||||
      diff[i] = -current_position[i];
 | 
			
		||||
@@ -84,7 +84,7 @@ void GcodeSuite::M428() {
 | 
			
		||||
    }
 | 
			
		||||
  }
 | 
			
		||||
 | 
			
		||||
  LOOP_XYZ(i) set_home_offset((AxisEnum)i, diff[i]);
 | 
			
		||||
  LOOP_LINEAR_AXES(i) set_home_offset((AxisEnum)i, diff[i]);
 | 
			
		||||
  report_current_position();
 | 
			
		||||
  LCD_MESSAGEPGM(MSG_HOME_OFFSETS_APPLIED);
 | 
			
		||||
  BUZZ(100, 659);
 | 
			
		||||
 
 | 
			
		||||
@@ -47,8 +47,8 @@
 | 
			
		||||
 | 
			
		||||
  void report_linear_axis_pos(const xyz_pos_t &pos, const uint8_t precision=3) {
 | 
			
		||||
    char str[12];
 | 
			
		||||
    LOOP_XYZ(a) {
 | 
			
		||||
      SERIAL_CHAR(' ', XYZ_CHAR(a), ':');
 | 
			
		||||
    LOOP_LINEAR_AXES(a) {
 | 
			
		||||
      SERIAL_CHAR(' ', AXIS_CHAR(a), ':');
 | 
			
		||||
      SERIAL_ECHO(dtostrf(pos[a], 1, precision, str));
 | 
			
		||||
    }
 | 
			
		||||
    SERIAL_EOL();
 | 
			
		||||
@@ -153,7 +153,7 @@
 | 
			
		||||
    #endif // HAS_L64XX
 | 
			
		||||
 | 
			
		||||
    SERIAL_ECHOPGM("Stepper:");
 | 
			
		||||
    LOOP_XYZE(i) {
 | 
			
		||||
    LOOP_LOGICAL_AXES(i) {
 | 
			
		||||
      SERIAL_CHAR(' ', axis_codes[i], ':');
 | 
			
		||||
      SERIAL_ECHO(stepper.position((AxisEnum)i));
 | 
			
		||||
    }
 | 
			
		||||
 
 | 
			
		||||
@@ -69,8 +69,8 @@
 | 
			
		||||
 */
 | 
			
		||||
void GcodeSuite::M290() {
 | 
			
		||||
  #if ENABLED(BABYSTEP_XY)
 | 
			
		||||
    LOOP_XYZ(a)
 | 
			
		||||
      if (parser.seenval(XYZ_CHAR(a)) || (a == Z_AXIS && parser.seenval('S'))) {
 | 
			
		||||
    LOOP_LINEAR_AXES(a)
 | 
			
		||||
      if (parser.seenval(AXIS_CHAR(a)) || (a == Z_AXIS && parser.seenval('S'))) {
 | 
			
		||||
        const float offs = constrain(parser.value_axis_units((AxisEnum)a), -2, 2);
 | 
			
		||||
        babystep.add_mm((AxisEnum)a, offs);
 | 
			
		||||
        #if ENABLED(BABYSTEP_ZPROBE_OFFSET)
 | 
			
		||||
 
 | 
			
		||||
@@ -38,7 +38,7 @@ inline void G38_single_probe(const uint8_t move_value) {
 | 
			
		||||
  planner.synchronize();
 | 
			
		||||
  G38_move = 0;
 | 
			
		||||
  endstops.hit_on_purpose();
 | 
			
		||||
  set_current_from_steppers_for_axis(ALL_AXES);
 | 
			
		||||
  set_current_from_steppers_for_axis(ALL_AXES_MASK);
 | 
			
		||||
  sync_plan_position();
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
@@ -49,7 +49,7 @@ inline bool G38_run_probe() {
 | 
			
		||||
  #if MULTIPLE_PROBING > 1
 | 
			
		||||
    // Get direction of move and retract
 | 
			
		||||
    xyz_float_t retract_mm;
 | 
			
		||||
    LOOP_XYZ(i) {
 | 
			
		||||
    LOOP_LINEAR_AXES(i) {
 | 
			
		||||
      const float dist = destination[i] - current_position[i];
 | 
			
		||||
      retract_mm[i] = ABS(dist) < G38_MINIMUM_MOVE ? 0 : home_bump_mm((AxisEnum)i) * (dist > 0 ? -1 : 1);
 | 
			
		||||
    }
 | 
			
		||||
@@ -119,7 +119,7 @@ void GcodeSuite::G38(const int8_t subcode) {
 | 
			
		||||
  ;
 | 
			
		||||
 | 
			
		||||
  // If any axis has enough movement, do the move
 | 
			
		||||
  LOOP_XYZ(i)
 | 
			
		||||
  LOOP_LINEAR_AXES(i)
 | 
			
		||||
    if (ABS(destination[i] - current_position[i]) >= G38_MINIMUM_MOVE) {
 | 
			
		||||
      if (!parser.seenval('F')) feedrate_mm_s = homing_feedrate((AxisEnum)i);
 | 
			
		||||
      // If G38.2 fails throw an error
 | 
			
		||||
 
 | 
			
		||||
		Reference in New Issue
	
	Block a user