Save some string flash

Marlin/src/Marlin.cpp

   #include "libs/L6470/L6470_Marlin.h"
 #endif
 
+const char G28_STR[] PROGMEM = "G28",
+           M21_STR[] PROGMEM = "M21",
+           M23_STR[] PROGMEM = "M23 %s",
+           M24_STR[] PROGMEM = "M24";
+
 bool Running = true;
 
 // For M109 and M190, this flag may be cleared (by M108) to exit the wait loop
       if (ELAPSED(ms, next_home_key_ms)) {
         next_home_key_ms = ms + HOME_DEBOUNCE_DELAY;
         LCD_MESSAGEPGM(MSG_AUTO_HOME);
-        queue.enqueue_now_P(PSTR("G28"));
+        queue.enqueue_now_P(G28_STR);
       }
     }
   #endif

Marlin/src/Marlin.h

   void event_probe_recover();
   void event_probe_failure();
 #endif
+
+extern const char G28_STR[], M21_STR[], M23_STR[], M24_STR[];

Marlin/src/feature/host_actions.cpp

       case PROMPT_PAUSE_RESUME:
         msg = PSTR("LCD_PAUSE_RESUME");
         #if ENABLED(ADVANCED_PAUSE_FEATURE)
-          queue.inject_P(PSTR("M24"));
+          extern const char M24_STR[];
+          queue.inject_P(M24_STR);
         #endif
         break;
       case PROMPT_INFO:

Marlin/src/feature/power_loss_recovery.cpp

       #if EXTRUDERS > 1
         for (int8_t e = 0; e < EXTRUDERS; e++) info.filament_size[e] = planner.filament_size[e];
       #else
-        if (parser.volumetric_enabled) info.filament_size = planner.filament_size[active_extruder]; 
-      #endif    
+        if (parser.volumetric_enabled) info.filament_size = planner.filament_size[active_extruder];
+      #endif
     #endif
 
     #if EXTRUDERS
   #endif
 
   // Recover volumetric extrusion state
