🎨 Apply F() to G-code suite and queue

Marlin/src/MarlinCore.cpp

     TERN_(POWER_LOSS_RECOVERY, recovery.purge());
 
     #ifdef EVENT_GCODE_SD_ABORT
-      queue.inject_P(PSTR(EVENT_GCODE_SD_ABORT));
+      queue.inject(F(EVENT_GCODE_SD_ABORT));
     #endif
 
     TERN_(PASSWORD_AFTER_SD_PRINT_ABORT, password.lock_machine());
   }
 
   inline void finishSDPrinting() {
-    if (queue.enqueue_one_P(PSTR("M1001"))) { // Keep trying until it gets queued
-      marlin_state = MF_RUNNING;              // Signal to stop trying
+    if (queue.enqueue_one(F("M1001"))) {  // Keep trying until it gets queued
+      marlin_state = MF_RUNNING;          // Signal to stop trying
       TERN_(PASSWORD_AFTER_SD_PRINT_END, password.lock_machine());
       TERN_(DGUS_LCD_UI_MKS, ScreenHandler.SDPrintingFinished());
     }
         if (ELAPSED(ms, next_cub_ms_##N)) {                            \
           next_cub_ms_##N = ms + CUB_DEBOUNCE_DELAY_##N;               \
           CODE;                                                        \
-          queue.inject_P(PSTR(BUTTON##N##_GCODE));                     \
+          queue.inject(F(BUTTON##N##_GCODE));                     \
           TERN_(HAS_LCD_MENU, ui.quick_feedback());                    \
         }                                                              \
       }                                                                \
 
   #ifdef STARTUP_COMMANDS
     SETUP_LOG("STARTUP_COMMANDS");
-    queue.inject_P(PSTR(STARTUP_COMMANDS));
+    queue.inject(F(STARTUP_COMMANDS));
   #endif
 
   #if ENABLED(HOST_PROMPT_SUPPORT)

Marlin/src/feature/mmu/mmu2.cpp

 }
 
 void MMU2::filament_runout() {
-  queue.inject_P(PSTR(MMU2_FILAMENT_RUNOUT_SCRIPT));
+  queue.inject(F(MMU2_FILAMENT_RUNOUT_SCRIPT));
   planner.synchronize();
 }
 

Marlin/src/feature/powerloss.cpp

   if (card.isMounted()) {
     load();
     if (!valid()) return cancel();
-    queue.inject_P(PSTR("M1000S"));
+    queue.inject(F("M1000S"));
   }
 }
 

Marlin/src/feature/runout.cpp

         SERIAL_ECHOPGM("Runout Command: ");
         SERIAL_ECHOLNPGM(FILAMENT_RUNOUT_SCRIPT);
       #endif
-      queue.inject_P(PSTR(FILAMENT_RUNOUT_SCRIPT));
+      queue.inject(F(FILAMENT_RUNOUT_SCRIPT));
     #endif
   }
 }

Marlin/src/gcode/bedlevel/mbl/G29.cpp

       mbl.reset();
       mbl_probe_index = 0;
       if (!ui.wait_for_move) {
-        queue.inject_P(parser.seen_test('N') ? PSTR("G28" TERN(CAN_SET_LEVELING_AFTER_G28, "L0", "") "\nG29S2") : PSTR("G29S2"));
+        queue.inject(parser.seen_test('N') ? F("G28" TERN(CAN_SET_LEVELING_AFTER_G28, "L0", "") "\nG29S2") : F("G29S2"));
         TERN_(EXTENSIBLE_UI, ExtUI::onMeshLevelingStart());
         return;
       }

Marlin/src/gcode/queue.cpp

  * Enqueue with Serial Echo
  * Return true if the command was consumed
  */
-bool GCodeQueue::enqueue_one(const char *cmd) {
+bool GCodeQueue::enqueue_one(const char * const cmd) {
   //SERIAL_ECHOLNPGM("enqueue_one(\"", cmd, "\")");
 
   if (*cmd == 0 || ISEOL(*cmd)) return true;
  * Enqueue and return only when commands are actually enqueued.
  * Never call this from a G-code handler!
  */
-void GCodeQueue::enqueue_one_now(const char *cmd) { while (!enqueue_one(cmd)) idle(); }
+void GCodeQueue::enqueue_one_now(const char * const cmd) { while (!enqueue_one(cmd)) idle(); }
 
 /**
  * Attempt to enqueue a single G-code command
  * and return 'true' if successful.
  */
-bool GCodeQueue::enqueue_one_P(PGM_P const pgcode) {
+bool GCodeQueue::enqueue_one(FSTR_P const fgcode) {
   size_t i = 0;
-  PGM_P p = pgcode;
+  PGM_P p = FTOP(fgcode);
   char c;
   while ((c = pgm_read_byte(&p[i])) && c != '\n') i++;
   char cmd[i + 1];

Marlin/src/gcode/queue.h

    * Aborts the current PROGMEM queue so only use for one or two commands.
    */
   static inline void inject_P(PGM_P const pgcode) { injected_commands_P = pgcode; }
+  static inline void inject(FSTR_P const fgcode) { inject_P(FTOP(fgcode)); }
 
   /**
    * Enqueue command(s) to run from SRAM. Drained by process_injected_command().
   /**
    * Enqueue and return only when commands are actually enqueued
    */
-  static void enqueue_one_now(const char *cmd);
+  static void enqueue_one_now(const char * const cmd);
 
   /**
    * Attempt to enqueue a single G-code command
    * and return 'true' if successful.
    */
-  static bool enqueue_one_P(PGM_P const pgcode);
+  static bool enqueue_one(FSTR_P const fgcode);
 
   /**
    * Enqueue from program memory and return only when commands are actually enqueued
    */
-  static void enqueue_now_P(PGM_P const cmd);
+  static void enqueue_now_P(PGM_P const pcmd);
+  static inline void enqueue_now(FSTR_P const fcmd) { enqueue_now_P(FTOP(fcmd)); }
 
   /**
    * Check whether there are any commands yet to be executed

Marlin/src/lcd/e3v2/creality/dwin.cpp

     if (select_print.now == PRINT_PAUSE_RESUME) {
       if (HMI_flag.select_flag) {
         HMI_flag.pause_action = true;
-        queue.inject_P(PSTR("M25"));
+        queue.inject(F("M25"));
       }
       Goto_PrintProcess();
     }
         #endif
         break;
 
-      case PREPARE_CASE_DISA: queue.inject_P(PSTR("M84")); break;
+      case PREPARE_CASE_DISA: queue.inject(F("M84")); break;
 
       case PREPARE_CASE_HOME: // Homing
         checkkey = Last_Prepare;
             EncoderRate.enabled = true;
           #else
             // Apply workspace offset, making the current position 0,0,0
-            queue.inject_P(PSTR("G92 X0 Y0 Z0"));
+            queue.inject(F("G92 X0 Y0 Z0"));
             HMI_AudioFeedback();
           #endif
           break;
   void HMI_Leveling() {
     Popup_Window_Leveling();
     DWIN_UpdateLCD();
-    queue.inject_P(PSTR("G28O\nG29"));
+    queue.inject(F("G28O\nG29"));
   }
 #endif
 
             EncoderRate.enabled = true;
           #else
             // Apply workspace offset, making the current position 0,0,0
-            queue.inject_P(PSTR("G92 X0 Y0 Z0"));
+            queue.inject(F("G92 X0 Y0 Z0"));
             HMI_AudioFeedback();
           #endif
         break;
       TERN_(HAS_HEATED_BED, resume_bed_temp = thermalManager.degTargetBed());
       thermalManager.disable_all_heaters();
     #endif
-    queue.inject_P(PSTR("G1 F1200 X0 Y0"));
+    queue.inject(F("G1 F1200 X0 Y0"));
   }
 
   if (card.isPrinting() && checkkey == PrintProcess) { // print process
           if (encoder_diffState == ENCODER_DIFF_ENTER) {
             recovery_flag = false;
             if (HMI_flag.select_flag) break;
-            TERN_(POWER_LOSS_RECOVERY, queue.inject_P(PSTR("M1000C")));
+            TERN_(POWER_LOSS_RECOVERY, queue.inject(F("M1000C")));
             HMI_StartFrame(true);
             return;
           }
 
       select_print.set(0);
       HMI_ValueStruct.show_mode = 0;
-      queue.inject_P(PSTR("M1000"));
+      queue.inject(F("M1000"));
       Goto_PrintProcess();
       Draw_Status_Area(true);
     }

Marlin/src/lcd/e3v2/enhanced/dwin.cpp

 
       case PAGE_INFO_LEVELING:
         #if HAS_ONESTEP_LEVELING
-          queue.inject_P(PSTR("G28XYO\nG28Z\nG29"));  // TODO: 'G29' should be homing when needed. Does it make sense for every LCD to do this differently?
+          queue.inject(F("G28XYO\nG28Z\nG29"));  // TODO: 'G29' should be homing when needed. Does it make sense for every LCD to do this differently?
         #else
           checkkey = Info;
           Draw_Info_Menu();
       if (HMI_flag.select_flag) {
         HMI_flag.pause_action = true;
         ICON_Resume();
-        queue.inject_P(PSTR("M25"));
+        queue.inject(F("M25"));
       }
       else {
         // cancel pause
       TERN_(HAS_FAN, resume_fan = thermalManager.fan_speed[0]);
     #endif
     IF_DISABLED(ADVANCED_PAUSE_FEATURE, thermalManager.disable_all_heaters());
-    IF_DISABLED(PARK_HEAD_ON_PAUSE, queue.inject_P(PSTR("G1 F1200 X0 Y0")));
+    IF_DISABLED(PARK_HEAD_ON_PAUSE, queue.inject(F("G1 F1200 X0 Y0")));
   }
 
   if (checkkey == PrintProcess) { // print process
           if (encoder_diffState == ENCODER_DIFF_ENTER) {
             recovery_flag = false;
             if (HMI_flag.select_flag) break;
-            TERN_(POWER_LOSS_RECOVERY, queue.inject_P(PSTR("M1000C")));
+            TERN_(POWER_LOSS_RECOVERY, queue.inject(F("M1000C")));
             return HMI_StartFrame(true);
           }
           else
       }
 
       select_print.set(PRINT_SETUP);
-      queue.inject_P(PSTR("M1000"));
+      queue.inject(F("M1000"));
       sdprint = true;
       Goto_PrintProcess();
       Draw_Status_Area(true);
   Draw_Info_Menu();
 }
 
-void DisableMotors() { queue.inject_P(PSTR("M84")); }
+void DisableMotors() { queue.inject(F("M84")); }
 
 void AutoHome() { queue.inject_P(G28_STR); }
 
 void SetHome() {
   // Apply workspace offset, making the current position 0,0,0
-  queue.inject_P(PSTR("G92 X0 Y0 Z0"));
+  queue.inject(F("G92 X0 Y0 Z0"));
   HMI_AudioFeedback();
 }
 
   void SetProbeOffsetZ() { SetPFloatOnClick(-10, 10, 2); }
   void ProbeTest() {
     ui.set_status_P(GET_TEXT(MSG_M48_TEST));
-    queue.inject_P(PSTR("G28O\nM48 P10"));
+    queue.inject(F("G28O\nM48 P10"));
   }
 #endif
 
 
   void ChangeFilament() {
     HMI_SaveProcessID(NothingToDo);
-    queue.inject_P(PSTR("M600 B2"));
+    queue.inject(F("M600 B2"));
   }
 
   void ParkHead(){
     ui.set_status_P(GET_TEXT(MSG_FILAMENT_PARK_ENABLED));
-    queue.inject_P(PSTR("G28O\nG27"));
+    queue.inject(F("G28O\nG27"));
   }
 
   #if ENABLED(FILAMENT_LOAD_UNLOAD_GCODES)
     void UnloadFilament(){
       ui.set_status_P(GET_TEXT(MSG_FILAMENTUNLOAD));
-      queue.inject_P(PSTR("M702 Z20"));
+      queue.inject(F("M702 Z20"));
     }
 
     void LoadFilament(){
       ui.set_status_P(GET_TEXT(MSG_FILAMENTLOAD));
-      queue.inject_P(PSTR("M701 Z20"));
+      queue.inject(F("M701 Z20"));
     }
   #endif
 
 
   void ManualMeshSave(){
     ui.set_status_P(GET_TEXT(MSG_UBL_STORAGE_MESH_MENU));
-    queue.inject_P(PSTR("M211 S1\nM500"));
+    queue.inject(F("M211 S1\nM500"));
   }
 
 #endif // MESH_BED_LEVELING

Marlin/src/lcd/e3v2/jyersui/dwin.cpp

           if (draw)
             Draw_Menu_Item(row, ICON_CloseMotor, F("Disable Stepper"));
           else
-            queue.inject_P(PSTR("M84"));
+            queue.inject(F("M84"));
           break;
         case PREPARE_HOME:
           if (draw)
               #endif
               TERN_(HAS_FAN, thermalManager.fan_speed[0] = pausefan);
               planner.synchronize();
-              TERN_(SDSUPPORT, queue.inject_P(PSTR("M24")));
+              TERN_(SDSUPPORT, queue.inject(F("M24")));
             #endif
           }
           else {
                 if (IS_SD_PRINTING()) card.pauseSDPrint();
               #endif
               planner.synchronize();
-              queue.inject_P(PSTR("M125"));
+              queue.inject(F("M125"));
               planner.synchronize();
             #else
-              queue.inject_P(PSTR("M25"));
+              queue.inject(F("M25"));
               TERN_(HAS_HOTEND, pausetemp = thermalManager.temp_hotend[0].target);
               TERN_(HAS_HEATED_BED, pausebed = thermalManager.temp_bed.target);
               TERN_(HAS_FAN, pausefan = thermalManager.fan_speed[0]);
         break;
       case Resume:
         if (selection == 0)
-          queue.inject_P(PSTR("M1000"));
+          queue.inject(F("M1000"));
         else {
-          queue.inject_P(PSTR("M1000 C"));
+          queue.inject(F("M1000 C"));
           Draw_Main_Menu();
         }
         break;
     static bool init = true;
     if (init) {
       init = false;
-      queue.inject_P(PSTR("M1000 S"));
+      queue.inject(F("M1000 S"));
     }
   #endif
 }

Marlin/src/lcd/extui/dgus/DGUSScreenHandler.cpp

   void DGUSScreenHandler::HandlePowerLossRecovery(DGUS_VP_Variable &var, void *val_ptr) {
     uint16_t value = swap16(*(uint16_t*)val_ptr);
     if (value) {
-      queue.inject_P(PSTR("M1000"));
+      queue.inject(F("M1000"));
       dgusdisplay.WriteVariable(VP_SD_Print_Filename, filelist.filename(), 32, true);
       GotoScreen(PLR_SCREEN_RECOVER);
     }

Marlin/src/lcd/extui/dgus/fysetc/DGUSScreenHandler.cpp

     bool old_relative_mode = relative_mode;
     if (!relative_mode) {
       //DEBUG_ECHOPGM(" G91");
-      queue.enqueue_now_P(PSTR("G91"));
+      queue.enqueue_now(F("G91"));
       //DEBUG_ECHOPGM(" ✓ ");
     }
     char buf[32]; // G1 X9999.99 F12345
     //DEBUG_ECHOLNPGM(" ✓ ");
     if (!old_relative_mode) {
       //DEBUG_ECHOPGM("G90");
-      queue.enqueue_now_P(PSTR("G90"));
+      queue.enqueue_now(F("G90"));
       //DEBUG_ECHOPGM(" ✓ ");
     }
   }

Marlin/src/lcd/extui/dgus/hiprecy/DGUSScreenHandler.cpp

     bool old_relative_mode = relative_mode;
     if (!relative_mode) {
       //DEBUG_ECHOPGM(" G91");
-      queue.enqueue_now_P(PSTR("G91"));
+      queue.enqueue_now(F("G91"));
       //DEBUG_ECHOPGM(" ✓ ");
     }
     char buf[32]; // G1 X9999.99 F12345
     //DEBUG_ECHOLNPGM(" ✓ ");
     if (!old_relative_mode) {
       //DEBUG_ECHOPGM("G90");
-      queue.enqueue_now_P(PSTR("G90"));
+      queue.enqueue_now(F("G90"));
       //DEBUG_ECHOPGM(" ✓ ");
     }
   }

Marlin/src/lcd/extui/dgus/mks/DGUSScreenHandler.cpp

           a_first_level = 0;
           queue.enqueue_now_P(G28_STR);
         }
-        queue.enqueue_now_P(PSTR("G29"));
+        queue.enqueue_now(F("G29"));
 
       #elif ENABLED(MESH_BED_LEVELING)
 
         Deci2 = offset * 100;
         Deci2 = Deci2 % 10;
         soft_endstop._enabled = false;
-        queue.enqueue_now_P(PSTR("G91"));
+        queue.enqueue_now(F("G91"));
         snprintf_P(cmd_buf, 30, PSTR("G1 Z%d.%d%d"), integer, Deci, Deci2);
         queue.enqueue_one_now(cmd_buf);
-        queue.enqueue_now_P(PSTR("G90"));
+        queue.enqueue_now(F("G90"));
         //soft_endstop._enabled = true;
         break;
 
         Deci2 = offset * 100;
         Deci2 = Deci2 % 10;
         soft_endstop._enabled = false;
-        queue.enqueue_now_P(PSTR("G91"));
+        queue.enqueue_now(F("G91"));
         snprintf_P(cmd_buf, 30, PSTR("G1 Z-%d.%d%d"), integer, Deci, Deci2);
         queue.enqueue_one_now(cmd_buf);
-        queue.enqueue_now_P(PSTR("G90"));
+        queue.enqueue_now(F("G90"));
         break;
 
       case 2:
         if (mesh_point_count == GRID_MAX_POINTS) { // The first point
 
-          queue.enqueue_now_P(PSTR("G28"));
-          queue.enqueue_now_P(PSTR("G29S1"));
+          queue.enqueue_now(F("G28"));
+          queue.enqueue_now(F("G29S1"));
           mesh_point_count--;
 
           if (mks_language_index == MKS_English) {
           }
         }
         else if (mesh_point_count > 1) {                              // 倒数第二个点
-          queue.enqueue_now_P(PSTR("G29S2"));
+          queue.enqueue_now(F("G29S2"));
           mesh_point_count--;
           if (mks_language_index == MKS_English) {
             const char level_buf_en2[] = "Next Point";
           }
         }
         else if (mesh_point_count == 1) {
-          queue.enqueue_now_P(PSTR("G29S2"));
+          queue.enqueue_now(F("G29S2"));
           mesh_point_count--;
           if (mks_language_index == MKS_English) {
             const char level_buf_en2[] = "Level Finsh";
   };
 
   if (WITHIN(point_value, 0x0001, 0x0005))
-    queue.enqueue_now_P(PSTR("G1Z10"));
+    queue.enqueue_now(F("G1Z10"));
 
   switch (point_value) {
     case 0x0001:
       enqueue_corner_move(X_MIN_POS + ABS(mks_corner_offsets[0].x),
                           Y_MIN_POS + ABS(mks_corner_offsets[0].y), level_speed);
-      queue.enqueue_now_P(PSTR("G28Z"));
+      queue.enqueue_now(F("G28Z"));
       break;
     case 0x0002:
       enqueue_corner_move(X_MAX_POS - ABS(mks_corner_offsets[1].x),
   }
 
   if (WITHIN(point_value, 0x0002, 0x0005)) {
-    //queue.enqueue_now_P(PSTR("G28Z"));
-    queue.enqueue_now_P(PSTR("G1Z-10"));
+    //queue.enqueue_now(F("G28Z"));
+    queue.enqueue_now(F("G1Z-10"));
   }
 }
 
 
     if (!relative_mode) {
       //DEBUG_ECHOPGM(" G91");
-      queue.enqueue_now_P(PSTR("G91"));
+      queue.enqueue_now(F("G91"));
       //DEBUG_ECHOPGM(" ✓ ");
     }
     char buf[32]; // G1 X9999.99 F12345
     //DEBUG_ECHOLNPGM(" ✓ ");
     if (!old_relative_mode) {
       //DEBUG_ECHOPGM("G90");
-      //queue.enqueue_now_P(PSTR("G90"));
-      queue.enqueue_now_P(PSTR("G90"));
+      //queue.enqueue_now(F("G90"));
+      queue.enqueue_now(F("G90"));
       //DEBUG_ECHOPGM(" ✓ ");
     }
   }
     switch (flag) {
       case 0:
         if (step == 0.01)
-          queue.inject_P(PSTR("M290 Z-0.01"));
+          queue.inject(F("M290 Z-0.01"));
         else if (step == 0.1)
-          queue.inject_P(PSTR("M290 Z-0.1"));
+          queue.inject(F("M290 Z-0.1"));
         else if (step == 0.5)
-          queue.inject_P(PSTR("M290 Z-0.5"));
+          queue.inject(F("M290 Z-0.5"));
         else if (step == 1)
-          queue.inject_P(PSTR("M290 Z-1"));
+          queue.inject(F("M290 Z-1"));
         else
-          queue.inject_P(PSTR("M290 Z-0.01"));
+          queue.inject(F("M290 Z-0.01"));
 
         z_offset_add = z_offset_add - ZOffset_distance;
         break;
 
       case 1:
         if (step == 0.01)
-          queue.inject_P(PSTR("M290 Z0.01"));
+          queue.inject(F("M290 Z0.01"));
         else if (step == 0.1)
-          queue.inject_P(PSTR("M290 Z0.1"));
+          queue.inject(F("M290 Z0.1"));
         else if (step == 0.5)
-          queue.inject_P(PSTR("M290 Z0.5"));
+          queue.inject(F("M290 Z0.5"));
         else if (step == 1)
-          queue.inject_P(PSTR("M290 Z1"));
+          queue.inject(F("M290 Z1"));
         else
-          queue.inject_P(PSTR("M290 Z-0.01"));
+          queue.inject(F("M290 Z-0.01"));
 
         z_offset_add = z_offset_add + ZOffset_distance;
         break;
 
       case RUNOUT_STATUS:
         runout_mks.runout_status = RUNOUT_BEGIN_STATUS;
-        queue.inject_P(PSTR("M25"));
+        queue.inject(F("M25"));
         GotoScreen(MKSLCD_SCREEN_PAUSE);
 
         sendinfoscreen(PSTR("NOTICE"), nullptr, PSTR("Please change filament!"), nullptr, true, true, true, true);

Marlin/src/lcd/extui/dgus/origin/DGUSScreenHandler.cpp

     bool old_relative_mode = relative_mode;
     if (!relative_mode) {
       //DEBUG_ECHOPGM(" G91");
-      queue.enqueue_now_P(PSTR("G91"));
+      queue.enqueue_now(F("G91"));
       //DEBUG_ECHOPGM(" ✓ ");
     }
     char buf[32]; // G1 X9999.99 F12345
     //DEBUG_ECHOLNPGM(" ✓ ");
     if (!old_relative_mode) {
       //DEBUG_ECHOPGM("G90");
-      queue.enqueue_now_P(PSTR("G90"));
+      queue.enqueue_now(F("G90"));
       //DEBUG_ECHOPGM(" ✓ ");
     }
   }

Marlin/src/lcd/extui/dgus_reloaded/DGUSRxHandler.cpp

   dgus_screen_handler.TriggerScreenChange(DGUS_Screen::LEVELING_PROBING);
 
   #if ENABLED(AUTO_BED_LEVELING_UBL)
-    queue.enqueue_now_P(PSTR("G29P1\nG29P3\nG29P5C"));
+    queue.enqueue_now(F("G29P1\nG29P3\nG29P5C"));
   #else
-    queue.enqueue_now_P(PSTR("G29"));
+    queue.enqueue_now(F("G29"));
   #endif
   queue.enqueue_now_P(DGUS_CMD_EEPROM_SAVE);
 }
 
   switch (axis) {
     case DGUS_Data::Axis::X_Y_Z:
-      queue.enqueue_now_P(PSTR("G28XYZ"));
+      queue.enqueue_now(F("G28XYZ"));
       break;
     case DGUS_Data::Axis::X_Y:
-      queue.enqueue_now_P(PSTR("G28XY"));
+      queue.enqueue_now(F("G28XY"));
       break;
     case DGUS_Data::Axis::Z:
-      queue.enqueue_now_P(PSTR("G28Z"));
+      queue.enqueue_now(F("G28Z"));
       break;
   }
 }
     return;
   }
 
-  queue.enqueue_now_P(PSTR("M502"));
+  queue.enqueue_now(F("M502"));
   queue.enqueue_now_P(DGUS_CMD_EEPROM_SAVE);
 }
 
           return;
         }
 
-        queue.enqueue_now_P(PSTR(DGUS_RESET_BLTOUCH));
+        queue.enqueue_now(F(DGUS_RESET_BLTOUCH));
       #else
         dgus_screen_handler.TriggerScreenChange(DGUS_Screen::INFOS);
       #endif
 
     dgus_screen_handler.TriggerScreenChange(DGUS_Screen::HOME);
 
-    queue.enqueue_now_P(PSTR("M1000C"));
+    queue.enqueue_now(F("M1000C"));
   }
 
   void DGUSRxHandler::PowerLossResume(DGUS_VP &vp, void *data_ptr) {
 
     dgus_screen_handler.TriggerScreenChange(DGUS_Screen::PRINT_STATUS);
 
-    queue.enqueue_now_P(PSTR("M1000"));
+    queue.enqueue_now(F("M1000"));
   }
 #endif // POWER_LOSS_RECOVERY
 

Marlin/src/lcd/extui/dgus_reloaded/DGUSSetupHandler.cpp

 
   if (ExtUI::isPositionKnown()) {
     if (ExtUI::getAxisPosition_mm(ExtUI::Z) < 10.0f) {
-      queue.enqueue_now_P(PSTR("G0Z10"));
+      queue.enqueue_now(F("G0Z10"));
     }
 
     return true;
 
   if (ExtUI::isPositionKnown()) {
     if (ExtUI::getAxisPosition_mm(ExtUI::Z) < 4.0f) {
-      queue.enqueue_now_P(PSTR("G0Z4"));
+      queue.enqueue_now(F("G0Z4"));
     }
 
     char buffer[20];
     snprintf_P(buffer, sizeof(buffer), PSTR("G0X%dY%d"), DGUS_LEVEL_CENTER_X, DGUS_LEVEL_CENTER_Y);
 
     queue.enqueue_one_now(buffer);
-    queue.enqueue_now_P(PSTR("G0Z0"));
+    queue.enqueue_now(F("G0Z0"));
 
     return true;
   }

Marlin/src/lcd/extui/mks_ui/draw_dialog.cpp

     draw_return_ui();
   }
   else if (DIALOG_IS(TYPE_FILAMENT_LOADING, TYPE_FILAMENT_UNLOADING)) {
-    queue.enqueue_one_P(PSTR("M410"));
+    queue.enqueue_one(F("M410"));
     uiCfg.filament_rate                = 0;
     uiCfg.filament_loading_completed   = false;
     uiCfg.filament_unloading_completed = false;

Marlin/src/lcd/extui/mks_ui/draw_extrusion.cpp

       if (ENABLED(HAS_MULTI_EXTRUDER)) {
         if (uiCfg.extruderIndex == 0) {
           uiCfg.extruderIndex = 1;
-          queue.inject_P(PSTR("T1"));
+          queue.inject(F("T1"));
         }
         else {
           uiCfg.extruderIndex = 0;
-          queue.inject_P(PSTR("T0"));
+          queue.inject(F("T0"));
         }
       }
       else

Marlin/src/lcd/extui/mks_ui/draw_home.cpp

       queue.inject_P(G28_STR);
       break;
     case ID_H_X:
-      queue.inject_P(PSTR("G28X"));
+      queue.inject(F("G28X"));
       break;
     case ID_H_Y:
-      queue.inject_P(PSTR("G28Y"));
+      queue.inject(F("G28Y"));
       break;
     case ID_H_Z:
-      queue.inject_P(PSTR("G28Z"));
+      queue.inject(F("G28Z"));
       break;
     case ID_H_OFF_ALL:
-      queue.inject_P(PSTR("M84"));
+      queue.inject(F("M84"));
       break;
     case ID_H_OFF_XY:
-      queue.inject_P(PSTR("M84XY"));
+      queue.inject(F("M84XY"));
       break;
     case ID_H_RETURN:
       clear_cur_ui();

Marlin/src/lcd/extui/mks_ui/draw_more.cpp

   switch (obj->mks_obj_id) {
     case ID_GCODE: lv_clear_more(); lv_draw_gcode(true); break;
     #if HAS_USER_ITEM(1)
-      case ID_CUSTOM_1: queue.inject_P(PSTR(MAIN_MENU_ITEM_1_GCODE)); break;
+      case ID_CUSTOM_1: queue.inject(F(MAIN_MENU_ITEM_1_GCODE)); break;
     #endif
     #if HAS_USER_ITEM(2)
-      case ID_CUSTOM_2: queue.inject_P(PSTR(MAIN_MENU_ITEM_2_GCODE)); break;
+      case ID_CUSTOM_2: queue.inject(F(MAIN_MENU_ITEM_2_GCODE)); break;
     #endif
     #if HAS_USER_ITEM(3)
-      case ID_CUSTOM_3: queue.inject_P(PSTR(MAIN_MENU_ITEM_3_GCODE)); break;
+      case ID_CUSTOM_3: queue.inject(F(MAIN_MENU_ITEM_3_GCODE)); break;
     #endif
     #if HAS_USER_ITEM(4)
-      case ID_CUSTOM_4: queue.inject_P(PSTR(MAIN_MENU_ITEM_4_GCODE)); break;
+      case ID_CUSTOM_4: queue.inject(F(MAIN_MENU_ITEM_4_GCODE)); break;
     #endif
     #if HAS_USER_ITEM(5)
-      case ID_CUSTOM_5: queue.inject_P(PSTR(MAIN_MENU_ITEM_5_GCODE)); break;
+      case ID_CUSTOM_5: queue.inject(F(MAIN_MENU_ITEM_5_GCODE)); break;
     #endif
     #if HAS_USER_ITEM(6)
-      case ID_CUSTOM_6: queue.inject_P(PSTR(MAIN_MENU_ITEM_6_GCODE)); break;
+      case ID_CUSTOM_6: queue.inject(F(MAIN_MENU_ITEM_6_GCODE)); break;
     #endif
     case ID_M_RETURN:
       lv_clear_more();

Marlin/src/lcd/extui/mks_ui/draw_printing.cpp

         #if HAS_SUICIDE
           if (gCfgItems.finish_power_off) {
             gcode.process_subcommands_now(F("M1001"));
-            queue.inject_P(PSTR("M81"));
+            queue.inject(F("M81"));
             marlin_state = MF_RUNNING;
           }
         #endif

Marlin/src/lcd/extui/mks_ui/draw_set.cpp

   if (event != LV_EVENT_RELEASED) return;
   if (obj->mks_obj_id == ID_S_CONTINUE) return;
   if (obj->mks_obj_id == ID_S_MOTOR_OFF) {
-    TERN(HAS_SUICIDE, suicide(), queue.enqueue_now_P(PSTR("M84")));
+    TERN(HAS_SUICIDE, suicide(), queue.enqueue_now(F("M84")));
     return;
   }
   lv_clear_set();

Marlin/src/lcd/extui/mks_ui/draw_tool.cpp

       #if ENABLED(AUTO_BED_LEVELING_BILINEAR)
         get_gcode_command(AUTO_LEVELING_COMMAND_ADDR, (uint8_t *)public_buf_m);
         public_buf_m[sizeof(public_buf_m) - 1] = 0;
-        queue.inject_P(PSTR(public_buf_m));
+        queue.inject(public_buf_m);
       #else
         uiCfg.leveling_first_time = true;
         lv_draw_manualLevel();

Marlin/src/lcd/extui/mks_ui/wifi_module.cpp

           }
 
           send_to_wifi((uint8_t *)tempBuf, strlen((char *)tempBuf));
-          queue.enqueue_one_P(PSTR("M105"));
+          queue.enqueue_one(F("M105"));
           break;
 
         case 992:
         #endif
 
         // Add the command to the queue
-        queue.enqueue_one_P(wifi_line_buffer);
+        queue.enqueue_one(wifi_line_buffer);
       }
       else if (wifi_read_count >= MAX_CMD_SIZE - 1) {
 

Marlin/src/lcd/marlinui.cpp

 
   #if BOTH(PSU_CONTROL, PS_OFF_CONFIRM)
     void MarlinUI::poweroff() {
-      queue.inject_P(PSTR("M81"));
+      queue.inject(F("M81"));
       goto_previous_screen();
     }
   #endif
 
     #if ENABLED(PARK_HEAD_ON_PAUSE)
       pause_show_message(PAUSE_MESSAGE_PARKING, PAUSE_MODE_PAUSE_PRINT); // Show message immediately to let user know about pause in progress
-      queue.inject_P(PSTR("M25 P\nM24"));
+      queue.inject(F("M25 P\nM24"));
     #elif ENABLED(SDSUPPORT)
-      queue.inject_P(PSTR("M25"));
+      queue.inject(F("M25"));
     #elif defined(ACTION_ON_PAUSE)
       host_action_pause();
     #endif

Marlin/src/lcd/menu/menu_advanced.cpp

       //
       // Set Home Offsets
       //
-      ACTION_ITEM(MSG_SET_HOME_OFFSETS, []{ queue.inject_P(PSTR("M428")); ui.return_to_status(); });
+      ACTION_ITEM(MSG_SET_HOME_OFFSETS, []{ queue.inject(F("M428")); ui.return_to_status(); });
     #endif
 
     // M203 / M205 - Feedrate items

Marlin/src/lcd/menu/menu_bed_corners.cpp

   void _lcd_draw_level_prompt() {
     if (!ui.should_draw()) return;
     MenuItem_confirm::confirm_screen(
-        []{ queue.inject_P(TERN(HAS_LEVELING, PSTR("G29N"), G28_STR)); ui.return_to_status(); }
+        []{ queue.inject(TERN(HAS_LEVELING, F("G29N"), FPSTR(G28_STR))); ui.return_to_status(); }
       , []{ ui.goto_previous_screen_no_defer(); }
       , GET_TEXT(MSG_BED_TRAMMING_IN_RANGE)
       , (const char*)nullptr, PSTR("?")

Marlin/src/lcd/menu/menu_bed_leveling.cpp

         ui.wait_for_move = true;
         ui.goto_screen(_lcd_level_bed_done);
         #if ENABLED(MESH_BED_LEVELING)
-          queue.inject_P(PSTR("G29S2"));
+          queue.inject(F("G29S2"));
         #elif ENABLED(PROBE_MANUALLY)
-          queue.inject_P(PSTR("G29V1"));
+          queue.inject(F("G29V1"));
         #endif
       }
       else
     // G29 Records Z, moves, and signals when it pauses
     ui.wait_for_move = true;
     #if ENABLED(MESH_BED_LEVELING)
-      queue.inject_P(manual_probe_index ? PSTR("G29S2") : PSTR("G29S1"));
+      queue.inject(manual_probe_index ? F("G29S2") : F("G29S1"));
     #elif ENABLED(PROBE_MANUALLY)
-      queue.inject_P(PSTR("G29V1"));
+      queue.inject(F("G29V1"));
     #endif
   }
 

Marlin/src/lcd/menu/menu_configuration.cpp

 
 #if ENABLED(CUSTOM_MENU_CONFIG)
 
-  void _lcd_custom_menus_configuration_gcode(PGM_P const cmd) {
-    queue.inject_P(cmd);
+  void _lcd_custom_menus_configuration_gcode(FSTR_P const fstr) {
+    queue.inject(fstr);
     TERN_(CUSTOM_MENU_CONFIG_SCRIPT_AUDIBLE_FEEDBACK, ui.completion_feedback());
     TERN_(CUSTOM_MENU_CONFIG_SCRIPT_RETURN, ui.return_to_status());
   }
     #else
       #define _DONE_SCRIPT ""
     #endif
-    #define GCODE_LAMBDA_CONF(N) []{ _lcd_custom_menus_configuration_gcode(PSTR(CONFIG_MENU_ITEM_##N##_GCODE _DONE_SCRIPT)); }
+    #define GCODE_LAMBDA_CONF(N) []{ _lcd_custom_menus_configuration_gcode(F(CONFIG_MENU_ITEM_##N##_GCODE _DONE_SCRIPT)); }
     #define _CUSTOM_ITEM_CONF(N) ACTION_ITEM_P(PSTR(CONFIG_MENU_ITEM_##N##_DESC), GCODE_LAMBDA_CONF(N));
     #define _CUSTOM_ITEM_CONF_CONFIRM(N)               \
       SUBMENU_P(PSTR(CONFIG_MENU_ITEM_##N##_DESC), []{ \

Marlin/src/lcd/menu/menu_filament.cpp

   #else
 
     if (thermalManager.targetHotEnoughToExtrude(active_extruder))
-      queue.inject_P(PSTR("M600B0"));
+      queue.inject(F("M600B0"));
     else
       ui.goto_screen([]{ _menu_temp_filament_op(PAUSE_MODE_CHANGE_FILAMENT, 0); });
 

Marlin/src/lcd/menu/menu_item.h

 
 #include "menu.h"
 #include "../marlinui.h"
-#include "../../gcode/queue.h" // for inject_P
+#include "../../gcode/queue.h" // for inject
 
 #include "../../inc/MarlinConfigPre.h"
 
     FORCE_INLINE static void draw(const bool sel, const uint8_t row, PGM_P const pstr, ...) {
       _draw(sel, row, pstr, '>', ' ');
     }
-    static void action(PGM_P const, PGM_P const pgcode) { queue.inject_P(pgcode); }
-    static inline void action(PGM_P const pstr, const uint8_t, const char * const pgcode) { action(pstr, pgcode); }
+    static void action(PGM_P const, PGM_P const pgcode) { queue.inject(FPSTR(pgcode)); }
+    static inline void action(PGM_P const pstr, const uint8_t, PGM_P const pgcode) { action(pstr, pgcode); }
 };
 
 ////////////////////////////////////////////

Marlin/src/lcd/menu/menu_job_recovery.cpp

 
 static void lcd_power_loss_recovery_resume() {
   ui.return_to_status();
-  queue.inject_P(PSTR("M1000"));
+  queue.inject(F("M1000"));
 }
 
 void lcd_power_loss_recovery_cancel() {

Marlin/src/lcd/menu/menu_main.cpp

 
 #if ENABLED(CUSTOM_MENU_MAIN)
 
-  void _lcd_custom_menu_main_gcode(PGM_P const cmd) {
-    queue.inject_P(cmd);
+  void _lcd_custom_menu_main_gcode(FSTR_P const fstr) {
+    queue.inject(fstr);
     TERN_(CUSTOM_MENU_MAIN_SCRIPT_AUDIBLE_FEEDBACK, ui.completion_feedback());
     TERN_(CUSTOM_MENU_MAIN_SCRIPT_RETURN, ui.return_to_status());
   }
     #else
       #define _DONE_SCRIPT ""
     #endif
-    #define GCODE_LAMBDA_MAIN(N) []{ _lcd_custom_menu_main_gcode(PSTR(MAIN_MENU_ITEM_##N##_GCODE _DONE_SCRIPT)); }
+    #define GCODE_LAMBDA_MAIN(N) []{ _lcd_custom_menu_main_gcode(F(MAIN_MENU_ITEM_##N##_GCODE _DONE_SCRIPT)); }
     #define _CUSTOM_ITEM_MAIN(N) ACTION_ITEM_P(PSTR(MAIN_MENU_ITEM_##N##_DESC), GCODE_LAMBDA_MAIN(N));
     #define _CUSTOM_ITEM_MAIN_CONFIRM(N)             \
       SUBMENU_P(PSTR(MAIN_MENU_ITEM_##N##_DESC), []{ \

Marlin/src/lcd/menu/menu_probe_offset.cpp

     // If wizard-homing was done by probe with PROBE_OFFSET_WIZARD_START_Z
     #if HOMING_Z_WITH_PROBE && defined(PROBE_OFFSET_WIZARD_START_Z)
       set_axis_never_homed(Z_AXIS); // On cancel the Z position needs correction
-      queue.inject_P(PSTR("G28Z"));
+      queue.inject(F("G28Z"));
     #else // Otherwise do a Z clearance move like after Homing
       z_clearance_move();
     #endif

Marlin/src/lcd/menu/menu_tramming.cpp

 
   // Inject G28, wait for homing to complete,
   set_all_unhomed();
-  queue.inject_P(TERN(CAN_SET_LEVELING_AFTER_G28, PSTR("G28L0"), G28_STR));
+  queue.inject(TERN(CAN_SET_LEVELING_AFTER_G28, F("G28L0"), FPSTR(G28_STR)));
 
   ui.goto_screen([]{
     _lcd_draw_homing();

Marlin/src/lcd/tft/ui_1024x600.cpp

 
 static void disable_steppers() {
   quick_feedback();
-  queue.inject_P(PSTR("M84"));
+  queue.inject(F("M84"));
 }
 
 static void drawBtn(int x, int y, const char *label, intptr_t data, MarlinImage img, uint16_t bgColor, bool enabled = true) {

Marlin/src/lcd/tft/ui_320x240.cpp

 
 static void disable_steppers() {
   quick_feedback();
-  queue.inject_P(PSTR("M84"));
+  queue.inject(F("M84"));
 }
 
 static void drawBtn(int x, int y, const char *label, intptr_t data, MarlinImage img, uint16_t bgColor, bool enabled = true) {

Marlin/src/lcd/tft/ui_480x320.cpp

 
 static void disable_steppers() {
   quick_feedback();
-  queue.inject_P(PSTR("M84"));
+  queue.inject(F("M84"));
 }
 
 static void drawBtn(int x, int y, const char *label, intptr_t data, MarlinImage img, uint16_t bgColor, bool enabled = true) {