Browse Source

🎨 Apply F() to status message

vanilla_fb_2.0.x
Scott Lahteine 3 years ago
committed by Scott Lahteine
parent
commit
360311f232
  1. 10
      Marlin/src/MarlinCore.cpp
  2. 38
      Marlin/src/feature/bedlevel/ubl/ubl_G29.cpp
  3. 2
      Marlin/src/feature/cancel_object.cpp
  4. 2
      Marlin/src/feature/hotend_idle.cpp
  5. 24
      Marlin/src/feature/mmu/mmu2.cpp
  6. 4
      Marlin/src/feature/pause.cpp
  7. 2
      Marlin/src/feature/stepper_driver_safety.cpp
  8. 2
      Marlin/src/feature/tmc_util.cpp
  9. 14
      Marlin/src/gcode/bedlevel/G26.cpp
  10. 4
      Marlin/src/gcode/bedlevel/abl/G29.cpp
  11. 4
      Marlin/src/gcode/bedlevel/mbl/G29.cpp
  12. 2
      Marlin/src/gcode/calibrate/G28.cpp
  13. 6
      Marlin/src/gcode/calibrate/G33.cpp
  14. 8
      Marlin/src/gcode/calibrate/G34_M422.cpp
  15. 2
      Marlin/src/gcode/calibrate/G76_M192_M871.cpp
  16. 6
      Marlin/src/gcode/calibrate/M48.cpp
  17. 2
      Marlin/src/gcode/control/M17_M18_M84.cpp
  18. 4
      Marlin/src/gcode/control/M80_M81.cpp
  19. 4
      Marlin/src/gcode/geometry/M206_M428.cpp
  20. 2
      Marlin/src/gcode/lcd/M0_M1.cpp
  21. 2
      Marlin/src/gcode/motion/G4.cpp
  22. 2
      Marlin/src/gcode/queue.cpp
  23. 2
      Marlin/src/gcode/temp/M140_M190.cpp
  24. 2
      Marlin/src/gcode/temp/M141_M191.cpp
  25. 2
      Marlin/src/gcode/temp/M143_M193.cpp
  26. 2
      Marlin/src/gcode/temp/M303.cpp
  27. 12
      Marlin/src/lcd/e3v2/creality/dwin.cpp
  28. 4
      Marlin/src/lcd/e3v2/creality/dwin.h
  29. 58
      Marlin/src/lcd/e3v2/enhanced/dwin.cpp
  30. 6
      Marlin/src/lcd/e3v2/enhanced/dwin.h
  31. 2
      Marlin/src/lcd/e3v2/enhanced/meshviewer.cpp
  32. 2
      Marlin/src/lcd/extui/mks_ui/wifi_module.cpp
  33. 65
      Marlin/src/lcd/marlinui.cpp
  34. 23
      Marlin/src/lcd/marlinui.h
  35. 2
      Marlin/src/lcd/menu/menu_advanced.cpp
  36. 2
      Marlin/src/lcd/menu/menu_mixer.cpp
  37. 8
      Marlin/src/lcd/menu/menu_mmu2.cpp
  38. 4
      Marlin/src/module/endstops.cpp
  39. 12
      Marlin/src/module/probe.cpp
  40. 6
      Marlin/src/module/settings.cpp
  41. 14
      Marlin/src/module/temperature.cpp
  42. 4
      Marlin/src/module/tool_change.cpp
  43. 2
      Marlin/src/sd/cardreader.cpp
  44. 10
      Marlin/src/sd/usb_flashdrive/Sd2Card_FlashDrive.cpp

10
Marlin/src/MarlinCore.cpp

