Initial commit

1 files changed, 1084 insertions, 0 deletions

diff --git a/Marlin/src/gcode/gcode.cpp b/Marlin/src/gcode/gcode.cpp
new file mode 100644
index 0000000..f917318
--- /dev/null
+++ b/Marlin/src/gcode/gcode.cpp
@@ -0,0 +1,1084 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+/**
+ * gcode.cpp - Temporary container for all gcode handlers
+ *             Most will migrate to classes, by feature.
+ */
+
+#include "gcode.h"
+GcodeSuite gcode;
+
+#if ENABLED(WIFI_CUSTOM_COMMAND)
+  extern bool wifi_custom_command(char * const command_ptr);
+#endif
+
+#include "parser.h"
+#include "queue.h"
+#include "../module/motion.h"
+
+#if ENABLED(PRINTCOUNTER)
+  #include "../module/printcounter.h"
+#endif
+
+#if ENABLED(HOST_ACTION_COMMANDS)
+  #include "../feature/host_actions.h"
+#endif
+
+#if ENABLED(POWER_LOSS_RECOVERY)
+  #include "../sd/cardreader.h"
+  #include "../feature/powerloss.h"
+#endif
+
+#if ENABLED(CANCEL_OBJECTS)
+  #include "../feature/cancel_object.h"
+#endif
+
+#if ENABLED(LASER_MOVE_POWER)
+  #include "../feature/spindle_laser.h"
+#endif
+
+#if ENABLED(PASSWORD_FEATURE)
+  #include "../feature/password/password.h"
+#endif
+
+#include "../MarlinCore.h" // for idle, kill
+
+// Inactivity shutdown
+millis_t GcodeSuite::previous_move_ms = 0,
+         GcodeSuite::max_inactive_time = 0,
+         GcodeSuite::stepper_inactive_time = SEC_TO_MS(DEFAULT_STEPPER_DEACTIVE_TIME);
+
+// Relative motion mode for each logical axis
+static constexpr xyze_bool_t ar_init = AXIS_RELATIVE_MODES;
+uint8_t GcodeSuite::axis_relative = (
+    (ar_init.x ? _BV(REL_X) : 0)
+  | (ar_init.y ? _BV(REL_Y) : 0)
+  | (ar_init.z ? _BV(REL_Z) : 0)
+  | (ar_init.e ? _BV(REL_E) : 0)
+);
+
+#if EITHER(HAS_AUTO_REPORTING, HOST_KEEPALIVE_FEATURE)
+  bool GcodeSuite::autoreport_paused; // = false
+#endif
+
+#if ENABLED(HOST_KEEPALIVE_FEATURE)
+  GcodeSuite::MarlinBusyState GcodeSuite::busy_state = NOT_BUSY;
+  uint8_t GcodeSuite::host_keepalive_interval = DEFAULT_KEEPALIVE_INTERVAL;
+#endif
+
+#if ENABLED(CNC_WORKSPACE_PLANES)
+  GcodeSuite::WorkspacePlane GcodeSuite::workspace_plane = PLANE_XY;
+#endif
+
+#if ENABLED(CNC_COORDINATE_SYSTEMS)
+  int8_t GcodeSuite::active_coordinate_system = -1; // machine space
+  xyz_pos_t GcodeSuite::coordinate_system[MAX_COORDINATE_SYSTEMS];
+#endif
+
+/**
+ * Get the target extruder from the T parameter or the active_extruder
+ * Return -1 if the T parameter is out of range
+ */
+int8_t GcodeSuite::get_target_extruder_from_command() {
+  if (parser.seenval('T')) {
+    const int8_t e = parser.value_byte();
+    if (e < EXTRUDERS) return e;
+    SERIAL_ECHO_START();
+    SERIAL_CHAR('M'); SERIAL_ECHO(parser.codenum);
+    SERIAL_ECHOLNPAIR(" " STR_INVALID_EXTRUDER " ", int(e));
+    return -1;
+  }
+  return active_extruder;
+}
+
+/**
+ * Get the target e stepper from the T parameter
+ * Return -1 if the T parameter is out of range or unspecified
+ */
+int8_t GcodeSuite::get_target_e_stepper_from_command() {
+  const int8_t e = parser.intval('T', -1);
+  if (WITHIN(e, 0, E_STEPPERS - 1)) return e;
+
+  SERIAL_ECHO_START();
+  SERIAL_CHAR('M'); SERIAL_ECHO(parser.codenum);
+  if (e == -1)
+    SERIAL_ECHOLNPGM(" " STR_E_STEPPER_NOT_SPECIFIED);
+  else
+    SERIAL_ECHOLNPAIR(" " STR_INVALID_E_STEPPER " ", int(e));
+  return -1;
+}
+
+/**
+ * Set XYZE destination and feedrate from the current GCode command
+ *
+ *  - Set destination from included axis codes
+ *  - Set to current for missing axis codes
+ *  - Set the feedrate, if included
+ */
+void GcodeSuite::get_destination_from_command() {
+  xyze_bool_t seen = { false, false, false, false };
+
+  #if ENABLED(CANCEL_OBJECTS)
+    const bool &skip_move = cancelable.skipping;
+  #else
+    constexpr bool skip_move = false;
+  #endif
+
+  // Get new XYZ position, whether absolute or relative
+  LOOP_XYZ(i) {
+    if ( (seen[i] = parser.seenval(XYZ_CHAR(i))) ) {
+      const float v = parser.value_axis_units((AxisEnum)i);
+      if (skip_move)
+        destination[i] = current_position[i];
+      else
+        destination[i] = axis_is_relative(AxisEnum(i)) ? current_position[i] + v : LOGICAL_TO_NATIVE(v, i);
+    }
+    else
+      destination[i] = current_position[i];
+  }
+
+  // Get new E position, whether absolute or relative
+  if ( (seen.e = parser.seenval('E')) ) {
+    const float v = parser.value_axis_units(E_AXIS);
+    destination.e = axis_is_relative(E_AXIS) ? current_position.e + v : v;
+  }
+  else
+    destination.e = current_position.e;
+
+  #if ENABLED(POWER_LOSS_RECOVERY) && !PIN_EXISTS(POWER_LOSS)
+    // Only update power loss recovery on moves with E
+    if (recovery.enabled && IS_SD_PRINTING() && seen.e && (seen.x || seen.y))
+      recovery.save();
+  #endif
+
+  if (parser.linearval('F') > 0)
+    feedrate_mm_s = parser.value_feedrate();
+
+  #if ENABLED(PRINTCOUNTER)
+    if (!DEBUGGING(DRYRUN) && !skip_move)
+      print_job_timer.incFilamentUsed(destination.e - current_position.e);
+  #endif
+
+  // Get ABCDHI mixing factors
+  #if BOTH(MIXING_EXTRUDER, DIRECT_MIXING_IN_G1)
+    M165();
+  #endif
+
+  #if ENABLED(LASER_MOVE_POWER)
+    // Set the laser power in the planner to configure this move
+    if (parser.seen('S')) {
+      const float spwr = parser.value_float();
+      cutter.inline_power(TERN(SPINDLE_LASER_PWM, cutter.power_to_range(cutter_power_t(round(spwr))), spwr > 0 ? 255 : 0));
+    }
+    else if (ENABLED(LASER_MOVE_G0_OFF) && parser.codenum == 0) // G0
+      cutter.set_inline_enabled(false);
+  #endif
+}
+
+/**
+ * Dwell waits immediately. It does not synchronize. Use M400 instead of G4
+ */
+void GcodeSuite::dwell(millis_t time) {
+  time += millis();
+  while (PENDING(millis(), time)) idle();
+}
+
+/**
+ * When G29_RETRY_AND_RECOVER is enabled, call G29() in
+ * a loop with recovery and retry handling.
+ */
+#if BOTH(HAS_LEVELING, G29_RETRY_AND_RECOVER)
+
+  void GcodeSuite::event_probe_recover() {
+    TERN_(HOST_PROMPT_SUPPORT, host_prompt_do(PROMPT_INFO, PSTR("G29 Retrying"), DISMISS_STR));
+    #ifdef ACTION_ON_G29_RECOVER
+      host_action(PSTR(ACTION_ON_G29_RECOVER));
+    #endif
+    #ifdef G29_RECOVER_COMMANDS
+      process_subcommands_now_P(PSTR(G29_RECOVER_COMMANDS));
+    #endif
+  }
+
+  void GcodeSuite::event_probe_failure() {
+    #ifdef ACTION_ON_G29_FAILURE
+      host_action(PSTR(ACTION_ON_G29_FAILURE));
+    #endif
+    #ifdef G29_FAILURE_COMMANDS
+      process_subcommands_now_P(PSTR(G29_FAILURE_COMMANDS));
+    #endif
+    #if ENABLED(G29_HALT_ON_FAILURE)
+      #ifdef ACTION_ON_CANCEL
+        host_action_cancel();
+      #endif
+      kill(GET_TEXT(MSG_LCD_PROBING_FAILED));
+    #endif
+  }
+
+  #ifndef G29_MAX_RETRIES
+    #define G29_MAX_RETRIES 0
+  #endif
+
+  void GcodeSuite::G29_with_retry() {
+    uint8_t retries = G29_MAX_RETRIES;
+    while (G29()) { // G29 should return true for failed probes ONLY
+      if (retries) {
+        event_probe_recover();
+        --retries;
+      }
+      else {
+        event_probe_failure();
+        return;
+      }
+    }
+
+    TERN_(HOST_PROMPT_SUPPORT, host_action_prompt_end());
+
+    #ifdef G29_SUCCESS_COMMANDS
+      process_subcommands_now_P(PSTR(G29_SUCCESS_COMMANDS));
+    #endif
+  }
+
+#endif // HAS_LEVELING && G29_RETRY_AND_RECOVER
+
+//
+// Placeholders for non-migrated codes
+//
+#if ENABLED(M100_FREE_MEMORY_WATCHER)
+  extern void M100_dump_routine(PGM_P const title, const char * const start, const char * const end);
+#endif
+
+/**
+ * Process the parsed command and dispatch it to its handler
+ */
+void GcodeSuite::process_parsed_command(const bool no_ok/*=false*/) {
+  KEEPALIVE_STATE(IN_HANDLER);
+
+ /**
+  * Block all Gcodes except M511 Unlock Printer, if printer is locked
+  * Will still block Gcodes if M511 is disabled, in which case the printer should be unlocked via LCD Menu
+  */
+  #if ENABLED(PASSWORD_FEATURE)
+    if (password.is_locked && !parser.is_command('M', 511)) {
+      SERIAL_ECHO_MSG(STR_PRINTER_LOCKED);
+      if (!no_ok) queue.ok_to_send();
+      return;
+    }
+  #endif
+
+  // Handle a known G, M, or T
+  switch (parser.command_letter) {
+    case 'G': switch (parser.codenum) {
+
+      case 0: case 1:                                             // G0: Fast Move, G1: Linear Move
+        G0_G1(TERN_(HAS_FAST_MOVES, parser.codenum == 0)); break;
+
+      #if ENABLED(ARC_SUPPORT) && DISABLED(SCARA)
+        case 2: case 3: G2_G3(parser.codenum == 2); break;        // G2: CW ARC, G3: CCW ARC
+      #endif
+
+      case 4: G4(); break;                                        // G4: Dwell
+
+      #if ENABLED(BEZIER_CURVE_SUPPORT)
+        case 5: G5(); break;                                      // G5: Cubic B_spline
+      #endif
+
+      #if ENABLED(DIRECT_STEPPING)
+        case 6: G6(); break;                                      // G6: Direct Stepper Move
+      #endif
+
+      #if ENABLED(FWRETRACT)
+        case 10: G10(); break;                                    // G10: Retract / Swap Retract
+        case 11: G11(); break;                                    // G11: Recover / Swap Recover
+      #endif
+
+      #if ENABLED(NOZZLE_CLEAN_FEATURE)
+        case 12: G12(); break;                                    // G12: Nozzle Clean
+      #endif
+
+      #if ENABLED(CNC_WORKSPACE_PLANES)
+        case 17: G17(); break;                                    // G17: Select Plane XY
+        case 18: G18(); break;                                    // G18: Select Plane ZX
+        case 19: G19(); break;                                    // G19: Select Plane YZ
+      #endif
+
+      #if ENABLED(INCH_MODE_SUPPORT)
+        case 20: G20(); break;                                    // G20: Inch Mode
+        case 21: G21(); break;                                    // G21: MM Mode
+      #else
+        case 21: NOOP; break;                                     // No error on unknown G21
+      #endif
+
+      #if ENABLED(G26_MESH_VALIDATION)
+        case 26: G26(); break;                                    // G26: Mesh Validation Pattern generation
+      #endif
+
+      #if ENABLED(NOZZLE_PARK_FEATURE)
+        case 27: G27(); break;                                    // G27: Nozzle Park
+      #endif
+
+      case 28: G28(); break;                                      // G28: Home one or more axes
+
+      #if HAS_LEVELING
+        case 29:                                                  // G29: Bed leveling calibration
+          TERN(G29_RETRY_AND_RECOVER, G29_with_retry, G29)();
+          break;
+      #endif
+
+      #if HAS_BED_PROBE
+        case 30: G30(); break;                                    // G30: Single Z probe
+        #if ENABLED(Z_PROBE_SLED)
+          case 31: G31(); break;                                  // G31: dock the sled
+          case 32: G32(); break;                                  // G32: undock the sled
+        #endif
+      #endif
+
+      #if ENABLED(DELTA_AUTO_CALIBRATION)
+        case 33: G33(); break;                                    // G33: Delta Auto-Calibration
+      #endif
+
+      #if ANY(Z_MULTI_ENDSTOPS, Z_STEPPER_AUTO_ALIGN, MECHANICAL_GANTRY_CALIBRATION)
+        case 34: G34(); break;                                    // G34: Z Stepper automatic alignment using probe
+      #endif
+
+      #if ENABLED(ASSISTED_TRAMMING)
+        case 35: G35(); break;                                    // G35: Read four bed corners to help adjust bed screws
+      #endif
+
+      #if ENABLED(G38_PROBE_TARGET)
+        case 38:                                                  // G38.2, G38.3: Probe towards target
+          if (WITHIN(parser.subcode, 2, TERN(G38_PROBE_AWAY, 5, 3)))
+            G38(parser.subcode);                                  // G38.4, G38.5: Probe away from target
+          break;
+      #endif
+
+      #if ENABLED(CNC_COORDINATE_SYSTEMS)
+        case 53: G53(); break;                                    // G53: (prefix) Apply native workspace
+        case 54: G54(); break;                                    // G54: Switch to Workspace 1
+        case 55: G55(); break;                                    // G55: Switch to Workspace 2
+        case 56: G56(); break;                                    // G56: Switch to Workspace 3
+        case 57: G57(); break;                                    // G57: Switch to Workspace 4
+        case 58: G58(); break;                                    // G58: Switch to Workspace 5
+        case 59: G59(); break;                                    // G59.0 - G59.3: Switch to Workspace 6-9
+      #endif
+
+      #if SAVED_POSITIONS
+        case 60: G60(); break;                                    // G60:  save current position
+        case 61: G61(); break;                                    // G61:  Apply/restore saved coordinates.
+      #endif
+
+      #if ENABLED(PROBE_TEMP_COMPENSATION)
+        case 76: G76(); break;                                    // G76: Calibrate first layer compensation values
+      #endif
+
+      #if ENABLED(GCODE_MOTION_MODES)
+        case 80: G80(); break;                                    // G80: Reset the current motion mode
+      #endif
+
+      case 90: set_relative_mode(false); break;                   // G90: Absolute Mode
+      case 91: set_relative_mode(true);  break;                   // G91: Relative Mode
+
+      case 92: G92(); break;                                      // G92: Set current axis position(s)
+
+      #if HAS_MESH
+        case 42: G42(); break;                                    // G42: Coordinated move to a mesh point
+      #endif
+
+      #if ENABLED(CALIBRATION_GCODE)
+        case 425: G425(); break;                                  // G425: Perform calibration with calibration cube
+      #endif
+
+      #if ENABLED(DEBUG_GCODE_PARSER)
+        case 800: parser.debug(); break;                          // G800: GCode Parser Test for G
+      #endif
+
+      default: parser.unknown_command_warning(); break;
+    }
+    break;
+
+    case 'M': switch (parser.codenum) {
+
+      #if HAS_RESUME_CONTINUE
+        case 0:                                                   // M0: Unconditional stop - Wait for user button press on LCD
+        case 1: M0_M1(); break;                                   // M1: Conditional stop - Wait for user button press on LCD
+      #endif
+
+      #if HAS_CUTTER
+        case 3: M3_M4(false); break;                              // M3: Turn ON Laser | Spindle (clockwise), set Power | Speed
+        case 4: M3_M4(true ); break;                              // M4: Turn ON Laser | Spindle (counter-clockwise), set Power | Speed
+        case 5: M5(); break;                                      // M5: Turn OFF Laser | Spindle
+      #endif
+
+      #if ENABLED(COOLANT_CONTROL)
+        #if ENABLED(COOLANT_MIST)
+          case 7: M7(); break;                                    // M7: Mist coolant ON
+        #endif
+        #if ENABLED(COOLANT_FLOOD)
+          case 8: M8(); break;                                    // M8: Flood coolant ON
+        #endif
+        case 9: M9(); break;                                      // M9: Coolant OFF
+      #endif
+
+      #if ENABLED(EXTERNAL_CLOSED_LOOP_CONTROLLER)
+        case 12: M12(); break;                                    // M12: Synchronize and optionally force a CLC set
+      #endif
+
+      #if ENABLED(EXPECTED_PRINTER_CHECK)
+        case 16: M16(); break;                                    // M16: Expected printer check
+      #endif
+
+      case 17: M17(); break;                                      // M17: Enable all stepper motors
+
+      #if ENABLED(SDSUPPORT)
+        case 20: M20(); break;                                    // M20: List SD card
+        case 21: M21(); break;                                    // M21: Init SD card
+        case 22: M22(); break;                                    // M22: Release SD card
+        case 23: M23(); break;                                    // M23: Select file
+        case 24: M24(); break;                                    // M24: Start SD print
+        case 25: M25(); break;                                    // M25: Pause SD print
+        case 26: M26(); break;                                    // M26: Set SD index
+        case 27: M27(); break;                                    // M27: Get SD status
+        case 28: M28(); break;                                    // M28: Start SD write
+        case 29: M29(); break;                                    // M29: Stop SD write
+        case 30: M30(); break;                                    // M30 <filename> Delete File
+
+        #if HAS_MEDIA_SUBCALLS
+          case 32: M32(); break;                                  // M32: Select file and start SD print
+        #endif
+
+        #if ENABLED(LONG_FILENAME_HOST_SUPPORT)
+          case 33: M33(); break;                                  // M33: Get the long full path to a file or folder
+        #endif
+
+        #if BOTH(SDCARD_SORT_ALPHA, SDSORT_GCODE)
+          case 34: M34(); break;                                  // M34: Set SD card sorting options
+        #endif
+
+        case 928: M928(); break;                                  // M928: Start SD write
+      #endif // SDSUPPORT
+
+      case 31: M31(); break;                                      // M31: Report time since the start of SD print or last M109
+
+      #if ENABLED(DIRECT_PIN_CONTROL)
+        case 42: M42(); break;                                    // M42: Change pin state
+      #endif
+
+      #if ENABLED(PINS_DEBUGGING)
+        case 43: M43(); break;                                    // M43: Read pin state
+      #endif
+
+      #if ENABLED(Z_MIN_PROBE_REPEATABILITY_TEST)
+        case 48: M48(); break;                                    // M48: Z probe repeatability test
+      #endif
+
+      #if ENABLED(LCD_SET_PROGRESS_MANUALLY)
+        case 73: M73(); break;                                    // M73: Set progress percentage (for display on LCD)
+      #endif
+
+      case 75: M75(); break;                                      // M75: Start print timer
+      case 76: M76(); break;                                      // M76: Pause print timer
+      case 77: M77(); break;                                      // M77: Stop print timer
+
+      #if ENABLED(PRINTCOUNTER)
+        case 78: M78(); break;                                    // M78: Show print statistics
+      #endif
+
+      #if ENABLED(M100_FREE_MEMORY_WATCHER)
+        case 100: M100(); break;                                  // M100: Free Memory Report
+      #endif
+
+      #if EXTRUDERS
+        case 104: M104(); break;                                  // M104: Set hot end temperature
+        case 109: M109(); break;                                  // M109: Wait for hotend temperature to reach target
+      #endif
+
+      case 105: M105(); return;                                   // M105: Report Temperatures (and say "ok")
+
+      #if HAS_FAN
+        case 106: M106(); break;                                  // M106: Fan On
+        case 107: M107(); break;                                  // M107: Fan Off
+      #endif
+
+      case 110: M110(); break;                                    // M110: Set Current Line Number
+      case 111: M111(); break;                                    // M111: Set debug level
+
+      #if DISABLED(EMERGENCY_PARSER)
+        case 108: M108(); break;                                  // M108: Cancel Waiting
+        case 112: M112(); break;                                  // M112: Full Shutdown
+        case 410: M410(); break;                                  // M410: Quickstop - Abort all the planned moves.
+        TERN_(HOST_PROMPT_SUPPORT, case 876:)                     // M876: Handle Host prompt responses
+      #else
+        case 108: case 112: case 410:
+        TERN_(HOST_PROMPT_SUPPORT, case 876:)
+        break;
+      #endif
+
+      #if ENABLED(HOST_KEEPALIVE_FEATURE)
+        case 113: M113(); break;                                  // M113: Set Host Keepalive interval
+      #endif
+
+      #if HAS_HEATED_BED
+        case 140: M140(); break;                                  // M140: Set bed temperature
+        case 190: M190(); break;                                  // M190: Wait for bed temperature to reach target
+      #endif
+
+      #if HAS_HEATED_CHAMBER
+        case 141: M141(); break;                                  // M141: Set chamber temperature
+        case 191: M191(); break;                                  // M191: Wait for chamber temperature to reach target
+      #endif
+
+      #if BOTH(AUTO_REPORT_TEMPERATURES, HAS_TEMP_SENSOR)
+        case 155: M155(); break;                                  // M155: Set temperature auto-report interval
+      #endif
+
+      #if ENABLED(PARK_HEAD_ON_PAUSE)
+        case 125: M125(); break;                                  // M125: Store current position and move to filament change position
+      #endif
+
+      #if ENABLED(BARICUDA)
+        // PWM for HEATER_1_PIN
+        #if HAS_HEATER_1
+          case 126: M126(); break;                                // M126: valve open
+          case 127: M127(); break;                                // M127: valve closed
+        #endif
+
+        // PWM for HEATER_2_PIN
+        #if HAS_HEATER_2
+          case 128: M128(); break;                                // M128: valve open
+          case 129: M129(); break;                                // M129: valve closed
+        #endif
+      #endif // BARICUDA
+
+      #if ENABLED(PSU_CONTROL)
+        case 80: M80(); break;                                    // M80: Turn on Power Supply
+      #endif
+      case 81: M81(); break;                                      // M81: Turn off Power, including Power Supply, if possible
+
+      case 82: M82(); break;                                      // M82: Set E axis normal mode (same as other axes)
+      case 83: M83(); break;                                      // M83: Set E axis relative mode
+      case 18: case 84: M18_M84(); break;                         // M18/M84: Disable Steppers / Set Timeout
+      case 85: M85(); break;                                      // M85: Set inactivity stepper shutdown timeout
+      case 92: M92(); break;                                      // M92: Set the steps-per-unit for one or more axes
+      case 114: M114(); break;                                    // M114: Report current position
+      case 115: M115(); break;                                    // M115: Report capabilities
+      case 117: M117(); break;                                    // M117: Set LCD message text, if possible
+      case 118: M118(); break;                                    // M118: Display a message in the host console
+      case 119: M119(); break;                                    // M119: Report endstop states
+      case 120: M120(); break;                                    // M120: Enable endstops
+      case 121: M121(); break;                                    // M121: Disable endstops
+
+      #if PREHEAT_COUNT
+        case 145: M145(); break;                                  // M145: Set material heatup parameters
+      #endif
+
+      #if ENABLED(TEMPERATURE_UNITS_SUPPORT)
+        case 149: M149(); break;                                  // M149: Set temperature units
+      #endif
+
+      #if HAS_COLOR_LEDS
+        case 150: M150(); break;                                  // M150: Set Status LED Color
+      #endif
+
+      #if ENABLED(MIXING_EXTRUDER)
+        case 163: M163(); break;                                  // M163: Set a component weight for mixing extruder
+        case 164: M164(); break;                                  // M164: Save current mix as a virtual extruder
+        #if ENABLED(DIRECT_MIXING_IN_G1)
+          case 165: M165(); break;                                // M165: Set multiple mix weights
+        #endif
+        #if ENABLED(GRADIENT_MIX)
+          case 166: M166(); break;                                // M166: Set Gradient Mix
+        #endif
+      #endif
+
+      #if DISABLED(NO_VOLUMETRICS)
+        case 200: M200(); break;                                  // M200: Set filament diameter, E to cubic units
+      #endif
+
+      case 201: M201(); break;                                    // M201: Set max acceleration for print moves (units/s^2)
+
+      #if 0
+        case 202: M202(); break;                                  // M202: Not used for Sprinter/grbl gen6
+      #endif
+
+      case 203: M203(); break;                                    // M203: Set max feedrate (units/sec)
+      case 204: M204(); break;                                    // M204: Set acceleration
+      case 205: M205(); break;                                    // M205: Set advanced settings
+
+      #if HAS_M206_COMMAND
+        case 206: M206(); break;                                  // M206: Set home offsets
+      #endif
+
+      #if ENABLED(FWRETRACT)
+        case 207: M207(); break;                                  // M207: Set Retract Length, Feedrate, and Z lift
+        case 208: M208(); break;                                  // M208: Set Recover (unretract) Additional Length and Feedrate
+        #if ENABLED(FWRETRACT_AUTORETRACT)
+          case 209:
+            if (MIN_AUTORETRACT <= MAX_AUTORETRACT) M209();       // M209: Turn Automatic Retract Detection on/off
+            break;
+        #endif
+      #endif
+
+      #if HAS_SOFTWARE_ENDSTOPS
+        case 211: M211(); break;                                  // M211: Enable, Disable, and/or Report software endstops
+      #endif
+
+      #if HAS_MULTI_EXTRUDER
+        case 217: M217(); break;                                  // M217: Set filament swap parameters
+      #endif
+
+      #if HAS_HOTEND_OFFSET
+        case 218: M218(); break;                                  // M218: Set a tool offset
+      #endif
+
+      case 220: M220(); break;                                    // M220: Set Feedrate Percentage: S<percent> ("FR" on your LCD)
+
+      #if EXTRUDERS
+        case 221: M221(); break;                                  // M221: Set Flow Percentage
+      #endif
+
+      #if ENABLED(DIRECT_PIN_CONTROL)
+        case 226: M226(); break;                                  // M226: Wait until a pin reaches a state
+      #endif
+
+      #if HAS_SERVOS
+        case 280: M280(); break;                                  // M280: Set servo position absolute
+        #if ENABLED(EDITABLE_SERVO_ANGLES)
+          case 281: M281(); break;                                // M281: Set servo angles
+        #endif
+      #endif
+
+      #if ENABLED(BABYSTEPPING)
+        case 290: M290(); break;                                  // M290: Babystepping
+      #endif
+
+      #if HAS_BUZZER
+        case 300: M300(); break;                                  // M300: Play beep tone
+      #endif
+
+      #if ENABLED(PIDTEMP)
+        case 301: M301(); break;                                  // M301: Set hotend PID parameters
+      #endif
+
+      #if ENABLED(PIDTEMPBED)
+        case 304: M304(); break;                                  // M304: Set bed PID parameters
+      #endif
+
+      #if ENABLED(PHOTO_GCODE)
+        case 240: M240(); break;                                  // M240: Trigger a camera
+      #endif
+
+      #if HAS_LCD_CONTRAST
+        case 250: M250(); break;                                  // M250: Set LCD contrast
+      #endif
+
+      #if ENABLED(EXPERIMENTAL_I2CBUS)
+        case 260: M260(); break;                                  // M260: Send data to an i2c slave
+        case 261: M261(); break;                                  // M261: Request data from an i2c slave
+      #endif
+
+      #if ENABLED(PREVENT_COLD_EXTRUSION)
+        case 302: M302(); break;                                  // M302: Allow cold extrudes (set the minimum extrude temperature)
+      #endif
+
+      #if HAS_PID_HEATING
+        case 303: M303(); break;                                  // M303: PID autotune
+      #endif
+
+      #if HAS_USER_THERMISTORS
+        case 305: M305(); break;                                  // M305: Set user thermistor parameters
+      #endif
+
+      #if ENABLED(REPETIER_GCODE_M360)
+        case 360: M360(); break;                                  // M360: Firmware settings
+      #endif
+
+      #if ENABLED(MORGAN_SCARA)
+        case 360: if (M360()) return; break;                      // M360: SCARA Theta pos1
+        case 361: if (M361()) return; break;                      // M361: SCARA Theta pos2
+        case 362: if (M362()) return; break;                      // M362: SCARA Psi pos1
+        case 363: if (M363()) return; break;                      // M363: SCARA Psi pos2
+        case 364: if (M364()) return; break;                      // M364: SCARA Psi pos3 (90 deg to Theta)
+      #endif
+
+      #if EITHER(EXT_SOLENOID, MANUAL_SOLENOID_CONTROL)
+        case 380: M380(); break;                                  // M380: Activate solenoid on active (or specified) extruder
+        case 381: M381(); break;                                  // M381: Disable all solenoids or, if MANUAL_SOLENOID_CONTROL, active (or specified) solenoid
+      #endif
+
+      case 400: M400(); break;                                    // M400: Finish all moves
+
+      #if HAS_BED_PROBE
+        case 401: M401(); break;                                  // M401: Deploy probe
+        case 402: M402(); break;                                  // M402: Stow probe
+      #endif
+
+      #if HAS_PRUSA_MMU2
+        case 403: M403(); break;
+      #endif
+
+      #if ENABLED(FILAMENT_WIDTH_SENSOR)
+        case 404: M404(); break;                                  // M404: Enter the nominal filament width (3mm, 1.75mm ) N<3.0> or display nominal filament width
+        case 405: M405(); break;                                  // M405: Turn on filament sensor for control
+        case 406: M406(); break;                                  // M406: Turn off filament sensor for control
+        case 407: M407(); break;                                  // M407: Display measured filament diameter
+      #endif
+
+      #if HAS_FILAMENT_SENSOR
+        case 412: M412(); break;                                  // M412: Enable/Disable filament runout detection
+      #endif
+
+      #if HAS_MULTI_LANGUAGE
+        case 414: M414(); break;                                  // M414: Select multi language menu
+      #endif
+
+      #if HAS_LEVELING
+        case 420: M420(); break;                                  // M420: Enable/Disable Bed Leveling
+      #endif
+
+      #if HAS_MESH
+        case 421: M421(); break;                                  // M421: Set a Mesh Bed Leveling Z coordinate
+      #endif
+
+      #if ENABLED(BACKLASH_GCODE)
+        case 425: M425(); break;                                  // M425: Tune backlash compensation
+      #endif
+
+      #if HAS_M206_COMMAND
+        case 428: M428(); break;                                  // M428: Apply current_position to home_offset
+      #endif
+
+      #if HAS_POWER_MONITOR
+        case 430: M430(); break;                                  // M430: Read the system current (A), voltage (V), and power (W)
+      #endif
+
+      #if ENABLED(CANCEL_OBJECTS)
+        case 486: M486(); break;                                  // M486: Identify and cancel objects
+      #endif
+
+      case 500: M500(); break;                                    // M500: Store settings in EEPROM
+      case 501: M501(); break;                                    // M501: Read settings from EEPROM
+      case 502: M502(); break;                                    // M502: Revert to default settings
+      #if DISABLED(DISABLE_M503)
+        case 503: M503(); break;                                  // M503: print settings currently in memory
+      #endif
+      #if ENABLED(EEPROM_SETTINGS)
+        case 504: M504(); break;                                  // M504: Validate EEPROM contents
+      #endif
+
+      #if ENABLED(PASSWORD_FEATURE)
+        case 510: M510(); break;                                  // M510: Lock Printer
+        #if ENABLED(PASSWORD_UNLOCK_GCODE)
+          case 511: M511(); break;                                // M511: Unlock Printer
+        #endif
+        #if ENABLED(PASSWORD_CHANGE_GCODE)
+          case 512: M512(); break;                                // M512: Set/Change/Remove Password
+        #endif
+      #endif
+
+      #if ENABLED(SDSUPPORT)
+        case 524: M524(); break;                                  // M524: Abort the current SD print job
+      #endif
+
+      #if ENABLED(SD_ABORT_ON_ENDSTOP_HIT)
+        case 540: M540(); break;                                  // M540: Set abort on endstop hit for SD printing
+      #endif
+
+      #if HAS_ETHERNET
+        case 552: M552(); break;                                  // M552: Set IP address
+        case 553: M553(); break;                                  // M553: Set gateway
+        case 554: M554(); break;                                  // M554: Set netmask
+      #endif
+
+      #if ENABLED(BAUD_RATE_GCODE)
+        case 575: M575(); break;                                  // M575: Set serial baudrate
+      #endif
+
+      #if ENABLED(ADVANCED_PAUSE_FEATURE)
+        case 600: M600(); break;                                  // M600: Pause for Filament Change
+        case 603: M603(); break;                                  // M603: Configure Filament Change
+      #endif
+
+      #if HAS_DUPLICATION_MODE
+        case 605: M605(); break;                                  // M605: Set Dual X Carriage movement mode
+      #endif
+
+      #if ENABLED(DELTA)
+        case 665: M665(); break;                                  // M665: Set delta configurations
+      #endif
+
+      #if ENABLED(DELTA) || HAS_EXTRA_ENDSTOPS
+        case 666: M666(); break;                                  // M666: Set delta or multiple endstop adjustment
+      #endif
+
+      #if ENABLED(DUET_SMART_EFFECTOR) && PIN_EXISTS(SMART_EFFECTOR_MOD)
+        case 672: M672(); break;                                  // M672: Set/clear Duet Smart Effector sensitivity
+      #endif
+
+      #if ENABLED(FILAMENT_LOAD_UNLOAD_GCODES)
+        case 701: M701(); break;                                  // M701: Load Filament
+        case 702: M702(); break;                                  // M702: Unload Filament
+      #endif
+
+      #if ENABLED(CONTROLLER_FAN_EDITABLE)
+        case 710: M710(); break;                                  // M710: Set Controller Fan settings
+      #endif
+
+      #if ENABLED(GCODE_MACROS)
+        case 810: case 811: case 812: case 813: case 814:
+        case 815: case 816: case 817: case 818: case 819:
+        M810_819(); break;                                        // M810-M819: Define/execute G-code macro
+      #endif
+
+      #if HAS_BED_PROBE
+        case 851: M851(); break;                                  // M851: Set Z Probe Z Offset
+      #endif
+
+      #if ENABLED(SKEW_CORRECTION_GCODE)
+        case 852: M852(); break;                                  // M852: Set Skew factors
+      #endif
+
+      #if ENABLED(PROBE_TEMP_COMPENSATION)
+        case 192: M192(); break;                                  // M192: Wait for probe temp
+        case 871: M871(); break;                                  // M871: Print/reset/clear first layer temperature offset values
+      #endif
+
+      #if ENABLED(LIN_ADVANCE)
+        case 900: M900(); break;                                  // M900: Set advance K factor.
+      #endif
+
+      #if ANY(HAS_MOTOR_CURRENT_SPI, HAS_MOTOR_CURRENT_PWM, HAS_MOTOR_CURRENT_I2C, HAS_MOTOR_CURRENT_DAC)
+        case 907: M907(); break;                                  // M907: Set digital trimpot motor current using axis codes.
+        #if EITHER(HAS_MOTOR_CURRENT_SPI, HAS_MOTOR_CURRENT_DAC)
+          case 908: M908(); break;                                // M908: Control digital trimpot directly.
+          #if ENABLED(HAS_MOTOR_CURRENT_DAC)
+            case 909: M909(); break;                              // M909: Print digipot/DAC current value
+            case 910: M910(); break;                              // M910: Commit digipot/DAC value to external EEPROM
+          #endif
+        #endif
+      #endif
+
+      #if HAS_TRINAMIC_CONFIG
+        case 122: M122(); break;                                  // M122: Report driver configuration and status
+        case 906: M906(); break;                                  // M906: Set motor current in milliamps using axis codes X, Y, Z, E
+        #if HAS_STEALTHCHOP
+          case 569: M569(); break;                                // M569: Enable stealthChop on an axis.
+        #endif
+        #if ENABLED(MONITOR_DRIVER_STATUS)
+          case 911: M911(); break;                                // M911: Report TMC2130 prewarn triggered flags
+          case 912: M912(); break;                                // M912: Clear TMC2130 prewarn triggered flags
+        #endif
+        #if ENABLED(HYBRID_THRESHOLD)
+          case 913: M913(); break;                                // M913: Set HYBRID_THRESHOLD speed.
+        #endif
+        #if USE_SENSORLESS
+          case 914: M914(); break;                                // M914: Set StallGuard sensitivity.
+        #endif
+      #endif
+
+      #if HAS_L64XX
+        case 122: M122(); break;                                   // M122: Report status
+        case 906: M906(); break;                                   // M906: Set or get motor drive level
+        case 916: M916(); break;                                   // M916: L6470 tuning: Increase drive level until thermal warning
+        case 917: M917(); break;                                   // M917: L6470 tuning: Find minimum current thresholds
+        case 918: M918(); break;                                   // M918: L6470 tuning: Increase speed until max or error
+      #endif
+
+      #if HAS_MICROSTEPS
+        case 350: M350(); break;                                  // M350: Set microstepping mode. Warning: Steps per unit remains unchanged. S code sets stepping mode for all drivers.
+        case 351: M351(); break;                                  // M351: Toggle MS1 MS2 pins directly, S# determines MS1 or MS2, X# sets the pin high/low.
+      #endif
+
+      #if ENABLED(CASE_LIGHT_ENABLE)
+        case 355: M355(); break;                                  // M355: Set case light brightness
+      #endif
+
+      #if ENABLED(DEBUG_GCODE_PARSER)
+        case 800: parser.debug(); break;                          // M800: GCode Parser Test for M
+      #endif
+
+      #if ENABLED(GCODE_REPEAT_MARKERS)
+        case 808: M808(); break;                                  // M808: Set / Goto repeat markers
+      #endif
+
+      #if ENABLED(I2C_POSITION_ENCODERS)
+        case 860: M860(); break;                                  // M860: Report encoder module position
+        case 861: M861(); break;                                  // M861: Report encoder module status
+        case 862: M862(); break;                                  // M862: Perform axis test
+        case 863: M863(); break;                                  // M863: Calibrate steps/mm
+        case 864: M864(); break;                                  // M864: Change module address
+        case 865: M865(); break;                                  // M865: Check module firmware version
+        case 866: M866(); break;                                  // M866: Report axis error count
+        case 867: M867(); break;                                  // M867: Toggle error correction
+        case 868: M868(); break;                                  // M868: Set error correction threshold
+        case 869: M869(); break;                                  // M869: Report axis error
+      #endif
+
+      #if ENABLED(MAGNETIC_PARKING_EXTRUDER)
+        case 951: M951(); break;                                  // M951: Set Magnetic Parking Extruder parameters
+      #endif
+
+      #if ENABLED(Z_STEPPER_AUTO_ALIGN)
+        case 422: M422(); break;                                  // M422: Set Z Stepper automatic alignment position using probe
+      #endif
+
+      #if ALL(HAS_SPI_FLASH, SDSUPPORT, MARLIN_DEV_MODE)
+        case 993: M993(); break;                                  // M993: Backup SPI Flash to SD
+        case 994: M994(); break;                                  // M994: Load a Backup from SD to SPI Flash
+      #endif
+
+      #if ENABLED(TOUCH_SCREEN_CALIBRATION)
+        case 995: M995(); break;                                  // M995: Touch screen calibration for TFT display
+      #endif
+
+      #if ENABLED(PLATFORM_M997_SUPPORT)
+        case 997: M997(); break;                                  // M997: Perform in-application firmware update
+      #endif
+
+      case 999: M999(); break;                                    // M999: Restart after being Stopped
+
+      #if ENABLED(POWER_LOSS_RECOVERY)
+        case 413: M413(); break;                                  // M413: Enable/disable/query Power-Loss Recovery
+        case 1000: M1000(); break;                                // M1000: [INTERNAL] Resume from power-loss
+      #endif
+
+      #if ENABLED(SDSUPPORT)
+        case 1001: M1001(); break;                                // M1001: [INTERNAL] Handle SD completion
+      #endif
+
+      #if ENABLED(MAX7219_GCODE)
+        case 7219: M7219(); break;                                // M7219: Set LEDs, columns, and rows
+      #endif
+
+      default: parser.unknown_command_warning(); break;
+    }
+    break;
+
+    case 'T': T(parser.codenum); break;                           // Tn: Tool Change
+
+    #if ENABLED(MARLIN_DEV_MODE)
+      case 'D': D(parser.codenum); break;                         // Dn: Debug codes
+    #endif
+
+    default:
+      #if ENABLED(WIFI_CUSTOM_COMMAND)
+        if (wifi_custom_command(parser.command_ptr)) break;
+      #endif
+      parser.unknown_command_warning();
+  }
+
+  if (!no_ok) queue.ok_to_send();
+
+  SERIAL_OUT(msgDone); // Call the msgDone serial hook to signal command processing done
+}
+
+/**
+ * Process a single command and dispatch it to its handler
+ * This is called from the main loop()
+ */
+void GcodeSuite::process_next_command() {
+  char * const current_command = queue.command_buffer[queue.index_r];
+
+  PORT_REDIRECT(SERIAL_PORTMASK(queue.port[queue.index_r]));
+
+  #if ENABLED(POWER_LOSS_RECOVERY)
+    recovery.queue_index_r = queue.index_r;
+  #endif
+
+  if (DEBUGGING(ECHO)) {
+    SERIAL_ECHO_START();
+    SERIAL_ECHOLN(current_command);
+    #if ENABLED(M100_FREE_MEMORY_DUMPER)
+      SERIAL_ECHOPAIR("slot:", queue.index_r);
+      M100_dump_routine(PSTR("   Command Queue:"), &queue.command_buffer[0][0], &queue.command_buffer[BUFSIZE - 1][MAX_CMD_SIZE - 1]);
+    #endif
+  }
+
+  // Parse the next command in the queue
+  parser.parse(current_command);
+  process_parsed_command();
+}
+
+/**
+ * Run a series of commands, bypassing the command queue to allow
+ * G-code "macros" to be called from within other G-code handlers.
+ */
+
+void GcodeSuite::process_subcommands_now_P(PGM_P pgcode) {
+  char * const saved_cmd = parser.command_ptr;        // Save the parser state
+  for (;;) {
+    PGM_P const delim = strchr_P(pgcode, '\n');       // Get address of next newline
+    const size_t len = delim ? delim - pgcode : strlen_P(pgcode); // Get the command length
+    char cmd[len + 1];                                // Allocate a stack buffer
+    strncpy_P(cmd, pgcode, len);                      // Copy the command to the stack
+    cmd[len] = '\0';                                  // End with a nul
+    parser.parse(cmd);                                // Parse the command
+    process_parsed_command(true);                     // Process it
+    if (!delim) break;                                // Last command?
+    pgcode = delim + 1;                               // Get the next command
+  }
+  parser.parse(saved_cmd);                            // Restore the parser state
+}
+
+void GcodeSuite::process_subcommands_now(char * gcode) {
+  char * const saved_cmd = parser.command_ptr;        // Save the parser state
+  for (;;) {
+    char * const delim = strchr(gcode, '\n');         // Get address of next newline
+    if (delim) *delim = '\0';                         // Replace with nul
+    parser.parse(gcode);                              // Parse the current command
+    if (delim) *delim = '\n';                         // Put back the newline
+    process_parsed_command(true);                     // Process it
+    if (!delim) break;                                // Last command?
+    gcode = delim + 1;                                // Get the next command
+  }
+  parser.parse(saved_cmd);                            // Restore the parser state
+}
+
+#if ENABLED(HOST_KEEPALIVE_FEATURE)
+
+  /**
+   * Output a "busy" message at regular intervals
+   * while the machine is not accepting commands.
+   */
+  void GcodeSuite::host_keepalive() {
+    const millis_t ms = millis();
+    static millis_t next_busy_signal_ms = 0;
+    if (!autoreport_paused && host_keepalive_interval && busy_state != NOT_BUSY) {
+      if (PENDING(ms, next_busy_signal_ms)) return;
+      switch (busy_state) {
+        case IN_HANDLER:
+        case IN_PROCESS:
+          SERIAL_ECHO_MSG(STR_BUSY_PROCESSING);
+          break;
+        case PAUSED_FOR_USER:
+          SERIAL_ECHO_MSG(STR_BUSY_PAUSED_FOR_USER);
+          break;
+        case PAUSED_FOR_INPUT:
+          SERIAL_ECHO_MSG(STR_BUSY_PAUSED_FOR_INPUT);
+          break;
+        default:
+          break;
+      }
+    }
+    next_busy_signal_ms = ms + SEC_TO_MS(host_keepalive_interval);
+  }
+
+#endif // HOST_KEEPALIVE_FEATURE