-  #if DISABLED(NO_VOLUMETRICS)    
+  #if DISABLED(NO_VOLUMETRICS)
     #if EXTRUDERS > 1
       for (int8_t e = 0; e < EXTRUDERS; e++) {
         dtostrf(info.filament_size[e], 1, 3, str_1);
 
   // Resume the SD file from the last position
   char *fn = info.sd_filename;
-  sprintf_P(cmd, PSTR("M23 %s"), fn);
+  extern const char M23_STR[];
+  sprintf_P(cmd, M23_STR, fn);
   gcode.process_subcommands_now(cmd);
   sprintf_P(cmd, PSTR("M24 S%ld T%ld"), resume_sdpos, info.print_job_elapsed);
   gcode.process_subcommands_now(cmd);

Marlin/src/gcode/feature/L6470/M906.cpp

   SERIAL_ECHO(temp_buf);
 
   SERIAL_ECHOPGM("   Motor Status: ");
-  const char * const stat_str;
+  const char *stat_str;
   switch (motor_status) {
     default:
     case 0: stat_str = PSTR("stopped"); break;
   SERIAL_ECHOPGM("   Vs_compensation: ");
   serialprintPGM((motor.GetParam(L6470_CONFIG) & CONFIG_EN_VSCOMP) ? PSTR("ENABLED ") : PSTR("DISABLED"));
 
-  SERIAL_ECHOLNPGM("   Compensation coefficient: ", dtostrf(comp_coef * 0.01f, 7, 2, numstr));
+  SERIAL_ECHOLNPAIR("   Compensation coefficient: ", dtostrf(comp_coef * 0.01f, 7, 2, numstr));
   SERIAL_ECHOPAIR("...KVAL_HOLD: ", motor.GetParam(L6470_KVAL_HOLD));
   SERIAL_ECHOPAIR("   KVAL_RUN : ", motor.GetParam(L6470_KVAL_RUN));
   SERIAL_ECHOPAIR("   KVAL_ACC: ", motor.GetParam(L6470_KVAL_ACC));

Marlin/src/gcode/feature/L6470/M916-918.cpp

   char gcode_string[30], str1[11], str2[11];
 
   // Turn the motor(s) both directions
-  sprintf_P(gcode_string, PSTR("G0 %c%s F%s"), axis_char, dtostrf(min, 1, 3, str1), dtostrf(rate, 1, 3, str2));
-  process_subcommands_now(gcode_string);
+  sprintf_P(gcode_string, PSTR("G0 %c%s F%s"), axis_char, dtostrf(min, 1, 3, str1), dtostrf(fr_mm_m, 1, 3, str2));
+  gcode.process_subcommands_now(gcode_string);
 
   sprintf_P(gcode_string, PSTR("G0 %c%s F%s"), axis_char, dtostrf(max, 1, 3, str1), str2);
-  process_subcommands_now(gcode_string);
+  gcode.process_subcommands_now(gcode_string);
 
   planner.synchronize();
 }

Marlin/src/gcode/gcode.h

   static void process_subcommands_now_P(PGM_P pgcode);
   static void process_subcommands_now(char * gcode);
 
-  static inline void home_all_axes() { process_subcommands_now_P(PSTR("G28")); }
+  static inline void home_all_axes() {
+    extern const char G28_STR[];
+    process_subcommands_now_P(G28_STR);
+  }
 
   #if ENABLED(HOST_KEEPALIVE_FEATURE)
     /**

Marlin/src/lcd/extensible_ui/lib/lulzbot/screens/stress_test_screen.cpp

 
   if (!commandsInQueue()) {
       if (!isPositionKnown()) {
-        injectCommands_P(PSTR("G28"));
+        injectCommands_P(G28_STR);
       } else {
         injectCommands_P(PSTR(
           "G0 X100 Y100 Z100 F6000\n"

Marlin/src/lcd/extui_malyan_lcd.cpp

         ExtUI::stopPrint();
         write_to_lcd_P(PSTR("{SYS:STARTED}"));
         break;
-    case 'H': queue.enqueue_now_P(PSTR("G28")); break; // Home all axes
+    case 'H': queue.enqueue_now_P(G28_STR); break; // Home all axes
     default: {
       #if ENABLED(SDSUPPORT)
         // Print file 000 - a three digit number indicating which

Marlin/src/lcd/menu/menu_bed_corners.cpp

   ui.defer_status_screen();
   if (!all_axes_known()) {
     set_all_unhomed();
-    queue.inject_P(PSTR("G28"));
+    queue.inject_P(G28_STR);
   }
 
   // Disable leveling so the planner won't mess with us

Marlin/src/lcd/menu/menu_bed_leveling.cpp

     ui.defer_status_screen();
     set_all_unhomed();
     ui.goto_screen(_lcd_level_bed_homing);
-    queue.inject_P(PSTR("G28"));
+    queue.inject_P(G28_STR);
   }
 
 #endif // PROBE_MANUALLY || MESH_BED_LEVELING
 
   // Auto Home if not using manual probing
   #if NONE(PROBE_MANUALLY, MESH_BED_LEVELING)
-    if (!is_homed) GCODES_ITEM(MSG_AUTO_HOME, PSTR("G28"));
+    if (!is_homed) GCODES_ITEM(MSG_AUTO_HOME, G28_STR);
   #endif
 
   // Level Bed

Marlin/src/lcd/menu/menu_configuration.cpp

 
     auto _recalc_offsets = []{
       if (active_extruder && all_axes_known()) {  // For the 2nd extruder re-home so the next tool-change gets the new offsets.
-        queue.inject_P(PSTR("G28")); // In future, we can babystep the 2nd extruder (if active), making homing unnecessary.
+        queue.inject_P(G28_STR); // In future, we can babystep the 2nd extruder (if active), making homing unnecessary.
         active_extruder = 0;
       }
     };

Marlin/src/lcd/menu/menu_delta_calibrate.cpp

   }
 
   void _lcd_delta_calibrate_home() {
-    queue.inject_P(PSTR("G28"));
+    queue.inject_P(G28_STR);
     ui.goto_screen(_lcd_calibrate_homing);
   }
 

Marlin/src/lcd/menu/menu_main.cpp

   #endif
 #endif
 
+extern const char M21_STR[];
+
 void menu_main() {
   START_MENU();
   BACK_ITEM(MSG_WATCH);
           SUBMENU(MSG_MEDIA_MENU, menu_media);
           MENU_ITEM(gcode,
             #if PIN_EXISTS(SD_DETECT)
-              MSG_CHANGE_MEDIA, PSTR("M21")
+              MSG_CHANGE_MEDIA, M21_STR
             #else
               MSG_RELEASE_MEDIA, PSTR("M22")
             #endif
         #if PIN_EXISTS(SD_DETECT)
           ACTION_ITEM(MSG_NO_MEDIA, nullptr);
         #else
-          GCODES_ITEM(MSG_INIT_MEDIA, PSTR("M21"));
+          GCODES_ITEM(MSG_INIT_MEDIA, M21_STR);
           ACTION_ITEM(MSG_MEDIA_RELEASED, nullptr);
         #endif
       }
       if (!card_open) {
         MENU_ITEM(gcode,
           #if PIN_EXISTS(SD_DETECT)
-            MSG_CHANGE_MEDIA, PSTR("M21")
+            MSG_CHANGE_MEDIA, M21_STR
           #else
             MSG_RELEASE_MEDIA, PSTR("M22")
           #endif
       #if PIN_EXISTS(SD_DETECT)
         ACTION_ITEM(MSG_NO_MEDIA, nullptr);
       #else
-        GCODES_ITEM(MSG_INIT_MEDIA, PSTR("M21"));
+        GCODES_ITEM(MSG_INIT_MEDIA, M21_STR);
         ACTION_ITEM(MSG_MEDIA_RELEASED, nullptr);
       #endif
     }

Marlin/src/lcd/menu/menu_motion.cpp

     SUBMENU(MSG_MOVE_Z, []{ _menu_move_distance(Z_AXIS, lcd_move_z); });
   }
   else
-    GCODES_ITEM(MSG_AUTO_HOME, PSTR("G28"));
+    GCODES_ITEM(MSG_AUTO_HOME, G28_STR);
 
   #if ANY(SWITCHING_EXTRUDER, SWITCHING_NOZZLE, MAGNETIC_SWITCHING_TOOLHEAD)
 
   //
   // Auto Home
   //
-  GCODES_ITEM(MSG_AUTO_HOME, PSTR("G28"));
+  GCODES_ITEM(MSG_AUTO_HOME, G28_STR);
   #if ENABLED(INDIVIDUAL_AXIS_HOMING_MENU)
     GCODES_ITEM(MSG_AUTO_HOME_X, PSTR("G28 X"));
     GCODES_ITEM(MSG_AUTO_HOME_Y, PSTR("G28 Y"));

Marlin/src/lcd/menu/menu_ubl.cpp

  */
 void _lcd_ubl_build_custom_mesh() {
   char ubl_lcd_gcode[20];
-  queue.inject_P(PSTR("G28"));
+  queue.inject_P(G28_STR);
   #if HAS_HEATED_BED
     sprintf_P(ubl_lcd_gcode, PSTR("M190 S%i"), custom_bed_temp);
     lcd_enqueue_one_now(ubl_lcd_gcode);
     #endif
   ;
   sprintf_P(ubl_lcd_gcode, PSTR("G26 C B%i H%i P"), temp, custom_hotend_temp);
-  lcd_enqueue_one_now_P(PSTR("G28"));
+  lcd_enqueue_one_now_P(G28_STR);
   lcd_enqueue_one_now(ubl_lcd_gcode);
 }
 
 void _lcd_ubl_output_map_lcd_cmd() {
   if (!all_axes_known()) {
     set_all_unhomed();
-    queue.inject_P(PSTR("G28"));
+    queue.inject_P(G28_STR);
   }
   ui.goto_screen(_lcd_ubl_map_homing);
 }

Marlin/src/lcd/ultralcd.cpp

 
         #endif // HAS_LCD_MENU
 
-        if (!homed && RRK(EN_KEYPAD_F1)) queue.inject_P(PSTR("G28"));
+        if (!homed && RRK(EN_KEYPAD_F1)) queue.inject_P(G28_STR);
         return true;
       }
 
     #if ENABLED(PARK_HEAD_ON_PAUSE)
       wait_for_heatup = wait_for_user = false;
     #endif
-    if (IS_SD_PAUSED()) queue.inject_P(PSTR("M24"));
+    if (IS_SD_PAUSED()) queue.inject_P(M24_STR);
     #ifdef ACTION_ON_RESUME
       host_action_resume();
     #endif

Marlin/src/sd/cardreader.cpp

 
 void CardReader::openAndPrintFile(const char *name) {
   char cmd[4 + strlen(name) + 1]; // Room for "M23 ", filename, and null
-  sprintf_P(cmd, PSTR("M23 %s"), name);
+  extern const char M23_STR[];
+  sprintf_P(cmd, M23_STR, name);
   for (char *c = &cmd[4]; *c; c++) *c = tolower(*c);
   queue.enqueue_one_now(cmd);
-  queue.enqueue_now_P(PSTR("M24"));
+  queue.enqueue_now_P(M24_STR);
 }
 
 void CardReader::startFileprint() {