@ -474,7 +474,7 @@ inline void manage_inactivity(const bool no_stepper_sleep=false) {
if (!IS_SD_PRINTING() && !READ(HOME_PIN)) { // HOME_PIN goes LOW when pressed if (!IS_SD_PRINTING() && !READ(HOME_PIN)) { // HOME_PIN goes LOW when pressed
if (ELAPSED(ms, next_home_key_ms)) { if (ELAPSED(ms, next_home_key_ms)) {
next_home_key_ms = ms + HOME_DEBOUNCE_DELAY; next_home_key_ms = ms + HOME_DEBOUNCE_DELAY;
LCD_MESSAGEPGM(MSG_AUTO_HOME); LCD_MESSAGE(MSG_AUTO_HOME);
queue.inject_P(G28_STR); queue.inject_P(G28_STR);
} }
} }
@ -499,8 +499,8 @@ inline void manage_inactivity(const bool no_stepper_sleep=false) {
} \ } \
}while(0) }while(0)
#define CHECK_CUSTOM_USER_BUTTON(N) _CHECK_CUSTOM_USER_BUTTON(N, NOOP) #define CHECK_CUSTOM_USER_BUTTON(N) _CHECK_CUSTOM_USER_BUTTON(N, NOOP)
#define CHECK_BETTER_USER_BUTTON(N) _CHECK_CUSTOM_USER_BUTTON(N, if (strlen(BUTTON##N##_DESC)) LCD_MESSAGEPGM_P(PSTR(BUTTON##N##_DESC))) #define CHECK_BETTER_USER_BUTTON(N) _CHECK_CUSTOM_USER_BUTTON(N, if (strlen(BUTTON##N##_DESC)) LCD_MESSAGE_F(BUTTON##N##_DESC))
#if HAS_BETTER_USER_BUTTON(1) #if HAS_BETTER_USER_BUTTON(1)
CHECK_BETTER_USER_BUTTON(1); CHECK_BETTER_USER_BUTTON(1);
@ -935,7 +935,7 @@ void stop() {
if (!IsStopped()) { if (!IsStopped()) {
SERIAL_ERROR_MSG(STR_ERR_STOPPED); SERIAL_ERROR_MSG(STR_ERR_STOPPED);
LCD_MESSAGEPGM(MSG_STOPPED); LCD_MESSAGE(MSG_STOPPED);
safe_delay(350); // allow enough time for messages to get out before stopping safe_delay(350); // allow enough time for messages to get out before stopping
marlin_state = MF_STOPPED; marlin_state = MF_STOPPED;
} }
@ -1551,7 +1551,7 @@ void setup() {
HMI_Init(); HMI_Init();
HMI_SetLanguageCache(); HMI_SetLanguageCache();
HMI_StartFrame(true); HMI_StartFrame(true);
DWIN_StatusChanged_P(GET_TEXT(WELCOME_MSG)); DWIN_StatusChanged(GET_TEXT_F(WELCOME_MSG));
#endif #endif
#if HAS_SERVICE_INTERVALS && !HAS_DWIN_E3V2_BASIC #if HAS_SERVICE_INTERVALS && !HAS_DWIN_E3V2_BASIC

38
Marlin/src/feature/bedlevel/ubl/ubl_G29.cpp

@ -736,7 +736,7 @@ void unified_bed_leveling::shift_mesh_height() {
const uint8_t point_num = (GRID_MAX_POINTS - count) + 1; const uint8_t point_num = (GRID_MAX_POINTS - count) + 1;
SERIAL_ECHOLNPGM("Probing mesh point ", point_num, "/", GRID_MAX_POINTS, "."); SERIAL_ECHOLNPGM("Probing mesh point ", point_num, "/", GRID_MAX_POINTS, ".");
TERN_(HAS_STATUS_MESSAGE, ui.status_printf_P(0, PSTR(S_FMT " %i/%i"), GET_TEXT(MSG_PROBING_POINT), point_num, int(GRID_MAX_POINTS))); TERN_(HAS_STATUS_MESSAGE, ui.status_printf(0, F(S_FMT " %i/%i"), GET_TEXT(MSG_PROBING_POINT), point_num, int(GRID_MAX_POINTS)));
#if HAS_LCD_MENU #if HAS_LCD_MENU
if (ui.button_pressed()) { if (ui.button_pressed()) {
@ -789,12 +789,12 @@ void unified_bed_leveling::shift_mesh_height() {
#endif // HAS_BED_PROBE #endif // HAS_BED_PROBE
void set_message_with_feedback(PGM_P const msg_P) { void set_message_with_feedback(FSTR_P const fstr) {
#if HAS_LCD_MENU #if HAS_LCD_MENU
ui.set_status_P(msg_P); ui.set_status(fstr);
ui.quick_feedback(); ui.quick_feedback();
#else #else
UNUSED(msg_P); UNUSED(fstr);
#endif #endif
} }
@ -850,7 +850,7 @@ void set_message_with_feedback(PGM_P const msg_P) {
planner.synchronize(); planner.synchronize();
SERIAL_ECHOPGM("Place shim under nozzle"); SERIAL_ECHOPGM("Place shim under nozzle");
LCD_MESSAGEPGM(MSG_UBL_BC_INSERT); LCD_MESSAGE(MSG_UBL_BC_INSERT);
ui.return_to_status(); ui.return_to_status();
echo_and_take_a_measurement(); echo_and_take_a_measurement();
@ -859,7 +859,7 @@ void set_message_with_feedback(PGM_P const msg_P) {
planner.synchronize(); planner.synchronize();
SERIAL_ECHOPGM("Remove shim"); SERIAL_ECHOPGM("Remove shim");
LCD_MESSAGEPGM(MSG_UBL_BC_REMOVE); LCD_MESSAGE(MSG_UBL_BC_REMOVE);
echo_and_take_a_measurement(); echo_and_take_a_measurement();
const float z2 = measure_point_with_encoder(); const float z2 = measure_point_with_encoder();
@ -905,7 +905,7 @@ void set_message_with_feedback(PGM_P const msg_P) {
if (!position_is_reachable(ppos)) break; // SHOULD NOT OCCUR (find_closest_mesh_point only returns reachable points) if (!position_is_reachable(ppos)) break; // SHOULD NOT OCCUR (find_closest_mesh_point only returns reachable points)
LCD_MESSAGEPGM(MSG_UBL_MOVING_TO_NEXT); LCD_MESSAGE(MSG_UBL_MOVING_TO_NEXT);
do_blocking_move_to(ppos); do_blocking_move_to(ppos);
do_z_clearance(z_clearance); do_z_clearance(z_clearance);
@ -917,11 +917,11 @@ void set_message_with_feedback(PGM_P const msg_P) {
if (parser.seen_test('B')) { if (parser.seen_test('B')) {
SERIAL_ECHOPGM("Place Shim & Measure"); SERIAL_ECHOPGM("Place Shim & Measure");
LCD_MESSAGEPGM(MSG_UBL_BC_INSERT); LCD_MESSAGE(MSG_UBL_BC_INSERT);
} }
else { else {
SERIAL_ECHOPGM("Measure"); SERIAL_ECHOPGM("Measure");
LCD_MESSAGEPGM(MSG_UBL_BC_INSERT2); LCD_MESSAGE(MSG_UBL_BC_INSERT2);
} }
const float z_step = 0.01f; // 0.01mm per encoder tick, occasionally step const float z_step = 0.01f; // 0.01mm per encoder tick, occasionally step
@ -974,7 +974,7 @@ void set_message_with_feedback(PGM_P const msg_P) {
save_ubl_active_state_and_disable(); save_ubl_active_state_and_disable();
LCD_MESSAGEPGM(MSG_UBL_FINE_TUNE_MESH); LCD_MESSAGE(MSG_UBL_FINE_TUNE_MESH);
ui.capture(); // Take over control of the LCD encoder ui.capture(); // Take over control of the LCD encoder
do_blocking_move_to_xy_z(pos, Z_CLEARANCE_BETWEEN_PROBES); // Move to the given XY with probe clearance do_blocking_move_to_xy_z(pos, Z_CLEARANCE_BETWEEN_PROBES); // Move to the given XY with probe clearance
@ -1039,7 +1039,7 @@ void set_message_with_feedback(PGM_P const msg_P) {
if (_click_and_hold([]{ if (_click_and_hold([]{
ui.return_to_status(); ui.return_to_status();
do_z_clearance(Z_CLEARANCE_BETWEEN_PROBES); do_z_clearance(Z_CLEARANCE_BETWEEN_PROBES);
set_message_with_feedback(GET_TEXT(MSG_EDITING_STOPPED)); set_message_with_feedback(GET_TEXT_F(MSG_EDITING_STOPPED));
})) break; })) break;
// TODO: Disable leveling here so the Z value becomes the 'native' Z value. // TODO: Disable leveling here so the Z value becomes the 'native' Z value.
@ -1060,7 +1060,7 @@ void set_message_with_feedback(PGM_P const msg_P) {
do_blocking_move_to_xy_z(pos, Z_CLEARANCE_BETWEEN_PROBES); do_blocking_move_to_xy_z(pos, Z_CLEARANCE_BETWEEN_PROBES);
LCD_MESSAGEPGM(MSG_UBL_DONE_EDITING_MESH); LCD_MESSAGE(MSG_UBL_DONE_EDITING_MESH);
SERIAL_ECHOLNPGM("Done Editing Mesh"); SERIAL_ECHOLNPGM("Done Editing Mesh");
if (lcd_map_control) if (lcd_map_control)
@ -1077,7 +1077,7 @@ void set_message_with_feedback(PGM_P const msg_P) {
bool unified_bed_leveling::G29_parse_parameters() { bool unified_bed_leveling::G29_parse_parameters() {
bool err_flag = false; bool err_flag = false;
set_message_with_feedback(GET_TEXT(MSG_UBL_DOING_G29)); set_message_with_feedback(GET_TEXT_F(MSG_UBL_DOING_G29));
param.C_constant = 0; param.C_constant = 0;
param.R_repetition = 0; param.R_repetition = 0;
@ -1200,7 +1200,7 @@ void unified_bed_leveling::save_ubl_active_state_and_disable() {
ubl_state_recursion_chk++; ubl_state_recursion_chk++;
if (ubl_state_recursion_chk != 1) { if (ubl_state_recursion_chk != 1) {
SERIAL_ECHOLNPGM("save_ubl_active_state_and_disabled() called multiple times in a row."); SERIAL_ECHOLNPGM("save_ubl_active_state_and_disabled() called multiple times in a row.");
set_message_with_feedback(GET_TEXT(MSG_UBL_SAVE_ERROR)); set_message_with_feedback(GET_TEXT_F(MSG_UBL_SAVE_ERROR));
return; return;
} }
#endif #endif
@ -1213,7 +1213,7 @@ void unified_bed_leveling::restore_ubl_active_state_and_leave() {
#if ENABLED(UBL_DEVEL_DEBUGGING) #if ENABLED(UBL_DEVEL_DEBUGGING)
if (--ubl_state_recursion_chk) { if (--ubl_state_recursion_chk) {
SERIAL_ECHOLNPGM("restore_ubl_active_state_and_leave() called too many times."); SERIAL_ECHOLNPGM("restore_ubl_active_state_and_leave() called too many times.");
set_message_with_feedback(GET_TEXT(MSG_UBL_RESTORE_ERROR)); set_message_with_feedback(GET_TEXT_F(MSG_UBL_RESTORE_ERROR));
return; return;
} }
#endif #endif
@ -1438,7 +1438,7 @@ void unified_bed_leveling::smart_fill_mesh() {
if (do_3_pt_leveling) { if (do_3_pt_leveling) {
SERIAL_ECHOLNPGM("Tilting mesh (1/3)"); SERIAL_ECHOLNPGM("Tilting mesh (1/3)");
TERN_(HAS_STATUS_MESSAGE, ui.status_printf_P(0, PSTR(S_FMT " 1/3"), GET_TEXT(MSG_LCD_TILTING_MESH))); TERN_(HAS_STATUS_MESSAGE, ui.status_printf(0, F(S_FMT " 1/3"), GET_TEXT(MSG_LCD_TILTING_MESH)));
measured_z = probe.probe_at_point(points[0], PROBE_PT_RAISE, param.V_verbosity); measured_z = probe.probe_at_point(points[0], PROBE_PT_RAISE, param.V_verbosity);
if (isnan(measured_z)) if (isnan(measured_z))
@ -1457,7 +1457,7 @@ void unified_bed_leveling::smart_fill_mesh() {
if (!abort_flag) { if (!abort_flag) {
SERIAL_ECHOLNPGM("Tilting mesh (2/3)"); SERIAL_ECHOLNPGM("Tilting mesh (2/3)");
TERN_(HAS_STATUS_MESSAGE, ui.status_printf_P(0, PSTR(S_FMT " 2/3"), GET_TEXT(MSG_LCD_TILTING_MESH))); TERN_(HAS_STATUS_MESSAGE, ui.status_printf(0, F(S_FMT " 2/3"), GET_TEXT(MSG_LCD_TILTING_MESH)));
measured_z = probe.probe_at_point(points[1], PROBE_PT_RAISE, param.V_verbosity); measured_z = probe.probe_at_point(points[1], PROBE_PT_RAISE, param.V_verbosity);
#ifdef VALIDATE_MESH_TILT #ifdef VALIDATE_MESH_TILT
@ -1477,7 +1477,7 @@ void unified_bed_leveling::smart_fill_mesh() {
if (!abort_flag) { if (!abort_flag) {
SERIAL_ECHOLNPGM("Tilting mesh (3/3)"); SERIAL_ECHOLNPGM("Tilting mesh (3/3)");
TERN_(HAS_STATUS_MESSAGE, ui.status_printf_P(0, PSTR(S_FMT " 3/3"), GET_TEXT(MSG_LCD_TILTING_MESH))); TERN_(HAS_STATUS_MESSAGE, ui.status_printf(0, F(S_FMT " 3/3"), GET_TEXT(MSG_LCD_TILTING_MESH)));
measured_z = probe.probe_at_point(points[2], PROBE_PT_LAST_STOW, param.V_verbosity); measured_z = probe.probe_at_point(points[2], PROBE_PT_LAST_STOW, param.V_verbosity);
#ifdef VALIDATE_MESH_TILT #ifdef VALIDATE_MESH_TILT
@ -1518,7 +1518,7 @@ void unified_bed_leveling::smart_fill_mesh() {
if (!abort_flag) { if (!abort_flag) {
SERIAL_ECHOLNPGM("Tilting mesh point ", point_num, "/", total_points, "\n"); SERIAL_ECHOLNPGM("Tilting mesh point ", point_num, "/", total_points, "\n");
TERN_(HAS_STATUS_MESSAGE, ui.status_printf_P(0, PSTR(S_FMT " %i/%i"), GET_TEXT(MSG_LCD_TILTING_MESH), point_num, total_points)); TERN_(HAS_STATUS_MESSAGE, ui.status_printf(0, F(S_FMT " %i/%i"), GET_TEXT(MSG_LCD_TILTING_MESH), point_num, total_points));
measured_z = probe.probe_at_point(rpos, parser.seen_test('E') ? PROBE_PT_STOW : PROBE_PT_RAISE, param.V_verbosity); // TODO: Needs error handling measured_z = probe.probe_at_point(rpos, parser.seen_test('E') ? PROBE_PT_STOW : PROBE_PT_RAISE, param.V_verbosity); // TODO: Needs error handling

2
Marlin/src/feature/cancel_object.cpp

@ -46,7 +46,7 @@ void CancelObject::set_active_object(const int8_t obj) {
#if BOTH(HAS_STATUS_MESSAGE, CANCEL_OBJECTS_REPORTING) #if BOTH(HAS_STATUS_MESSAGE, CANCEL_OBJECTS_REPORTING)
if (active_object >= 0) if (active_object >= 0)
ui.status_printf_P(0, PSTR(S_FMT " %i"), GET_TEXT(MSG_PRINTING_OBJECT), int(active_object)); ui.status_printf(0, F(S_FMT " %i"), GET_TEXT(MSG_PRINTING_OBJECT), int(active_object));
else else
ui.reset_status(); ui.reset_status();
#endif #endif

2
Marlin/src/feature/hotend_idle.cpp

@ -77,7 +77,7 @@ void HotendIdleProtection::check() {
void HotendIdleProtection::timed_out() { void HotendIdleProtection::timed_out() {
next_protect_ms = 0; next_protect_ms = 0;
SERIAL_ECHOLNPGM("Hotend Idle Timeout"); SERIAL_ECHOLNPGM("Hotend Idle Timeout");
LCD_MESSAGEPGM(MSG_HOTEND_IDLE_TIMEOUT); LCD_MESSAGE(MSG_HOTEND_IDLE_TIMEOUT);
HOTEND_LOOP() { HOTEND_LOOP() {
if ((HOTEND_IDLE_NOZZLE_TARGET) < thermalManager.degTargetHotend(e)) if ((HOTEND_IDLE_NOZZLE_TARGET) < thermalManager.degTargetHotend(e))
thermalManager.setTargetHotend(HOTEND_IDLE_NOZZLE_TARGET, e); thermalManager.setTargetHotend(HOTEND_IDLE_NOZZLE_TARGET, e);

24
Marlin/src/feature/mmu/mmu2.cpp

@ -451,7 +451,7 @@ void MMU2::check_version() {
} }
static void mmu2_not_responding() { static void mmu2_not_responding() {
LCD_MESSAGEPGM(MSG_MMU2_NOT_RESPONDING); LCD_MESSAGE(MSG_MMU2_NOT_RESPONDING);
BUZZ(100, 659); BUZZ(100, 659);
BUZZ(200, 698); BUZZ(200, 698);
BUZZ(100, 659); BUZZ(100, 659);
@ -487,7 +487,7 @@ static void mmu2_not_responding() {
if (index != extruder) { if (index != extruder) {
stepper.disable_extruder(); stepper.disable_extruder();
ui.status_printf_P(0, GET_TEXT(MSG_MMU2_LOADING_FILAMENT), int(index + 1)); ui.status_printf(0, GET_TEXT_F(MSG_MMU2_LOADING_FILAMENT), int(index + 1));
command(MMU_CMD_T0 + index); command(MMU_CMD_T0 + index);
manage_response(true, true); manage_response(true, true);
@ -573,7 +573,7 @@ static void mmu2_not_responding() {
command(MMU_CMD_U0); command(MMU_CMD_U0);
manage_response(true, true); manage_response(true, true);
} }
ui.status_printf_P(0, GET_TEXT(MSG_MMU2_LOADING_FILAMENT), int(index + 1)); ui.status_printf(0, GET_TEXT_F(MSG_MMU2_LOADING_FILAMENT), int(index + 1));
mmu_loading_flag = true; mmu_loading_flag = true;
command(MMU_CMD_T0 + index); command(MMU_CMD_T0 + index);
manage_response(true, true); manage_response(true, true);
@ -671,7 +671,7 @@ static void mmu2_not_responding() {
if (index != extruder) { if (index != extruder) {
stepper.disable_extruder(); stepper.disable_extruder();
ui.status_printf_P(0, GET_TEXT(MSG_MMU2_LOADING_FILAMENT), int(index + 1)); ui.status_printf(0, GET_TEXT_F(MSG_MMU2_LOADING_FILAMENT), int(index + 1));
command(MMU_CMD_T0 + index); command(MMU_CMD_T0 + index);
manage_response(true, true); manage_response(true, true);
command(MMU_CMD_C0); command(MMU_CMD_C0);
@ -808,14 +808,14 @@ void MMU2::manage_response(const bool move_axes, const bool turn_off_nozzle) {
if (turn_off_nozzle && resume_hotend_temp) { if (turn_off_nozzle && resume_hotend_temp) {
thermalManager.setTargetHotend(resume_hotend_temp, active_extruder); thermalManager.setTargetHotend(resume_hotend_temp, active_extruder);
LCD_MESSAGEPGM(MSG_HEATING); LCD_MESSAGE(MSG_HEATING);
BUZZ(200, 40); BUZZ(200, 40);
while (!thermalManager.wait_for_hotend(active_extruder, false)) safe_delay(1000); while (!thermalManager.wait_for_hotend(active_extruder, false)) safe_delay(1000);
} }
if (move_axes && all_axes_homed()) { if (move_axes && all_axes_homed()) {
LCD_MESSAGEPGM(MSG_MMU2_RESUMING); LCD_MESSAGE(MSG_MMU2_RESUMING);
BUZZ(198, 404); BUZZ(4, 0); BUZZ(198, 404); BUZZ(198, 404); BUZZ(4, 0); BUZZ(198, 404);
// Move XY to starting position, then Z // Move XY to starting position, then Z
@ -826,7 +826,7 @@ void MMU2::manage_response(const bool move_axes, const bool turn_off_nozzle) {
} }
else { else {
BUZZ(198, 404); BUZZ(4, 0); BUZZ(198, 404); BUZZ(198, 404); BUZZ(4, 0); BUZZ(198, 404);
LCD_MESSAGEPGM(MSG_MMU2_RESUMING); LCD_MESSAGE(MSG_MMU2_RESUMING);
} }
} }
} }
@ -908,7 +908,7 @@ bool MMU2::load_filament_to_nozzle(const uint8_t index) {
if (thermalManager.tooColdToExtrude(active_extruder)) { if (thermalManager.tooColdToExtrude(active_extruder)) {
BUZZ(200, 404); BUZZ(200, 404);
LCD_ALERTMESSAGEPGM(MSG_HOTEND_TOO_COLD); LCD_ALERTMESSAGE(MSG_HOTEND_TOO_COLD);
return false; return false;
} }
@ -944,11 +944,11 @@ bool MMU2::eject_filament(const uint8_t index, const bool recover) {
if (thermalManager.tooColdToExtrude(active_extruder)) { if (thermalManager.tooColdToExtrude(active_extruder)) {
BUZZ(200, 404); BUZZ(200, 404);
LCD_ALERTMESSAGEPGM(MSG_HOTEND_TOO_COLD); LCD_ALERTMESSAGE(MSG_HOTEND_TOO_COLD);
return false; return false;
} }
LCD_MESSAGEPGM(MSG_MMU2_EJECTING_FILAMENT); LCD_MESSAGE(MSG_MMU2_EJECTING_FILAMENT);
stepper.enable_extruder(); stepper.enable_extruder();
current_position.e -= MMU2_FILAMENTCHANGE_EJECT_FEED; current_position.e -= MMU2_FILAMENTCHANGE_EJECT_FEED;
@ -958,7 +958,7 @@ bool MMU2::eject_filament(const uint8_t index, const bool recover) {
manage_response(false, false); manage_response(false, false);
if (recover) { if (recover) {
LCD_MESSAGEPGM(MSG_MMU2_EJECT_RECOVER); LCD_MESSAGE(MSG_MMU2_EJECT_RECOVER);
BUZZ(200, 404); BUZZ(200, 404);
TERN_(HOST_PROMPT_SUPPORT, host_prompt_do(PROMPT_USER_CONTINUE, PSTR("MMU2 Eject Recover"), CONTINUE_STR)); TERN_(HOST_PROMPT_SUPPORT, host_prompt_do(PROMPT_USER_CONTINUE, PSTR("MMU2 Eject Recover"), CONTINUE_STR));
TERN_(EXTENSIBLE_UI, ExtUI::onUserConfirmRequired_P(PSTR("MMU2 Eject Recover"))); TERN_(EXTENSIBLE_UI, ExtUI::onUserConfirmRequired_P(PSTR("MMU2 Eject Recover")));
@ -993,7 +993,7 @@ bool MMU2::unload() {
if (thermalManager.tooColdToExtrude(active_extruder)) { if (thermalManager.tooColdToExtrude(active_extruder)) {
BUZZ(200, 404); BUZZ(200, 404);
LCD_ALERTMESSAGEPGM(MSG_HOTEND_TOO_COLD); LCD_ALERTMESSAGE(MSG_HOTEND_TOO_COLD);
return false; return false;
} }

4
Marlin/src/feature/pause.cpp

@ -538,7 +538,7 @@ void wait_for_confirmation(const bool is_reload/*=false*/, const int8_t max_beep
TERN_(EXTENSIBLE_UI, ExtUI::onStatusChanged_P(GET_TEXT(MSG_REHEATING))); TERN_(EXTENSIBLE_UI, ExtUI::onStatusChanged_P(GET_TEXT(MSG_REHEATING)));
TERN_(DWIN_CREALITY_LCD_ENHANCED, ui.set_status_P(GET_TEXT(MSG_REHEATING))); TERN_(DWIN_CREALITY_LCD_ENHANCED, LCD_MESSAGE(MSG_REHEATING));
// Re-enable the heaters if they timed out // Re-enable the heaters if they timed out
HOTEND_LOOP() thermalManager.reset_hotend_idle_timer(e); HOTEND_LOOP() thermalManager.reset_hotend_idle_timer(e);
@ -556,7 +556,7 @@ void wait_for_confirmation(const bool is_reload/*=false*/, const int8_t max_beep
TERN_(HOST_PROMPT_SUPPORT, host_prompt_do(PROMPT_USER_CONTINUE, GET_TEXT(MSG_REHEATDONE), CONTINUE_STR)); TERN_(HOST_PROMPT_SUPPORT, host_prompt_do(PROMPT_USER_CONTINUE, GET_TEXT(MSG_REHEATDONE), CONTINUE_STR));
TERN_(EXTENSIBLE_UI, ExtUI::onUserConfirmRequired_P(GET_TEXT(MSG_REHEATDONE))); TERN_(EXTENSIBLE_UI, ExtUI::onUserConfirmRequired_P(GET_TEXT(MSG_REHEATDONE)));
TERN_(DWIN_CREALITY_LCD_ENHANCED, ui.set_status_P(GET_TEXT(MSG_REHEATDONE))); TERN_(DWIN_CREALITY_LCD_ENHANCED, LCD_MESSAGE(MSG_REHEATDONE));
IF_DISABLED(PAUSE_REHEAT_FAST_RESUME, wait_for_user = true); IF_DISABLED(PAUSE_REHEAT_FAST_RESUME, wait_for_user = true);

2
Marlin/src/feature/stepper_driver_safety.cpp

@ -32,7 +32,7 @@ void stepper_driver_backward_error(PGM_P str) {
SERIAL_ERROR_START(); SERIAL_ERROR_START();
SERIAL_ECHOPGM_P(str); SERIAL_ECHOPGM_P(str);
SERIAL_ECHOLNPGM(" driver is backward!"); SERIAL_ECHOLNPGM(" driver is backward!");
ui.status_printf_P(2, PSTR(S_FMT S_FMT), str, GET_TEXT(MSG_DRIVER_BACKWARD)); ui.status_printf(2, F(S_FMT S_FMT), str, GET_TEXT(MSG_DRIVER_BACKWARD));
} }
void stepper_driver_backward_check() { void stepper_driver_backward_check() {

2
Marlin/src/feature/tmc_util.cpp

@ -1341,7 +1341,7 @@ void test_tmc_connection(LOGICAL_AXIS_ARGS(const bool)) {
#endif #endif
} }
if (axis_connection) LCD_MESSAGEPGM(MSG_ERROR_TMC); if (axis_connection) LCD_MESSAGE(MSG_ERROR_TMC);
} }
#endif // HAS_TRINAMIC_CONFIG #endif // HAS_TRINAMIC_CONFIG

14
Marlin/src/gcode/bedlevel/G26.cpp

@ -163,7 +163,7 @@ float g26_random_deviation = 0.0;
*/ */
bool user_canceled() { bool user_canceled() {
if (!ui.button_pressed()) return false; // Return if the button isn't pressed if (!ui.button_pressed()) return false; // Return if the button isn't pressed
ui.set_status_P(GET_TEXT(MSG_G26_CANCELED), 99); ui.set_status(GET_TEXT_F(MSG_G26_CANCELED), 99);
TERN_(HAS_LCD_MENU, ui.quick_feedback()); TERN_(HAS_LCD_MENU, ui.quick_feedback());
ui.wait_for_release(); ui.wait_for_release();
return true; return true;
@ -323,7 +323,7 @@ typedef struct {
if (bed_temp > 25) { if (bed_temp > 25) {
#if HAS_WIRED_LCD #if HAS_WIRED_LCD
ui.set_status_P(GET_TEXT(MSG_G26_HEATING_BED), 99); ui.set_status(GET_TEXT_F(MSG_G26_HEATING_BED), 99);
ui.quick_feedback(); ui.quick_feedback();
TERN_(HAS_LCD_MENU, ui.capture()); TERN_(HAS_LCD_MENU, ui.capture());
#endif #endif
@ -342,7 +342,7 @@ typedef struct {
// Start heating the active nozzle // Start heating the active nozzle
#if HAS_WIRED_LCD #if HAS_WIRED_LCD
ui.set_status_P(GET_TEXT(MSG_G26_HEATING_NOZZLE), 99); ui.set_status(GET_TEXT_F(MSG_G26_HEATING_NOZZLE), 99);
ui.quick_feedback(); ui.quick_feedback();
#endif #endif
thermalManager.setTargetHotend(hotend_temp, active_extruder); thermalManager.setTargetHotend(hotend_temp, active_extruder);
@ -372,7 +372,7 @@ typedef struct {
if (prime_flag == -1) { // The user wants to control how much filament gets purged if (prime_flag == -1) { // The user wants to control how much filament gets purged
ui.capture(); ui.capture();
ui.set_status_P(GET_TEXT(MSG_G26_MANUAL_PRIME), 99); ui.set_status(GET_TEXT_F(MSG_G26_MANUAL_PRIME), 99);
ui.chirp(); ui.chirp();
destination = current_position; destination = current_position;
@ -399,7 +399,7 @@ typedef struct {
ui.wait_for_release(); ui.wait_for_release();
ui.set_status_P(GET_TEXT(MSG_G26_PRIME_DONE), 99); ui.set_status(GET_TEXT_F(MSG_G26_PRIME_DONE), 99);
ui.quick_feedback(); ui.quick_feedback();
ui.release(); ui.release();
} }
@ -407,7 +407,7 @@ typedef struct {
#endif #endif
{ {
#if HAS_WIRED_LCD #if HAS_WIRED_LCD
ui.set_status_P(GET_TEXT(MSG_G26_FIXED_LENGTH), 99); ui.set_status(GET_TEXT_F(MSG_G26_FIXED_LENGTH), 99);
ui.quick_feedback(); ui.quick_feedback();
#endif #endif
destination = current_position; destination = current_position;
@ -854,7 +854,7 @@ void GcodeSuite::G26() {
} while (--g26_repeats && location.valid()); } while (--g26_repeats && location.valid());
LEAVE: LEAVE:
ui.set_status_P(GET_TEXT(MSG_G26_LEAVING), -1); ui.set_status(GET_TEXT_F(MSG_G26_LEAVING), -1);
TERN_(EXTENSIBLE_UI, ExtUI::onMeshUpdate(location, ExtUI::G26_FINISH)); TERN_(EXTENSIBLE_UI, ExtUI::onMeshUpdate(location, ExtUI::G26_FINISH));
g26.retract_filament(destination); g26.retract_filament(destination);

4
Marlin/src/gcode/bedlevel/abl/G29.cpp

@ -636,7 +636,7 @@ G29_TYPE GcodeSuite::G29() {
if (TERN0(IS_KINEMATIC, !probe.can_reach(abl.probePos))) continue; if (TERN0(IS_KINEMATIC, !probe.can_reach(abl.probePos))) continue;
if (abl.verbose_level) SERIAL_ECHOLNPGM("Probing mesh point ", pt_index, "/", abl.abl_points, "."); if (abl.verbose_level) SERIAL_ECHOLNPGM("Probing mesh point ", pt_index, "/", abl.abl_points, ".");
TERN_(HAS_STATUS_MESSAGE, ui.status_printf_P(0, PSTR(S_FMT " %i/%i"), GET_TEXT(MSG_PROBING_POINT), int(pt_index), int(abl.abl_points))); TERN_(HAS_STATUS_MESSAGE, ui.status_printf(0, F(S_FMT " %i/%i"), GET_TEXT(MSG_PROBING_POINT), int(pt_index), int(abl.abl_points)));
abl.measured_z = faux ? 0.001f * random(-100, 101) : probe.probe_at_point(abl.probePos, raise_after, abl.verbose_level); abl.measured_z = faux ? 0.001f * random(-100, 101) : probe.probe_at_point(abl.probePos, raise_after, abl.verbose_level);
@ -681,7 +681,7 @@ G29_TYPE GcodeSuite::G29() {
LOOP_L_N(i, 3) { LOOP_L_N(i, 3) {
if (abl.verbose_level) SERIAL_ECHOLNPGM("Probing point ", i + 1, "/3."); if (abl.verbose_level) SERIAL_ECHOLNPGM("Probing point ", i + 1, "/3.");
TERN_(HAS_STATUS_MESSAGE, ui.status_printf_P(0, PSTR(S_FMT " %i/3"), GET_TEXT(MSG_PROBING_POINT), int(i + 1))); TERN_(HAS_STATUS_MESSAGE, ui.status_printf(0, F(S_FMT " %i/3"), GET_TEXT(MSG_PROBING_POINT), int(i + 1)));
// Retain the last probe position // Retain the last probe position
abl.probePos = xy_pos_t(points[i]); abl.probePos = xy_pos_t(points[i]);

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

@ -152,7 +152,7 @@ void GcodeSuite::G29() {
// After recording the last point, activate home and activate // After recording the last point, activate home and activate
mbl_probe_index = -1; mbl_probe_index = -1;
SERIAL_ECHOLNPGM("Mesh probing done."); SERIAL_ECHOLNPGM("Mesh probing done.");
TERN_(HAS_STATUS_MESSAGE, ui.set_status(GET_TEXT(MSG_MESH_DONE))); TERN_(HAS_STATUS_MESSAGE, LCD_MESSAGE(MSG_MESH_DONE));
BUZZ(100, 659); BUZZ(100, 659);
BUZZ(100, 698); BUZZ(100, 698);
@ -214,7 +214,7 @@ void GcodeSuite::G29() {
if (state == MeshNext) { if (state == MeshNext) {
SERIAL_ECHOLNPGM("MBL G29 point ", _MIN(mbl_probe_index, GRID_MAX_POINTS), " of ", GRID_MAX_POINTS); SERIAL_ECHOLNPGM("MBL G29 point ", _MIN(mbl_probe_index, GRID_MAX_POINTS), " of ", GRID_MAX_POINTS);
if (mbl_probe_index > 0) TERN_(HAS_STATUS_MESSAGE, ui.status_printf_P(0, PSTR(S_FMT " %i/%i"), GET_TEXT(MSG_PROBING_POINT), _MIN(mbl_probe_index, GRID_MAX_POINTS), int(GRID_MAX_POINTS))); if (mbl_probe_index > 0) TERN_(HAS_STATUS_MESSAGE, ui.status_printf(0, F(S_FMT " %i/%i"), GET_TEXT(MSG_PROBING_POINT), _MIN(mbl_probe_index, GRID_MAX_POINTS), int(GRID_MAX_POINTS)));
} }
report_current_position(); report_current_position();

2
Marlin/src/gcode/calibrate/G28.cpp

@ -156,7 +156,7 @@
homeaxis(Z_AXIS); homeaxis(Z_AXIS);
} }
else { else {
LCD_MESSAGEPGM(MSG_ZPROBE_OUT); LCD_MESSAGE(MSG_ZPROBE_OUT);
SERIAL_ECHO_MSG(STR_ZPROBE_OUT_SER); SERIAL_ECHO_MSG(STR_ZPROBE_OUT_SER);
} }
} }

6
Marlin/src/gcode/calibrate/G33.cpp

@ -477,11 +477,11 @@ void GcodeSuite::G33() {
SERIAL_ECHOLNPGM("G33 Auto Calibrate"); SERIAL_ECHOLNPGM("G33 Auto Calibrate");
// Report settings // Report settings
PGM_P const checkingac = PSTR("Checking... AC"); FSTR_P const checkingac = F("Checking... AC");
SERIAL_ECHOPGM_P(checkingac); SERIAL_ECHOF(checkingac);
if (verbose_level == 0) SERIAL_ECHOPGM(" (DRY-RUN)"); if (verbose_level == 0) SERIAL_ECHOPGM(" (DRY-RUN)");
SERIAL_EOL(); SERIAL_EOL();
ui.set_status_P(checkingac); ui.set_status(checkingac);
print_calibration_settings(_endstop_results, _angle_results); print_calibration_settings(_endstop_results, _angle_results);

8
Marlin/src/gcode/calibrate/G34_M422.cpp

@ -31,7 +31,7 @@
#include "../../module/stepper.h" #include "../../module/stepper.h"
#include "../../module/planner.h" #include "../../module/planner.h"
#include "../../module/probe.h" #include "../../module/probe.h"
#include "../../lcd/marlinui.h" // for LCD_MESSAGEPGM #include "../../lcd/marlinui.h" // for LCD_MESSAGE
#if HAS_LEVELING #if HAS_LEVELING
#include "../../feature/bedlevel/bedlevel.h" #include "../../feature/bedlevel/bedlevel.h"
@ -229,7 +229,7 @@ void GcodeSuite::G34() {
const float z_probed_height = probe.probe_at_point(z_stepper_align.xy[iprobe], raise_after, 0, true, false); const float z_probed_height = probe.probe_at_point(z_stepper_align.xy[iprobe], raise_after, 0, true, false);
if (isnan(z_probed_height)) { if (isnan(z_probed_height)) {
SERIAL_ECHOLNPGM("Probing failed"); SERIAL_ECHOLNPGM("Probing failed");
LCD_MESSAGEPGM(MSG_LCD_PROBING_FAILED); LCD_MESSAGE(MSG_LCD_PROBING_FAILED);
err_break = true; err_break = true;
break; break;
} }
@ -328,7 +328,7 @@ void GcodeSuite::G34() {
auto decreasing_accuracy = [](const_float_t v1, const_float_t v2) { auto decreasing_accuracy = [](const_float_t v1, const_float_t v2) {
if (v1 < v2 * 0.7f) { if (v1 < v2 * 0.7f) {
SERIAL_ECHOLNPGM("Decreasing Accuracy Detected."); SERIAL_ECHOLNPGM("Decreasing Accuracy Detected.");
LCD_MESSAGEPGM(MSG_DECREASING_ACCURACY); LCD_MESSAGE(MSG_DECREASING_ACCURACY);
return true; return true;
} }
return false; return false;
@ -411,7 +411,7 @@ void GcodeSuite::G34() {
if (success_break) { if (success_break) {
SERIAL_ECHOLNPGM("Target accuracy achieved."); SERIAL_ECHOLNPGM("Target accuracy achieved.");
LCD_MESSAGEPGM(MSG_ACCURACY_ACHIEVED); LCD_MESSAGE(MSG_ACCURACY_ACHIEVED);
break; break;
} }

2
Marlin/src/gcode/calibrate/G76_M192_M871.cpp

@ -351,7 +351,7 @@ void GcodeSuite::M192() {
} }
const celsius_t target_temp = parser.value_celsius(); const celsius_t target_temp = parser.value_celsius();
ui.set_status_P(thermalManager.isProbeBelowTemp(target_temp) ? GET_TEXT(MSG_PROBE_HEATING) : GET_TEXT(MSG_PROBE_COOLING)); ui.set_status(thermalManager.isProbeBelowTemp(target_temp) ? GET_TEXT_F(MSG_PROBE_HEATING) : GET_TEXT_F(MSG_PROBE_COOLING));
thermalManager.wait_for_probe(target_temp, no_wait_for_cooling); thermalManager.wait_for_probe(target_temp, no_wait_for_cooling);
} }

6
Marlin/src/gcode/calibrate/M48.cpp

@ -79,7 +79,7 @@ void GcodeSuite::M48() {
}; };
if (!probe.can_reach(test_position)) { if (!probe.can_reach(test_position)) {
ui.set_status_P(GET_TEXT(MSG_M48_OUT_OF_BOUNDS), 99); ui.set_status(GET_TEXT_F(MSG_M48_OUT_OF_BOUNDS), 99);
SERIAL_ECHOLNPGM("? (X,Y) out of bounds."); SERIAL_ECHOLNPGM("? (X,Y) out of bounds.");
return; return;
} }
@ -144,7 +144,7 @@ void GcodeSuite::M48() {
LOOP_L_N(n, n_samples) { LOOP_L_N(n, n_samples) {
#if HAS_STATUS_MESSAGE #if HAS_STATUS_MESSAGE
// Display M48 progress in the status bar // Display M48 progress in the status bar
ui.status_printf_P(0, PSTR(S_FMT ": %d/%d"), GET_TEXT(MSG_M48_POINT), int(n + 1), int(n_samples)); ui.status_printf(0, F(S_FMT ": %d/%d"), GET_TEXT(MSG_M48_POINT), int(n + 1), int(n_samples));
#endif #endif
// When there are "legs" of movement move around the point before probing // When there are "legs" of movement move around the point before probing
@ -260,7 +260,7 @@ void GcodeSuite::M48() {
#if HAS_STATUS_MESSAGE #if HAS_STATUS_MESSAGE
// Display M48 results in the status bar // Display M48 results in the status bar
char sigma_str[8]; char sigma_str[8];
ui.status_printf_P(0, PSTR(S_FMT ": %s"), GET_TEXT(MSG_M48_DEVIATION), dtostrf(sigma, 2, 6, sigma_str)); ui.status_printf(0, F(S_FMT ": %s"), GET_TEXT(MSG_M48_DEVIATION), dtostrf(sigma, 2, 6, sigma_str));
#endif #endif
} }

2
Marlin/src/gcode/control/M17_M18_M84.cpp

@ -136,7 +136,7 @@ void GcodeSuite::M17() {
} }
} }
else { else {
LCD_MESSAGEPGM(MSG_NO_MOVE); LCD_MESSAGE(MSG_NO_MOVE);
stepper.enable_all_steppers(); stepper.enable_all_steppers();
} }
} }

4
Marlin/src/gcode/control/M80_M81.cpp

@ -25,7 +25,7 @@
#include "../../module/temperature.h" #include "../../module/temperature.h"
#include "../../module/planner.h" // for planner.finish_and_disable #include "../../module/planner.h" // for planner.finish_and_disable
#include "../../module/printcounter.h" // for print_job_timer.stop #include "../../module/printcounter.h" // for print_job_timer.stop
#include "../../lcd/marlinui.h" // for LCD_MESSAGEPGM_P #include "../../lcd/marlinui.h" // for LCD_MESSAGE_F
#include "../../inc/MarlinConfig.h" #include "../../inc/MarlinConfig.h"
@ -95,5 +95,5 @@ void GcodeSuite::M81() {
powerManager.power_off_soon(); powerManager.power_off_soon();
#endif #endif
LCD_MESSAGEPGM_P(PSTR(MACHINE_NAME " " STR_OFF ".")); LCD_MESSAGE_F(MACHINE_NAME " " STR_OFF ".");
} }

4
Marlin/src/gcode/geometry/M206_M428.cpp

@ -91,7 +91,7 @@ void GcodeSuite::M428() {
diff[i] = -current_position[i]; diff[i] = -current_position[i];
if (!WITHIN(diff[i], -20, 20)) { if (!WITHIN(diff[i], -20, 20)) {
SERIAL_ERROR_MSG(STR_ERR_M428_TOO_FAR); SERIAL_ERROR_MSG(STR_ERR_M428_TOO_FAR);
LCD_ALERTMESSAGEPGM_P(PSTR("Err: Too far!")); LCD_ALERTMESSAGE_F("Err: Too far!");
BUZZ(200, 40); BUZZ(200, 40);
return; return;
} }
@ -99,7 +99,7 @@ void GcodeSuite::M428() {
LOOP_LINEAR_AXES(i) set_home_offset((AxisEnum)i, diff[i]); LOOP_LINEAR_AXES(i) set_home_offset((AxisEnum)i, diff[i]);
report_current_position(); report_current_position();
LCD_MESSAGEPGM(MSG_HOME_OFFSETS_APPLIED); LCD_MESSAGE(MSG_HOME_OFFSETS_APPLIED);
BUZZ(100, 659); BUZZ(100, 659);
BUZZ(100, 698); BUZZ(100, 698);
} }

2
Marlin/src/gcode/lcd/M0_M1.cpp

@ -59,7 +59,7 @@ void GcodeSuite::M0_M1() {
if (parser.string_arg) if (parser.string_arg)
ui.set_status(parser.string_arg, true); ui.set_status(parser.string_arg, true);
else { else {
LCD_MESSAGEPGM(MSG_USERWAIT); LCD_MESSAGE(MSG_USERWAIT);
#if ENABLED(LCD_PROGRESS_BAR) && PROGRESS_MSG_EXPIRE > 0 #if ENABLED(LCD_PROGRESS_BAR) && PROGRESS_MSG_EXPIRE > 0
ui.reset_progress_bar_timeout(); ui.reset_progress_bar_timeout();
#endif #endif

2
Marlin/src/gcode/motion/G4.cpp

@ -38,7 +38,7 @@ void GcodeSuite::G4() {
SERIAL_ECHOLNPGM(STR_Z_MOVE_COMP); SERIAL_ECHOLNPGM(STR_Z_MOVE_COMP);
#endif #endif
if (!ui.has_status()) LCD_MESSAGEPGM(MSG_DWELL); if (!ui.has_status()) LCD_MESSAGE(MSG_DWELL);
dwell(dwell_ms); dwell(dwell_ms);
} }

2
Marlin/src/gcode/queue.cpp

@ -513,7 +513,7 @@ void GCodeQueue::get_serial_commands() {
TERN_(BEZIER_CURVE_SUPPORT, case 5:) TERN_(BEZIER_CURVE_SUPPORT, case 5:)
PORT_REDIRECT(SERIAL_PORTMASK(p)); // Reply to the serial port that sent the command PORT_REDIRECT(SERIAL_PORTMASK(p)); // Reply to the serial port that sent the command
SERIAL_ECHOLNPGM(STR_ERR_STOPPED); SERIAL_ECHOLNPGM(STR_ERR_STOPPED);
LCD_MESSAGEPGM(MSG_STOPPED); LCD_MESSAGE(MSG_STOPPED);
break; break;
} }
} }

2
Marlin/src/gcode/temp/M140_M190.cpp

@ -83,7 +83,7 @@ void GcodeSuite::M140_M190(const bool isM190) {
thermalManager.setTargetBed(temp); thermalManager.setTargetBed(temp);
ui.set_status_P(thermalManager.isHeatingBed() ? GET_TEXT(MSG_BED_HEATING) : GET_TEXT(MSG_BED_COOLING)); ui.set_status(thermalManager.isHeatingBed() ? GET_TEXT_F(MSG_BED_HEATING) : GET_TEXT_F(MSG_BED_COOLING));
// with PRINTJOB_TIMER_AUTOSTART, M190 can start the timer, and M140 can stop it // with PRINTJOB_TIMER_AUTOSTART, M190 can start the timer, and M140 can stop it
TERN_(PRINTJOB_TIMER_AUTOSTART, thermalManager.auto_job_check_timer(isM190, !isM190)); TERN_(PRINTJOB_TIMER_AUTOSTART, thermalManager.auto_job_check_timer(isM190, !isM190));

2
Marlin/src/gcode/temp/M141_M191.cpp

@ -69,7 +69,7 @@ void GcodeSuite::M191() {
const bool is_heating = thermalManager.isHeatingChamber(); const bool is_heating = thermalManager.isHeatingChamber();
if (is_heating || !no_wait_for_cooling) { if (is_heating || !no_wait_for_cooling) {
ui.set_status_P(is_heating ? GET_TEXT(MSG_CHAMBER_HEATING) : GET_TEXT(MSG_CHAMBER_COOLING)); ui.set_status(is_heating ? GET_TEXT_F(MSG_CHAMBER_HEATING) : GET_TEXT_F(MSG_CHAMBER_COOLING));
thermalManager.wait_for_chamber(false); thermalManager.wait_for_chamber(false);
} }
} }

2
Marlin/src/gcode/temp/M143_M193.cpp

@ -58,7 +58,7 @@ void GcodeSuite::M193() {
cooler.enable(); cooler.enable();
thermalManager.setTargetCooler(parser.value_celsius()); thermalManager.setTargetCooler(parser.value_celsius());
if (thermalManager.isLaserCooling()) { if (thermalManager.isLaserCooling()) {
ui.set_status_P(GET_TEXT(MSG_LASER_COOLING)); LCD_MESSAGE(MSG_LASER_COOLING);
thermalManager.wait_for_cooler(true); thermalManager.wait_for_cooler(true);
} }
} }

2
Marlin/src/gcode/temp/M303.cpp

@ -85,7 +85,7 @@ void GcodeSuite::M303() {
KEEPALIVE_STATE(NOT_BUSY); KEEPALIVE_STATE(NOT_BUSY);
#endif #endif
LCD_MESSAGEPGM(MSG_PID_AUTOTUNE); LCD_MESSAGE(MSG_PID_AUTOTUNE);
thermalManager.PID_autotune(temp, hid, c, u); thermalManager.PID_autotune(temp, hid, c, u);
ui.reset_status(); ui.reset_status();
} }

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

@ -4287,16 +4287,16 @@ void DWIN_CompletedLeveling() {
if (checkkey == Leveling) Goto_MainMenu(); if (checkkey == Leveling) Goto_MainMenu();
} }
void DWIN_StatusChanged(const char *text) { void DWIN_StatusChanged(const char * const cstr/*=nullptr*/) {
DWIN_Draw_Rectangle(1, Color_Bg_Blue, 0, STATUS_Y, DWIN_WIDTH, STATUS_Y + 24); DWIN_Draw_Rectangle(1, Color_Bg_Blue, 0, STATUS_Y, DWIN_WIDTH, STATUS_Y + 24);
const int8_t x = _MAX(0U, DWIN_WIDTH - strlen_P(text) * MENU_CHR_W) / 2; const int8_t x = _MAX(0U, DWIN_WIDTH - strlen(cstr) * MENU_CHR_W) / 2;
DWIN_Draw_String(false, font8x16, Color_White, Color_Bg_Blue, x, STATUS_Y + 3, F(text)); DWIN_Draw_String(false, font8x16, Color_White, Color_Bg_Blue, x, STATUS_Y + 3, cstr);
DWIN_UpdateLCD(); DWIN_UpdateLCD();
} }
void DWIN_StatusChanged_P(PGM_P const pstr) { void DWIN_StatusChanged(FSTR_P const fstr) {
char str[strlen_P((const char*)pstr) + 1]; char str[strlen_P(FTOP(fstr)) + 1];
strcpy_P(str, (const char*)pstr); strcpy_P(str, FTOP(fstr));
DWIN_StatusChanged(str); DWIN_StatusChanged(str);
} }

4
Marlin/src/lcd/e3v2/creality/dwin.h

@ -244,8 +244,8 @@ void HMI_Init();
void DWIN_Update(); void DWIN_Update();
void EachMomentUpdate(); void EachMomentUpdate();
void DWIN_HandleScreen(); void DWIN_HandleScreen();
void DWIN_StatusChanged(const char *text); void DWIN_StatusChanged(const char * const cstr=nullptr);
void DWIN_StatusChanged_P(PGM_P const pstr); void DWIN_StatusChanged(FSTR_P const fstr);
inline void DWIN_StartHoming() { HMI_flag.home_flag = true; } inline void DWIN_StartHoming() { HMI_flag.home_flag = true; }

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

@ -713,7 +713,7 @@ void Draw_Main_Menu() {
void Goto_Main_Menu() { void Goto_Main_Menu() {
checkkey = MainMenu; checkkey = MainMenu;
DWIN_StatusChanged(nullptr); DWIN_StatusChanged();
Draw_Main_Menu(); Draw_Main_Menu();
} }
@ -1758,20 +1758,20 @@ void DWIN_Startup() {
HMI_SetLanguage(); HMI_SetLanguage();
} }
void DWIN_DrawStatusLine(const uint16_t color, const uint16_t bgcolor, const char *text) { void DWIN_DrawStatusLine(const uint16_t color, const uint16_t bgcolor, const char * const text/*=nullptr*/) {
DWIN_Draw_Rectangle(1, bgcolor, 0, STATUS_Y, DWIN_WIDTH, STATUS_Y + 20); DWIN_Draw_Rectangle(1, bgcolor, 0, STATUS_Y, DWIN_WIDTH, STATUS_Y + 20);
if (text) DWINUI::Draw_CenteredString(color, STATUS_Y + 2, text); if (text) DWINUI::Draw_CenteredString(color, STATUS_Y + 2, text);
DWIN_UpdateLCD(); DWIN_UpdateLCD();
} }
// Update Status line // Update Status line
void DWIN_StatusChanged(const char *text) { void DWIN_StatusChanged(const char * const cstr/*=nullptr*/) {
DWIN_DrawStatusLine(HMI_data.StatusTxt_Color, HMI_data.StatusBg_Color, text); DWIN_DrawStatusLine(HMI_data.StatusTxt_Color, HMI_data.StatusBg_Color, cstr);
} }
void DWIN_StatusChanged_P(PGM_P const pstr) { void DWIN_StatusChanged(FSTR_P const fstr) {
char str[strlen_P((const char*)pstr) + 1]; char str[strlen_P(FTOP(fstr)) + 1];
strcpy_P(str, (const char*)pstr); strcpy_P(str, FTOP(fstr));
DWIN_StatusChanged(str); DWIN_StatusChanged(str);
} }
@ -1806,7 +1806,7 @@ void DWIN_Progress_Update() {
#if HAS_FILAMENT_SENSOR #if HAS_FILAMENT_SENSOR
// Filament Runout process // Filament Runout process
void DWIN_FilamentRunout(const uint8_t extruder) { ui.set_status_P(GET_TEXT(MSG_RUNOUT_SENSOR)); } void DWIN_FilamentRunout(const uint8_t extruder) { LCD_MESSAGE(MSG_RUNOUT_SENSOR); }
#endif #endif
void DWIN_SetColorDefaults() { void DWIN_SetColorDefaults() {
@ -1891,7 +1891,7 @@ void DWIN_Redraw_screen() {
case PAUSE_MESSAGE_OPTION: DWIN_Popup_FilamentPurge(); break; case PAUSE_MESSAGE_OPTION: DWIN_Popup_FilamentPurge(); break;
case PAUSE_MESSAGE_RESUME: DWIN_Popup_Pause(GET_TEXT_F(MSG_FILAMENT_CHANGE_RESUME)); break; case PAUSE_MESSAGE_RESUME: DWIN_Popup_Pause(GET_TEXT_F(MSG_FILAMENT_CHANGE_RESUME)); break;
case PAUSE_MESSAGE_HEAT: DWIN_Popup_Pause(GET_TEXT_F(MSG_FILAMENT_CHANGE_HEAT), ICON_Continue_E); break; case PAUSE_MESSAGE_HEAT: DWIN_Popup_Pause(GET_TEXT_F(MSG_FILAMENT_CHANGE_HEAT), ICON_Continue_E); break;
case PAUSE_MESSAGE_HEATING: ui.set_status_P(GET_TEXT(MSG_FILAMENT_CHANGE_HEATING)); break; case PAUSE_MESSAGE_HEATING: LCD_MESSAGE(MSG_FILAMENT_CHANGE_HEATING); break;
case PAUSE_MESSAGE_STATUS: HMI_ReturnScreen(); break; case PAUSE_MESSAGE_STATUS: HMI_ReturnScreen(); break;
default: break; default: break;
} }
@ -2183,7 +2183,7 @@ void SetMoveZto0() {
); );
gcode.process_subcommands_now(cmd); gcode.process_subcommands_now(cmd);
planner.synchronize(); planner.synchronize();
ui.set_status_P(PSTR("Now adjust Z Offset")); LCD_MESSAGE_F("Now adjust Z Offset");
HMI_AudioFeedback(true); HMI_AudioFeedback(true);
} }
@ -2240,7 +2240,7 @@ void Goto_LockScreen() { DWIN_LockScreen(true); }
void SetProbeOffsetY() { SetPFloatOnClick(-50, 50, UNITFDIGITS); } void SetProbeOffsetY() { SetPFloatOnClick(-50, 50, UNITFDIGITS); }
void SetProbeOffsetZ() { SetPFloatOnClick(-10, 10, 2); } void SetProbeOffsetZ() { SetPFloatOnClick(-10, 10, 2); }
void ProbeTest() { void ProbeTest() {
ui.set_status_P(GET_TEXT(MSG_M48_TEST)); LCD_MESSAGE(MSG_M48_TEST);
queue.inject(F("G28O\nM48 P10")); queue.inject(F("G28O\nM48 P10"));
} }
#endif #endif
@ -2297,7 +2297,7 @@ void DWIN_ApplyColor() {
DWINUI::SetColors(HMI_data.Text_Color, HMI_data.Background_Color); DWINUI::SetColors(HMI_data.Text_Color, HMI_data.Background_Color);
Draw_Status_Area(false); Draw_Status_Area(false);
Draw_SelectColors_Menu(); Draw_SelectColors_Menu();
ui.set_status_P(PSTR("Colors applied")); LCD_MESSAGE_F("Colors applied");
} }
void SetSpeed() { SetPIntOnClick(MIN_PRINT_SPEED, MAX_PRINT_SPEED); } void SetSpeed() { SetPIntOnClick(MIN_PRINT_SPEED, MAX_PRINT_SPEED); }
@ -2325,18 +2325,18 @@ void SetSpeed() { SetPIntOnClick(MIN_PRINT_SPEED, MAX_PRINT_SPEED); }
} }
void ParkHead(){ void ParkHead(){
ui.set_status_P(GET_TEXT(MSG_FILAMENT_PARK_ENABLED)); LCD_MESSAGE(MSG_FILAMENT_PARK_ENABLED);
queue.inject(F("G28O\nG27")); queue.inject(F("G28O\nG27"));
} }
#if ENABLED(FILAMENT_LOAD_UNLOAD_GCODES) #if ENABLED(FILAMENT_LOAD_UNLOAD_GCODES)
void UnloadFilament(){ void UnloadFilament(){
ui.set_status_P(GET_TEXT(MSG_FILAMENTUNLOAD)); LCD_MESSAGE(MSG_FILAMENTUNLOAD);
queue.inject(F("M702 Z20")); queue.inject(F("M702 Z20"));
} }
void LoadFilament(){ void LoadFilament(){
ui.set_status_P(GET_TEXT(MSG_FILAMENTLOAD)); LCD_MESSAGE(MSG_FILAMENTLOAD);
queue.inject(F("M701 Z20")); queue.inject(F("M701 Z20"));
} }
#endif #endif
@ -2362,23 +2362,23 @@ void LevBed(uint8_t point) {
switch (point) { switch (point) {
case 0: case 0:
ui.set_status_P(GET_TEXT(MSG_LEVBED_FL)); LCD_MESSAGE(MSG_LEVBED_FL);
xpos = ypos = margin; xpos = ypos = margin;
break; break;
case 1: case 1:
ui.set_status_P(GET_TEXT(MSG_LEVBED_FR)); LCD_MESSAGE(MSG_LEVBED_FR);
xpos = X_BED_SIZE - margin; ypos = margin; xpos = X_BED_SIZE - margin; ypos = margin;
break; break;
case 2: case 2:
ui.set_status_P(GET_TEXT(MSG_LEVBED_BR)); LCD_MESSAGE(MSG_LEVBED_BR);
xpos = X_BED_SIZE - margin; ypos = Y_BED_SIZE - margin; xpos = X_BED_SIZE - margin; ypos = Y_BED_SIZE - margin;
break; break;
case 3: case 3:
ui.set_status_P(GET_TEXT(MSG_LEVBED_BL)); LCD_MESSAGE(MSG_LEVBED_BL);
xpos = margin; ypos = Y_BED_SIZE - margin; xpos = margin; ypos = Y_BED_SIZE - margin;
break; break;
case 4: case 4:
ui.set_status_P(GET_TEXT(MSG_LEVBED_C)); LCD_MESSAGE(MSG_LEVBED_C);
xpos = X_BED_SIZE / 2; ypos = Y_BED_SIZE / 2; xpos = X_BED_SIZE / 2; ypos = Y_BED_SIZE / 2;
break; break;
} }
@ -2393,7 +2393,7 @@ void LevBed(uint8_t point) {
dtostrf(ypos, 1, 1, str_2), dtostrf(ypos, 1, 1, str_2),
dtostrf(zval, 1, 2, str_3) dtostrf(zval, 1, 2, str_3)
); );
ui.set_status_P(cmd); ui.set_status(cmd);
#else #else
planner.synchronize(); planner.synchronize();
sprintf_P(cmd, PSTR(fmt), xpos, ypos); sprintf_P(cmd, PSTR(fmt), xpos, ypos);
@ -2410,7 +2410,7 @@ void LevBedC () { LevBed(4); }
#if ENABLED(MESH_BED_LEVELING) #if ENABLED(MESH_BED_LEVELING)
void ManualMeshStart(){ void ManualMeshStart(){
ui.set_status_P(GET_TEXT(MSG_UBL_BUILD_MESH_MENU)); LCD_MESSAGE(MSG_UBL_BUILD_MESH_MENU);
gcode.process_subcommands_now(F("G28 XYO\nG28 Z\nM211 S0\nG29S1")); gcode.process_subcommands_now(F("G28 XYO\nG28 Z\nM211 S0\nG29S1"));
planner.synchronize(); planner.synchronize();
#ifdef MANUAL_PROBE_START_Z #ifdef MANUAL_PROBE_START_Z
@ -2435,7 +2435,7 @@ void LevBedC () { LevBed(4); }
} }
void ManualMeshSave(){ void ManualMeshSave(){
ui.set_status_P(GET_TEXT(MSG_UBL_STORAGE_MESH_MENU)); LCD_MESSAGE(MSG_UBL_STORAGE_MESH_MENU);
queue.inject(F("M211 S1\nM500")); queue.inject(F("M211 S1\nM500"));
} }
@ -3092,11 +3092,11 @@ void HMI_SetPFloat() {
// Menu Creation and Drawing functions ====================================================== // Menu Creation and Drawing functions ======================================================
void SetMenuTitle(frame_rect_t cn, frame_rect_t en, const __FlashStringHelper* text) { void SetMenuTitle(frame_rect_t cn, frame_rect_t en, const __FlashStringHelper* fstr) {
if (HMI_IsChinese() && (cn.w != 0)) if (HMI_IsChinese() && (cn.w != 0))
CurrentMenu->MenuTitle.SetFrame(cn.x, cn.y, cn.w, cn.h); CurrentMenu->MenuTitle.SetFrame(cn.x, cn.y, cn.w, cn.h);
else else
CurrentMenu->MenuTitle.SetCaption(text); CurrentMenu->MenuTitle.SetCaption(fstr);
} }
void Draw_Prepare_Menu() { void Draw_Prepare_Menu() {
@ -3234,7 +3234,7 @@ void Draw_Move_Menu() {
#endif #endif
} }
CurrentMenu->draw(); CurrentMenu->draw();
if (!all_axes_trusted()) ui.set_status_P(PSTR("WARNING: position is unknow")); if (!all_axes_trusted()) LCD_MESSAGE_F("WARNING: position is unknown");
} }
#if HAS_HOME_OFFSET #if HAS_HOME_OFFSET
@ -3440,11 +3440,11 @@ void Draw_Motion_Menu() {
#if HAS_PREHEAT #if HAS_PREHEAT
void Draw_Preheat_Menu(frame_rect_t cn, frame_rect_t en, const __FlashStringHelper* text) { void Draw_Preheat_Menu(frame_rect_t cn, frame_rect_t en, const __FlashStringHelper* fstr) {
checkkey = Menu; checkkey = Menu;
if (CurrentMenu != PreheatMenu) { if (CurrentMenu != PreheatMenu) {
CurrentMenu = PreheatMenu; CurrentMenu = PreheatMenu;
SetMenuTitle(cn, en, text); SetMenuTitle(cn, en, fstr);
DWINUI::MenuItemsPrepare(5); DWINUI::MenuItemsPrepare(5);
ADDMENUITEM(ICON_Back, GET_TEXT_F(MSG_BUTTON_BACK), onDrawBack, Draw_Temperature_Menu); ADDMENUITEM(ICON_Back, GET_TEXT_F(MSG_BUTTON_BACK), onDrawBack, Draw_Temperature_Menu);
#if HAS_HOTEND #if HAS_HOTEND
@ -3648,7 +3648,7 @@ void Draw_Steps_Menu() {
ADDMENUITEM_P(ICON_Zoffset, GET_TEXT_F(MSG_ZPROBE_ZOFFSET), onDrawPFloat2Menu, SetZOffset, &BABY_Z_VAR); ADDMENUITEM_P(ICON_Zoffset, GET_TEXT_F(MSG_ZPROBE_ZOFFSET), onDrawPFloat2Menu, SetZOffset, &BABY_Z_VAR);
} }
CurrentMenu->draw(); CurrentMenu->draw();
if (!axis_is_trusted(Z_AXIS)) ui.set_status_P(PSTR("WARNING: Z position is unknow, move Z to home")); if (!axis_is_trusted(Z_AXIS)) LCD_MESSAGE_F("WARNING: Z position unknown, move Z to home");
} }
#endif #endif

6
Marlin/src/lcd/e3v2/enhanced/dwin.h

@ -179,9 +179,9 @@ void EachMomentUpdate();
void update_variable(); void update_variable();
void DWIN_HandleScreen(); void DWIN_HandleScreen();
void DWIN_Update(); void DWIN_Update();
void DWIN_DrawStatusLine(const uint16_t color, const uint16_t bgcolor, const char *text); void DWIN_DrawStatusLine(const uint16_t color, const uint16_t bgcolor, const char *text=nullptr);
void DWIN_StatusChanged(const char * const text); void DWIN_StatusChanged(const char * const cstr=nullptr);
void DWIN_StatusChanged_P(PGM_P const text); void DWIN_StatusChanged(FSTR_P const fstr);
void DWIN_StartHoming(); void DWIN_StartHoming();
void DWIN_CompletedHoming(); void DWIN_CompletedHoming();
#if HAS_MESH #if HAS_MESH

2
Marlin/src/lcd/e3v2/enhanced/meshviewer.cpp

@ -66,7 +66,7 @@ void MeshViewerClass::Draw() {
} }
} }
char str_1[6], str_2[6] = ""; char str_1[6], str_2[6] = "";
ui.status_printf_P(0, PSTR("Mesh minZ: %s, maxZ: %s"), ui.status_printf(0, F("Mesh minZ: %s, maxZ: %s"),
dtostrf((float)minz / 100, 1, 2, str_1), dtostrf((float)minz / 100, 1, 2, str_1),
dtostrf((float)maxz / 100, 1, 2, str_2) dtostrf((float)maxz / 100, 1, 2, str_2)
); );

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

@ -2018,7 +2018,7 @@ void get_wifi_commands() {
TERN_(ARC_SUPPORT, case 2 ... 3:) TERN_(ARC_SUPPORT, case 2 ... 3:)
TERN_(BEZIER_CURVE_SUPPORT, case 5:) TERN_(BEZIER_CURVE_SUPPORT, case 5:)
SERIAL_ECHOLNPGM(STR_ERR_STOPPED); SERIAL_ECHOLNPGM(STR_ERR_STOPPED);
LCD_MESSAGEPGM(MSG_STOPPED); LCD_MESSAGE(MSG_STOPPED);
break; break;
} }
} }

65
Marlin/src/lcd/marlinui.cpp

@ -665,7 +665,7 @@ constexpr uint8_t epps = ENCODER_PULSES_PER_STEP;
void MarlinUI::kill_screen(PGM_P lcd_error, PGM_P lcd_component) { void MarlinUI::kill_screen(PGM_P lcd_error, PGM_P lcd_component) {
init(); init();
status_printf_P(1, PSTR(S_FMT ": " S_FMT), lcd_error, lcd_component); status_printf(1, F(S_FMT ": " S_FMT), lcd_error, lcd_component);
TERN_(HAS_LCD_MENU, return_to_status()); TERN_(HAS_LCD_MENU, return_to_status());
// RED ALERT. RED ALERT. // RED ALERT. RED ALERT.
@ -1393,76 +1393,77 @@ constexpr uint8_t epps = ENCODER_PULSES_PER_STEP;
#if SERVICE_INTERVAL_3 > 0 #if SERVICE_INTERVAL_3 > 0
static PGMSTR(service3, "> " SERVICE_NAME_3 "!"); static PGMSTR(service3, "> " SERVICE_NAME_3 "!");
#endif #endif
PGM_P msg; FSTR_P msg;
if (printingIsPaused()) if (printingIsPaused())
msg = GET_TEXT(MSG_PRINT_PAUSED); msg = GET_TEXT_F(MSG_PRINT_PAUSED);
#if ENABLED(SDSUPPORT) #if ENABLED(SDSUPPORT)
else if (IS_SD_PRINTING()) else if (IS_SD_PRINTING())
return set_status(card.longest_filename(), true); return set_status(card.longest_filename(), true);
#endif #endif
else if (print_job_timer.isRunning()) else if (print_job_timer.isRunning())
msg = GET_TEXT(MSG_PRINTING); msg = GET_TEXT_F(MSG_PRINTING);
#if SERVICE_INTERVAL_1 > 0 #if SERVICE_INTERVAL_1 > 0
else if (print_job_timer.needsService(1)) msg = service1; else if (print_job_timer.needsService(1)) msg = FPSTR(service1);
#endif #endif
#if SERVICE_INTERVAL_2 > 0 #if SERVICE_INTERVAL_2 > 0
else if (print_job_timer.needsService(2)) msg = service2; else if (print_job_timer.needsService(2)) msg = FPSTR(service2);
#endif #endif
#if SERVICE_INTERVAL_3 > 0 #if SERVICE_INTERVAL_3 > 0
else if (print_job_timer.needsService(3)) msg = service3; else if (print_job_timer.needsService(3)) msg = FPSTR(service3);
#endif #endif
else if (!no_welcome) else if (!no_welcome)
msg = GET_TEXT(WELCOME_MSG); msg = GET_TEXT_F(WELCOME_MSG);
else else
return; return;
set_status_P(msg, -1); set_status(msg, -1);
} }
void MarlinUI::set_status_P(PGM_P const message, int8_t level) { void MarlinUI::set_status(FSTR_P const fstr, int8_t level) {
PGM_P const pstr = FTOP(fstr);
if (level < 0) level = alert_level = 0; if (level < 0) level = alert_level = 0;
if (level < alert_level) return; if (level < alert_level) return;
alert_level = level; alert_level = level;
TERN_(HOST_PROMPT_SUPPORT, host_action_notify_P(message)); TERN_(HOST_PROMPT_SUPPORT, host_action_notify_P(pstr));
// Since the message is encoded in UTF8 it must // Since the message is encoded in UTF8 it must
// only be cut on a character boundary. // only be cut on a character boundary.
// Get a pointer to the null terminator // Get a pointer to the null terminator
PGM_P pend = message + strlen_P(message); PGM_P pend = pstr + strlen_P(pstr);
// If length of supplied UTF8 string is greater than // If length of supplied UTF8 string is greater than
// the buffer size, start cutting whole UTF8 chars // the buffer size, start cutting whole UTF8 chars
while ((pend - message) > MAX_MESSAGE_LENGTH) { while ((pend - pstr) > MAX_MESSAGE_LENGTH) {
--pend; --pend;
while (!START_OF_UTF8_CHAR(pgm_read_byte(pend))) --pend; while (!START_OF_UTF8_CHAR(pgm_read_byte(pend))) --pend;
}; };
// At this point, we have the proper cut point. Use it // At this point, we have the proper cut point. Use it
uint8_t maxLen = pend - message; uint8_t maxLen = pend - pstr;
strncpy_P(status_message, message, maxLen); strncpy_P(status_message, pstr, maxLen);
status_message[maxLen] = '\0'; status_message[maxLen] = '\0';
finish_status(level > 0); finish_status(level > 0);
} }
void MarlinUI::set_alert_status_P(PGM_P const message) { void MarlinUI::set_alert_status(FSTR_P const fstr) {
set_status_P(message, 1); set_status(fstr, 1);
TERN_(HAS_TOUCH_SLEEP, wakeup_screen()); TERN_(HAS_TOUCH_SLEEP, wakeup_screen());
TERN_(HAS_LCD_MENU, return_to_status()); TERN_(HAS_LCD_MENU, return_to_status());
} }
#include <stdarg.h> #include <stdarg.h>
void MarlinUI::status_printf_P(const uint8_t level, PGM_P const fmt, ...) { void MarlinUI::status_printf(const uint8_t level, FSTR_P const fmt, ...) {
if (level < alert_level) return; if (level < alert_level) return;
alert_level = level; alert_level = level;
va_list args; va_list args;
va_start(args, fmt); va_start(args, FTOP(fmt));
vsnprintf_P(status_message, MAX_MESSAGE_LENGTH, fmt, args); vsnprintf_P(status_message, MAX_MESSAGE_LENGTH, FTOP(fmt), args);
va_end(args); va_end(args);
finish_status(level > 0); finish_status(level > 0);
} }
@ -1536,7 +1537,7 @@ constexpr uint8_t epps = ENCODER_PULSES_PER_STEP;
#endif #endif
IF_DISABLED(SDSUPPORT, print_job_timer.stop()); IF_DISABLED(SDSUPPORT, print_job_timer.stop());
TERN_(HOST_PROMPT_SUPPORT, host_prompt_open(PROMPT_INFO, PSTR("UI Aborted"), DISMISS_STR)); TERN_(HOST_PROMPT_SUPPORT, host_prompt_open(PROMPT_INFO, PSTR("UI Aborted"), DISMISS_STR));
LCD_MESSAGEPGM(MSG_PRINT_ABORTED); LCD_MESSAGE(MSG_PRINT_ABORTED);
TERN_(HAS_LCD_MENU, return_to_status()); TERN_(HAS_LCD_MENU, return_to_status());
} }
@ -1548,7 +1549,7 @@ constexpr uint8_t epps = ENCODER_PULSES_PER_STEP;
#endif #endif
void MarlinUI::flow_fault() { void MarlinUI::flow_fault() {
LCD_ALERTMESSAGEPGM(MSG_FLOWMETER_FAULT); LCD_ALERTMESSAGE(MSG_FLOWMETER_FAULT);
TERN_(HAS_BUZZER, buzz(1000, 440)); TERN_(HAS_BUZZER, buzz(1000, 440));
TERN_(HAS_LCD_MENU, return_to_status()); TERN_(HAS_LCD_MENU, return_to_status());
} }
@ -1566,7 +1567,7 @@ constexpr uint8_t epps = ENCODER_PULSES_PER_STEP;
TERN_(HAS_TOUCH_SLEEP, wakeup_screen()); TERN_(HAS_TOUCH_SLEEP, wakeup_screen());
TERN_(HOST_PROMPT_SUPPORT, host_prompt_open(PROMPT_PAUSE_RESUME, PSTR("UI Pause"), PSTR("Resume"))); TERN_(HOST_PROMPT_SUPPORT, host_prompt_open(PROMPT_PAUSE_RESUME, PSTR("UI Pause"), PSTR("Resume")));
LCD_MESSAGEPGM(MSG_PRINT_PAUSED); LCD_MESSAGE(MSG_PRINT_PAUSED);
#if ENABLED(PARK_HEAD_ON_PAUSE) #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 pause_show_message(PAUSE_MESSAGE_PARKING, PAUSE_MODE_PAUSE_PRINT); // Show message immediately to let user know about pause in progress
@ -1637,14 +1638,14 @@ constexpr uint8_t epps = ENCODER_PULSES_PER_STEP;
// //
// Send the status line as a host notification // Send the status line as a host notification
// //
void MarlinUI::set_status(const char * const message, const bool) { void MarlinUI::set_status(const char * const cstr, const bool) {
TERN(HOST_PROMPT_SUPPORT, host_action_notify(message), UNUSED(message)); TERN(HOST_PROMPT_SUPPORT, host_action_notify(cstr), UNUSED(cstr));
} }
void MarlinUI::set_status_P(PGM_P message, const int8_t) { void MarlinUI::set_status(FSTR_P const fstr, const int8_t) {
TERN(HOST_PROMPT_SUPPORT, host_action_notify_P(message), UNUSED(message)); TERN(HOST_PROMPT_SUPPORT, host_action_notify_P(FTOP(fstr)), UNUSED(fstr));
} }
void MarlinUI::status_printf_P(const uint8_t, PGM_P const message, ...) { void MarlinUI::status_printf(const uint8_t, FSTR_P const fstr, ...) {
TERN(HOST_PROMPT_SUPPORT, host_action_notify_P(message), UNUSED(message)); TERN(HOST_PROMPT_SUPPORT, host_action_notify_P(FPSTR(fstr)), UNUSED(fstr));
} }
#endif // !HAS_DISPLAY && !HAS_STATUS_MESSAGE #endif // !HAS_DISPLAY && !HAS_STATUS_MESSAGE
@ -1670,7 +1671,7 @@ constexpr uint8_t epps = ENCODER_PULSES_PER_STEP;
quick_feedback(); quick_feedback();
goto_screen(MEDIA_MENU_GATEWAY); goto_screen(MEDIA_MENU_GATEWAY);
#else #else
LCD_MESSAGEPGM(MSG_MEDIA_INSERTED); LCD_MESSAGE(MSG_MEDIA_INSERTED);
#endif #endif
} }
} }
@ -1679,7 +1680,7 @@ constexpr uint8_t epps = ENCODER_PULSES_PER_STEP;
#if ENABLED(EXTENSIBLE_UI) #if ENABLED(EXTENSIBLE_UI)
ExtUI::onMediaRemoved(); ExtUI::onMediaRemoved();
#elif PIN_EXISTS(SD_DETECT) #elif PIN_EXISTS(SD_DETECT)
LCD_MESSAGEPGM(MSG_MEDIA_REMOVED); LCD_MESSAGE(MSG_MEDIA_REMOVED);
#if HAS_LCD_MENU #if HAS_LCD_MENU
if (!defer_return_to_status) return_to_status(); if (!defer_return_to_status) return_to_status();
#endif #endif
@ -1802,7 +1803,7 @@ constexpr uint8_t epps = ENCODER_PULSES_PER_STEP;
); );
}); });
#else #else
set_status_P(eeprom_err(msgid)); set_status(FPSTR(eeprom_err(msgid)));
#endif #endif
} }

23
Marlin/src/lcd/marlinui.h

@ -342,21 +342,19 @@ public:
static bool has_status(); static bool has_status();
static void reset_status(const bool no_welcome=false); static void reset_status(const bool no_welcome=false);
static void set_status(const char * const message, const bool persist=false); static void set_alert_status(FSTR_P const fstr);
static void set_status_P(PGM_P const message, const int8_t level=0);
static void status_printf_P(const uint8_t level, PGM_P const fmt, ...);
static void set_alert_status_P(PGM_P const message);
static inline void reset_alert_level() { alert_level = 0; } static inline void reset_alert_level() { alert_level = 0; }
#else #else
static constexpr bool has_status() { return false; } static constexpr bool has_status() { return false; }
static inline void reset_status(const bool=false) {} static inline void reset_status(const bool=false) {}
static void set_status(const char *message, const bool=false); static inline void set_alert_status(FSTR_P const) {}
static void set_status_P(PGM_P message, const int8_t=0);
static void status_printf_P(const uint8_t, PGM_P message, ...);
static inline void set_alert_status_P(PGM_P const) {}
static inline void reset_alert_level() {} static inline void reset_alert_level() {}
#endif #endif
static void set_status(const char * const cstr, const bool persist=false);
static void set_status(FSTR_P const fstr, const int8_t level=0);
static void status_printf(const uint8_t level, FSTR_P const fmt, ...);
#if EITHER(HAS_DISPLAY, DWIN_CREALITY_LCD_ENHANCED) #if EITHER(HAS_DISPLAY, DWIN_CREALITY_LCD_ENHANCED)
static void kill_screen(PGM_P const lcd_error, PGM_P const lcd_component); static void kill_screen(PGM_P const lcd_error, PGM_P const lcd_component);
#else #else
@ -740,8 +738,7 @@ private:
extern MarlinUI ui; extern MarlinUI ui;
#define LCD_MESSAGEPGM_P(x) ui.set_status_P(x) #define LCD_MESSAGE_F(S) ui.set_status(F(S))
#define LCD_ALERTMESSAGEPGM_P(x) ui.set_alert_status_P(x) #define LCD_MESSAGE(M) ui.set_status(GET_TEXT_F(M))
#define LCD_ALERTMESSAGE_F(S) ui.set_alert_status(F(S))
#define LCD_MESSAGEPGM(x) LCD_MESSAGEPGM_P(GET_TEXT(x)) #define LCD_ALERTMESSAGE(M) ui.set_alert_status(GET_TEXT_F(M))
#define LCD_ALERTMESSAGEPGM(x) LCD_ALERTMESSAGEPGM_P(GET_TEXT(x))

2
Marlin/src/lcd/menu/menu_advanced.cpp

@ -630,7 +630,7 @@ void menu_advanced_settings() {
didset = settings.set_sd_update_status(new_state); didset = settings.set_sd_update_status(new_state);
ui.completion_feedback(didset); ui.completion_feedback(didset);
ui.return_to_status(); ui.return_to_status();
if (new_state) LCD_MESSAGEPGM(MSG_RESET_PRINTER); else ui.reset_status(); if (new_state) LCD_MESSAGE(MSG_RESET_PRINTER); else ui.reset_status();
}); });
#endif #endif

2
Marlin/src/lcd/menu/menu_mixer.cpp

@ -253,7 +253,7 @@ void menu_mixer() {
MSG_BUTTON_RESET, MSG_BUTTON_CANCEL, MSG_BUTTON_RESET, MSG_BUTTON_CANCEL,
[]{ []{
mixer.reset_vtools(); mixer.reset_vtools();
LCD_MESSAGEPGM(MSG_VTOOLS_RESET); LCD_MESSAGE(MSG_VTOOLS_RESET);
ui.return_to_status(); ui.return_to_status();
}, },
nullptr, nullptr,

8
Marlin/src/lcd/menu/menu_mmu2.cpp

@ -36,14 +36,14 @@
inline void action_mmu2_load_filament_to_nozzle(const uint8_t tool) { inline void action_mmu2_load_filament_to_nozzle(const uint8_t tool) {
ui.reset_status(); ui.reset_status();
ui.return_to_status(); ui.return_to_status();
ui.status_printf_P(0, GET_TEXT(MSG_MMU2_LOADING_FILAMENT), int(tool + 1)); ui.status_printf(0, GET_TEXT_F(MSG_MMU2_LOADING_FILAMENT), int(tool + 1));
if (mmu2.load_filament_to_nozzle(tool)) ui.reset_status(); if (mmu2.load_filament_to_nozzle(tool)) ui.reset_status();
ui.return_to_status(); ui.return_to_status();
} }
void _mmu2_load_filament(uint8_t index) { void _mmu2_load_filament(uint8_t index) {
ui.return_to_status(); ui.return_to_status();
ui.status_printf_P(0, GET_TEXT(MSG_MMU2_LOADING_FILAMENT), int(index + 1)); ui.status_printf(0, GET_TEXT_F(MSG_MMU2_LOADING_FILAMENT), int(index + 1));
mmu2.load_filament(index); mmu2.load_filament(index);
ui.reset_status(); ui.reset_status();
} }
@ -74,14 +74,14 @@ void menu_mmu2_load_to_nozzle() {
void _mmu2_eject_filament(uint8_t index) { void _mmu2_eject_filament(uint8_t index) {
ui.reset_status(); ui.reset_status();
ui.return_to_status(); ui.return_to_status();
ui.status_printf_P(0, GET_TEXT(MSG_MMU2_EJECTING_FILAMENT), int(index + 1)); ui.status_printf(0, GET_TEXT_F(MSG_MMU2_EJECTING_FILAMENT), int(index + 1));
if (mmu2.eject_filament(index, true)) ui.reset_status(); if (mmu2.eject_filament(index, true)) ui.reset_status();
} }
void action_mmu2_unload_filament() { void action_mmu2_unload_filament() {
ui.reset_status(); ui.reset_status();
ui.return_to_status(); ui.return_to_status();
LCD_MESSAGEPGM(MSG_MMU2_UNLOADING_FILAMENT); LCD_MESSAGE(MSG_MMU2_UNLOADING_FILAMENT);
idle(); idle();
if (mmu2.unload()) ui.reset_status(); if (mmu2.unload()) ui.reset_status();
} }

4
Marlin/src/module/endstops.cpp

@ -460,8 +460,8 @@ void Endstops::event_handler() {
SERIAL_EOL(); SERIAL_EOL();
TERN_(HAS_STATUS_MESSAGE, TERN_(HAS_STATUS_MESSAGE,
ui.status_printf_P(0, ui.status_printf(0,
PSTR(S_FMT GANG_N_1(LINEAR_AXES, " %c") " %c"), F(S_FMT GANG_N_1(LINEAR_AXES, " %c") " %c"),
GET_TEXT(MSG_LCD_ENDSTOPS), GET_TEXT(MSG_LCD_ENDSTOPS),
LINEAR_AXIS_LIST(chrX, chrY, chrZ, chrI, chrJ, chrK), chrP LINEAR_AXIS_LIST(chrX, chrY, chrZ, chrI, chrJ, chrK), chrP
) )

12
Marlin/src/module/probe.cpp

@ -137,7 +137,7 @@ xyz_pos_t Probe::offset; // Initialized by settings.load()
#if ENABLED(TOUCH_MI_MANUAL_DEPLOY) #if ENABLED(TOUCH_MI_MANUAL_DEPLOY)
const screenFunc_t prev_screen = ui.currentScreen; const screenFunc_t prev_screen = ui.currentScreen;
LCD_MESSAGEPGM(MSG_MANUAL_DEPLOY_TOUCHMI); LCD_MESSAGE(MSG_MANUAL_DEPLOY_TOUCHMI);
ui.return_to_status(); ui.return_to_status();
TERN_(HOST_PROMPT_SUPPORT, host_prompt_do(PROMPT_USER_CONTINUE, PSTR("Deploy TouchMI"), CONTINUE_STR)); TERN_(HOST_PROMPT_SUPPORT, host_prompt_do(PROMPT_USER_CONTINUE, PSTR("Deploy TouchMI"), CONTINUE_STR));
@ -290,10 +290,10 @@ FORCE_INLINE void probe_specific_action(const bool deploy) {
BUZZ(100, 659); BUZZ(100, 659);
BUZZ(100, 698); BUZZ(100, 698);
PGM_P const ds_str = deploy ? GET_TEXT(MSG_MANUAL_DEPLOY) : GET_TEXT(MSG_MANUAL_STOW); FSTR_P const ds_str = deploy ? GET_TEXT_F(MSG_MANUAL_DEPLOY) : GET_TEXT_F(MSG_MANUAL_STOW);
ui.return_to_status(); // To display the new status message ui.return_to_status(); // To display the new status message
ui.set_status_P(ds_str, 99); ui.set_status(ds_str, 99);
SERIAL_ECHOLNPGM_P(ds_str); SERIAL_ECHOLNF(ds_str);
TERN_(HOST_PROMPT_SUPPORT, host_prompt_do(PROMPT_USER_CONTINUE, PSTR("Stow Probe"), CONTINUE_STR)); TERN_(HOST_PROMPT_SUPPORT, host_prompt_do(PROMPT_USER_CONTINUE, PSTR("Stow Probe"), CONTINUE_STR));
TERN_(EXTENSIBLE_UI, ExtUI::onUserConfirmRequired_P(PSTR("Stow Probe"))); TERN_(EXTENSIBLE_UI, ExtUI::onUserConfirmRequired_P(PSTR("Stow Probe")));
@ -439,7 +439,7 @@ bool Probe::set_deployed(const bool deploy) {
if (PROBE_TRIGGERED() == deploy) { // Unchanged after deploy/stow action? if (PROBE_TRIGGERED() == deploy) { // Unchanged after deploy/stow action?
if (IsRunning()) { if (IsRunning()) {
SERIAL_ERROR_MSG("Z-Probe failed"); SERIAL_ERROR_MSG("Z-Probe failed");
LCD_ALERTMESSAGEPGM_P(PSTR("Err: ZPROBE")); LCD_ALERTMESSAGE_F("Err: ZPROBE");
} }
stop(); stop();
return true; return true;
@ -793,7 +793,7 @@ float Probe::probe_at_point(const_float_t rx, const_float_t ry, const ProbePtRai
if (isnan(measured_z)) { if (isnan(measured_z)) {
stow(); stow();
LCD_MESSAGEPGM(MSG_LCD_PROBING_FAILED); LCD_MESSAGE(MSG_LCD_PROBING_FAILED);
#if DISABLED(G29_RETRY_AND_RECOVER) #if DISABLED(G29_RETRY_AND_RECOVER)
SERIAL_ERROR_MSG(STR_ERR_PROBING_FAILED); SERIAL_ERROR_MSG(STR_ERR_PROBING_FAILED);
#endif #endif

6
Marlin/src/module/settings.cpp

@ -1471,7 +1471,7 @@ void MarlinSettings::postprocess() {
store_mesh(ubl.storage_slot); store_mesh(ubl.storage_slot);
#endif #endif
if (!eeprom_error) LCD_MESSAGEPGM(MSG_SETTINGS_STORED); if (!eeprom_error) LCD_MESSAGE(MSG_SETTINGS_STORED);
TERN_(EXTENSIBLE_UI, ExtUI::onConfigurationStoreWritten(!eeprom_error)); TERN_(EXTENSIBLE_UI, ExtUI::onConfigurationStoreWritten(!eeprom_error));
@ -1497,7 +1497,7 @@ void MarlinSettings::postprocess() {
stored_ver[1] = '\0'; stored_ver[1] = '\0';
} }
DEBUG_ECHO_MSG("EEPROM version mismatch (EEPROM=", stored_ver, " Marlin=" EEPROM_VERSION ")"); DEBUG_ECHO_MSG("EEPROM version mismatch (EEPROM=", stored_ver, " Marlin=" EEPROM_VERSION ")");
TERN_(DWIN_CREALITY_LCD_ENHANCED, ui.set_status(GET_TEXT(MSG_ERR_EEPROM_VERSION))); TERN_(DWIN_CREALITY_LCD_ENHANCED, LCD_MESSAGE(MSG_ERR_EEPROM_VERSION));
IF_DISABLED(EEPROM_AUTO_INIT, ui.eeprom_alert_version()); IF_DISABLED(EEPROM_AUTO_INIT, ui.eeprom_alert_version());
eeprom_error = true; eeprom_error = true;
@ -2362,7 +2362,7 @@ void MarlinSettings::postprocess() {
else if (working_crc != stored_crc) { else if (working_crc != stored_crc) {
eeprom_error = true; eeprom_error = true;
DEBUG_ERROR_MSG("EEPROM CRC mismatch - (stored) ", stored_crc, " != ", working_crc, " (calculated)!"); DEBUG_ERROR_MSG("EEPROM CRC mismatch - (stored) ", stored_crc, " != ", working_crc, " (calculated)!");
TERN_(DWIN_CREALITY_LCD_ENHANCED, ui.set_status(GET_TEXT(MSG_ERR_EEPROM_CRC))); TERN_(DWIN_CREALITY_LCD_ENHANCED, LCD_MESSAGE(MSG_ERR_EEPROM_CRC));
IF_DISABLED(EEPROM_AUTO_INIT, ui.eeprom_alert_crc()); IF_DISABLED(EEPROM_AUTO_INIT, ui.eeprom_alert_crc());
} }
else if (!validating) { else if (!validating) {

14
Marlin/src/module/temperature.cpp

@ -635,7 +635,7 @@ volatile bool Temperature::raw_temps_ready = false;
// PID Tuning loop // PID Tuning loop
wait_for_heatup = true; // Can be interrupted with M108 wait_for_heatup = true; // Can be interrupted with M108
TERN_(HAS_STATUS_MESSAGE, ui.status_printf_P(0, PSTR(S_FMT), "Wait for heat up...")); TERN_(HAS_STATUS_MESSAGE, ui.set_status(F("Wait for heat up...")));
while (wait_for_heatup) { while (wait_for_heatup) {
const millis_t ms = millis(); const millis_t ms = millis();
@ -696,7 +696,7 @@ volatile bool Temperature::raw_temps_ready = false;
} }
} }
SHV((bias + d) >> 1); SHV((bias + d) >> 1);
TERN_(HAS_STATUS_MESSAGE, ui.status_printf_P(0, PSTR(S_FMT " %i/%i"), GET_TEXT(MSG_PID_CYCLE), cycles, ncycles)); TERN_(HAS_STATUS_MESSAGE, ui.status_printf(0, F(S_FMT " %i/%i"), GET_TEXT(MSG_PID_CYCLE), cycles, ncycles));
cycles++; cycles++;
minT = target; minT = target;
} }
@ -3603,11 +3603,11 @@ void Temperature::isr() {
#if HAS_HOTEND && HAS_STATUS_MESSAGE #if HAS_HOTEND && HAS_STATUS_MESSAGE
void Temperature::set_heating_message(const uint8_t e) { void Temperature::set_heating_message(const uint8_t e) {
const bool heating = isHeatingHotend(e); const bool heating = isHeatingHotend(e);
ui.status_printf_P(0, ui.status_printf(0,
#if HAS_MULTI_HOTEND #if HAS_MULTI_HOTEND
PSTR("E%c " S_FMT), '1' + e F("E%c " S_FMT), '1' + e
#else #else
PSTR("E1 " S_FMT) F("E1 " S_FMT)
#endif #endif
, heating ? GET_TEXT(MSG_HEATING) : GET_TEXT(MSG_COOLING) , heating ? GET_TEXT(MSG_HEATING) : GET_TEXT(MSG_COOLING)
); );
@ -3744,7 +3744,7 @@ void Temperature::isr() {
void Temperature::wait_for_hotend_heating(const uint8_t target_extruder) { void Temperature::wait_for_hotend_heating(const uint8_t target_extruder) {
if (isHeatingHotend(target_extruder)) { if (isHeatingHotend(target_extruder)) {
SERIAL_ECHOLNPGM("Wait for hotend heating..."); SERIAL_ECHOLNPGM("Wait for hotend heating...");
LCD_MESSAGEPGM(MSG_HEATING); LCD_MESSAGE(MSG_HEATING);
wait_for_hotend(target_extruder); wait_for_hotend(target_extruder);
ui.reset_status(); ui.reset_status();
} }
@ -3874,7 +3874,7 @@ void Temperature::isr() {
void Temperature::wait_for_bed_heating() { void Temperature::wait_for_bed_heating() {
if (isHeatingBed()) { if (isHeatingBed()) {
SERIAL_ECHOLNPGM("Wait for bed heating..."); SERIAL_ECHOLNPGM("Wait for bed heating...");
LCD_MESSAGEPGM(MSG_BED_HEATING); LCD_MESSAGE(MSG_BED_HEATING);
wait_for_bed(); wait_for_bed();
ui.reset_status(); ui.reset_status();
} }

4
Marlin/src/module/tool_change.cpp

@ -490,12 +490,12 @@ void fast_line_to_current(const AxisEnum fr_axis) { _line_to_current(fr_axis, 0.
#endif #endif
if (check_tool_sensor_stats(0)) { if (check_tool_sensor_stats(0)) {
ui.set_status_P("TC error"); LCD_MESSAGE_F("TC error");
switching_toolhead_lock(false); switching_toolhead_lock(false);
while (check_tool_sensor_stats(0)) { /* nada */ } while (check_tool_sensor_stats(0)) { /* nada */ }
switching_toolhead_lock(true); switching_toolhead_lock(true);
} }
ui.set_status_P("TC Success"); LCD_MESSAGE_F("TC Success");
#endif #endif
} }

2
Marlin/src/sd/cardreader.cpp

@ -457,7 +457,7 @@ void CardReader::mount() {
cdroot(); cdroot();
#if ENABLED(USB_FLASH_DRIVE_SUPPORT) || PIN_EXISTS(SD_DETECT) #if ENABLED(USB_FLASH_DRIVE_SUPPORT) || PIN_EXISTS(SD_DETECT)
else if (marlin_state != MF_INITIALIZING) else if (marlin_state != MF_INITIALIZING)
ui.set_status_P(GET_TEXT(MSG_SD_INIT_FAIL), -1); ui.set_status(GET_TEXT_F(MSG_SD_INIT_FAIL), -1);
#endif #endif
ui.refresh(); ui.refresh();

10
Marlin/src/sd/usb_flashdrive/Sd2Card_FlashDrive.cpp

@ -126,7 +126,7 @@ bool DiskIODriver_USBFlash::usbStartup() {
SERIAL_ECHOPGM("Starting USB host..."); SERIAL_ECHOPGM("Starting USB host...");
if (!UHS_START) { if (!UHS_START) {
SERIAL_ECHOLNPGM(" failed."); SERIAL_ECHOLNPGM(" failed.");
LCD_MESSAGEPGM(MSG_MEDIA_USB_FAILED); LCD_MESSAGE(MSG_MEDIA_USB_FAILED);
return false; return false;
} }
@ -221,7 +221,7 @@ void DiskIODriver_USBFlash::idle() {
#if USB_DEBUG >= 1 #if USB_DEBUG >= 1
SERIAL_ECHOLNPGM("Waiting for media"); SERIAL_ECHOLNPGM("Waiting for media");
#endif #endif
LCD_MESSAGEPGM(MSG_MEDIA_WAITING); LCD_MESSAGE(MSG_MEDIA_WAITING);
GOTO_STATE_AFTER_DELAY(state, 2000); GOTO_STATE_AFTER_DELAY(state, 2000);
} }
break; break;
@ -236,7 +236,7 @@ void DiskIODriver_USBFlash::idle() {
SERIAL_ECHOLNPGM("USB device removed"); SERIAL_ECHOLNPGM("USB device removed");
#endif #endif
if (state != MEDIA_READY) if (state != MEDIA_READY)
LCD_MESSAGEPGM(MSG_MEDIA_USB_REMOVED); LCD_MESSAGE(MSG_MEDIA_USB_REMOVED);
GOTO_STATE_AFTER_DELAY(WAIT_FOR_DEVICE, 0); GOTO_STATE_AFTER_DELAY(WAIT_FOR_DEVICE, 0);
} }
@ -245,12 +245,12 @@ void DiskIODriver_USBFlash::idle() {
#if USB_DEBUG >= 1 #if USB_DEBUG >= 1
SERIAL_ECHOLNPGM("Media removed"); SERIAL_ECHOLNPGM("Media removed");
#endif #endif
LCD_MESSAGEPGM(MSG_MEDIA_REMOVED); LCD_MESSAGE(MSG_MEDIA_REMOVED);
GOTO_STATE_AFTER_DELAY(WAIT_FOR_DEVICE, 0); GOTO_STATE_AFTER_DELAY(WAIT_FOR_DEVICE, 0);
} }
else if (task_state == UHS_STATE(ERROR)) { else if (task_state == UHS_STATE(ERROR)) {
LCD_MESSAGEPGM(MSG_MEDIA_READ_ERROR); LCD_MESSAGE(MSG_MEDIA_READ_ERROR);
GOTO_STATE_AFTER_DELAY(MEDIA_ERROR, 0); GOTO_STATE_AFTER_DELAY(MEDIA_ERROR, 0);
} }
} }

Loading…
Cancel
Save