wp/Marlin-2-0-x-Anycubic-i3-MEGA-S
1
0
Fork 0
Code Issues 28 Pull Requests 2 Actions Packages Projects Releases 30 Wiki Activity

Merge upstream changes from Marlin 2.1.1

Browse Source
This commit is contained in:
Stefan Kalscheuer
2022-09-03 09:23:32 +02:00
parent 626283aadb
commit 986e416c7f
1610 changed files with 73839 additions and 40857 deletions
Download Patch File Download Diff File Expand all files Collapse all files

305
Marlin/src/lcd/marlinui.h
View File

@@ -21,31 +21,17 @@
*/
#pragma once
#include "../module/motion.h"
#include "buttons.h"
#include "../inc/MarlinConfig.h"
#include "../sd/cardreader.h"
#include "../module/motion.h"
#include "../libs/buzzer.h"
#if HAS_BUZZER
#include "../libs/buzzer.h"
#endif
#if ENABLED(SDSUPPORT)
#include "../sd/cardreader.h"
#endif
#include "buttons.h"
#if ENABLED(TOUCH_SCREEN_CALIBRATION)
#include "tft_io/touch_calibration.h"
#endif
#if ANY(HAS_LCD_MENU, ULTIPANEL_FEEDMULTIPLY, SOFT_RESET_ON_KILL)
#define HAS_ENCODER_ACTION 1
#endif
#if HAS_STATUS_MESSAGE
#define START_OF_UTF8_CHAR(C) (((C) & 0xC0u) != 0x80U)
#endif
#if E_MANUAL > 1
#define MULTI_E_MANUAL 1
#endif
@@ -54,19 +40,20 @@
#include "../module/printcounter.h"
#endif
#if ENABLED(ADVANCED_PAUSE_FEATURE) && ANY(HAS_LCD_MENU, EXTENSIBLE_UI, HAS_DWIN_E3V2)
#if ENABLED(ADVANCED_PAUSE_FEATURE)
#include "../feature/pause.h"
#include "../module/motion.h" // for active_extruder
#endif
#if ENABLED(DWIN_CREALITY_LCD)
#include "e3v2/creality/dwin.h"
#elif ENABLED(DWIN_CREALITY_LCD_ENHANCED)
#include "e3v2/enhanced/dwin.h"
#elif ENABLED(DWIN_LCD_PROUI)
#include "e3v2/proui/dwin.h"
#endif
#define START_OF_UTF8_CHAR(C) (((C) & 0xC0u) != 0x80U)
typedef bool (*statusResetFunc_t)();
#if HAS_WIRED_LCD
enum LCDViewAction : uint8_t {
@@ -81,7 +68,7 @@
uint8_t get_ADC_keyValue();
#endif
#if HAS_LCD_MENU
#if HAS_MARLINUI_MENU
#include "lcdprint.h"
@@ -94,7 +81,7 @@
typedef void (*screenFunc_t)();
typedef void (*menuAction_t)();
#endif // HAS_LCD_MENU
#endif // HAS_MARLINUI_MENU
#endif // HAS_WIRED_LCD
@@ -116,7 +103,7 @@
};
#endif
#if PREHEAT_COUNT
#if HAS_PREHEAT
typedef struct {
#if HAS_HOTEND
celsius_t hotend_temp;
@@ -130,7 +117,7 @@
} preheat_t;
#endif
#if HAS_LCD_MENU
#if HAS_MARLINUI_MENU
// Manual Movement class
class ManualMove {
@@ -146,12 +133,16 @@
static xyze_pos_t all_axes_destination;
#endif
public:
static screenFunc_t screen_ptr;
static float menu_scale;
#if IS_KINEMATIC
static float offset;
#endif
#if ENABLED(MANUAL_E_MOVES_RELATIVE)
static float e_origin;
#endif
template <typename T>
void set_destination(const T& dest) {
static void set_destination(const T& dest) {
#if IS_KINEMATIC
// Moves are segmented, so the entire move is not submitted at once.
// Using a separate variable prevents corrupting the in-progress move.
@@ -162,10 +153,10 @@
current_position.set(dest);
#endif
}
float axis_value(const AxisEnum axis) {
static float axis_value(const AxisEnum axis) {
return NATIVE_TO_LOGICAL(processing ? destination[axis] : SUM_TERN(IS_KINEMATIC, current_position[axis], offset), axis);
}
bool apply_diff(const AxisEnum axis, const_float_t diff, const_float_t min, const_float_t max) {
static bool apply_diff(const AxisEnum axis, const_float_t diff, const_float_t min, const_float_t max) {
#if IS_KINEMATIC
float &valref = offset;
const float rmin = min - current_position[axis], rmax = max - current_position[axis];
@@ -175,12 +166,7 @@
#endif
valref += diff;
const float pre = valref;
if (min != max) {
if (diff < 0)
NOLESS(valref, rmin);
else
NOMORE(valref, rmax);
}
if (min != max) { if (diff < 0) NOLESS(valref, rmin); else NOMORE(valref, rmax); }
return pre != valref;
}
#if IS_KINEMATIC
@@ -192,19 +178,40 @@
static void soon(const AxisEnum axis OPTARG(MULTI_E_MANUAL, const int8_t eindex=active_extruder));
};
void lcd_move_axis(const AxisEnum);
#endif
////////////////////////////////////////////
//////////// MarlinUI Singleton ////////////
////////////////////////////////////////////
class MarlinUI;
extern MarlinUI ui;
class MarlinUI {
public:
MarlinUI() {
TERN_(HAS_LCD_MENU, currentScreen = status_screen);
TERN_(HAS_MARLINUI_MENU, currentScreen = status_screen);
}
static void init();
#if HAS_DISPLAY || HAS_DWIN_E3V2
static void init_lcd();
#else
static void init_lcd() {}
#endif
static void reinit_lcd() { TERN_(REINIT_NOISY_LCD, init_lcd()); }
#if HAS_WIRED_LCD
static bool detected();
#else
static bool detected() { return true; }
#endif
#if HAS_MULTI_LANGUAGE
static uint8_t language;
static void set_language(const uint8_t lang);
@@ -215,17 +222,17 @@ public:
#endif
#if ENABLED(SOUND_MENU_ITEM)
static bool buzzer_enabled; // Initialized by settings.load()
static bool sound_on; // Initialized by settings.load()
#else
static constexpr bool buzzer_enabled = true;
static constexpr bool sound_on = true;
#endif
#if HAS_BUZZER
#if USE_MARLINUI_BUZZER
static void buzz(const long duration, const uint16_t freq);
#endif
FORCE_INLINE static void chirp() {
TERN_(HAS_CHIRP, buzz(LCD_FEEDBACK_FREQUENCY_DURATION_MS, LCD_FEEDBACK_FREQUENCY_HZ));
static void chirp() {
TERN_(HAS_CHIRP, TERN(USE_MARLINUI_BUZZER, buzz, BUZZ)(LCD_FEEDBACK_FREQUENCY_DURATION_MS, LCD_FEEDBACK_FREQUENCY_HZ));
}
#if ENABLED(LCD_HAS_STATUS_INDICATORS)
@@ -235,7 +242,7 @@ public:
// LCD implementations
static void clear_lcd();
#if BOTH(HAS_LCD_MENU, TOUCH_SCREEN_CALIBRATION)
#if BOTH(HAS_MARLINUI_MENU, TOUCH_SCREEN_CALIBRATION)
static void check_touch_calibration() {
if (touch_calibration.need_calibration()) currentScreen = touch_calibration_screen;
}
@@ -253,8 +260,8 @@ public:
#ifndef LCD_BRIGHTNESS_MAX
#define LCD_BRIGHTNESS_MAX 255
#endif
#ifndef DEFAULT_LCD_BRIGHTNESS
#define DEFAULT_LCD_BRIGHTNESS LCD_BRIGHTNESS_MAX
#ifndef LCD_BRIGHTNESS_DEFAULT
#define LCD_BRIGHTNESS_DEFAULT LCD_BRIGHTNESS_MAX
#endif
static uint8_t brightness;
static bool backlight;
@@ -263,6 +270,22 @@ public:
FORCE_INLINE static void refresh_brightness() { set_brightness(brightness); }
#endif
#if LCD_BACKLIGHT_TIMEOUT
#define LCD_BKL_TIMEOUT_MIN 1u
#define LCD_BKL_TIMEOUT_MAX UINT16_MAX // Slightly more than 18 hours
static uint16_t lcd_backlight_timeout;
static millis_t backlight_off_ms;
static void refresh_backlight_timeout();
#elif HAS_DISPLAY_SLEEP
#define SLEEP_TIMEOUT_MIN 0
#define SLEEP_TIMEOUT_MAX 99
static uint8_t sleep_timeout_minutes;
static millis_t screen_timeout_millis;
static void refresh_screen_timeout();
static void sleep_on();
static void sleep_off();
#endif
#if HAS_DWIN_E3V2_BASIC
static void refresh();
#else
@@ -271,14 +294,6 @@ public:
}
#endif
#if HAS_WIRED_LCD
static bool detected();
static void init_lcd();
#else
static inline bool detected() { return true; }
static inline void init_lcd() {}
#endif
#if HAS_PRINT_PROGRESS
#if HAS_PRINT_PROGRESS_PERMYRIAD
typedef uint16_t progress_t;
@@ -294,20 +309,20 @@ public:
static void set_progress(const progress_t p) { progress_override = _MIN(p, 100U * (PROGRESS_SCALE)); }
static void set_progress_done() { progress_override = (PROGRESS_MASK + 1U) + 100U * (PROGRESS_SCALE); }
static void progress_reset() { if (progress_override & (PROGRESS_MASK + 1U)) set_progress(0); }
#if ENABLED(SHOW_REMAINING_TIME)
static inline uint32_t _calculated_remaining_time() {
const duration_t elapsed = print_job_timer.duration();
const progress_t progress = _get_progress();
return progress ? elapsed.value * (100 * (PROGRESS_SCALE) - progress) / progress : 0;
}
#if ENABLED(USE_M73_REMAINING_TIME)
static uint32_t remaining_time;
FORCE_INLINE static void set_remaining_time(const uint32_t r) { remaining_time = r; }
FORCE_INLINE static uint32_t get_remaining_time() { return remaining_time ?: _calculated_remaining_time(); }
FORCE_INLINE static void reset_remaining_time() { set_remaining_time(0); }
#else
FORCE_INLINE static uint32_t get_remaining_time() { return _calculated_remaining_time(); }
#endif
#endif
#if ENABLED(SHOW_REMAINING_TIME)
static uint32_t _calculated_remaining_time() {
const duration_t elapsed = print_job_timer.duration();
const progress_t progress = _get_progress();
return progress ? elapsed.value * (100 * (PROGRESS_SCALE) - progress) / progress : 0;
}
#if ENABLED(USE_M73_REMAINING_TIME)
static uint32_t remaining_time;
FORCE_INLINE static void set_remaining_time(const uint32_t r) { remaining_time = r; }
FORCE_INLINE static uint32_t get_remaining_time() { return remaining_time ?: _calculated_remaining_time(); }
FORCE_INLINE static void reset_remaining_time() { set_remaining_time(0); }
#else
FORCE_INLINE static uint32_t get_remaining_time() { return _calculated_remaining_time(); }
#endif
#endif
static progress_t _get_progress();
@@ -321,7 +336,7 @@ public:
#if HAS_STATUS_MESSAGE
#if EITHER(HAS_WIRED_LCD, DWIN_CREALITY_LCD_ENHANCED)
#if EITHER(HAS_WIRED_LCD, DWIN_LCD_PROUI)
#if ENABLED(STATUS_MESSAGE_SCROLLING)
#define MAX_MESSAGE_LENGTH _MAX(LONG_FILENAME_LENGTH, MAX_LANG_CHARSIZE * 2 * (LCD_WIDTH))
#else
@@ -334,6 +349,10 @@ public:
static char status_message[];
static uint8_t alert_level; // Higher levels block lower levels
#if HAS_STATUS_MESSAGE_TIMEOUT
static millis_t status_message_expire_ms; // Reset some status messages after a timeout
#endif
#if ENABLED(STATUS_MESSAGE_SCROLLING)
static uint8_t status_scroll_offset;
static void advance_status_scroll();
@@ -342,30 +361,25 @@ public:
static bool has_status();
static void reset_status(const bool no_welcome=false);
static void set_status(const char * const message, const bool persist=false);
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 void set_alert_status(FSTR_P const fstr);
static void reset_alert_level() { alert_level = 0; }
static statusResetFunc_t status_reset_callback;
static void set_status_reset_fn(const statusResetFunc_t fn=nullptr) { status_reset_callback = fn; }
#else
static constexpr bool has_status() { return false; }
static inline void reset_status(const bool=false) {}
static void set_status(const char *message, const bool=false);
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 void reset_status(const bool=false) {}
static void set_alert_status(FSTR_P const) {}
static void reset_alert_level() {}
static void set_status_reset_fn(const statusResetFunc_t=nullptr) {}
#endif
#if EITHER(HAS_DISPLAY, DWIN_CREALITY_LCD_ENHANCED)
static void kill_screen(PGM_P const lcd_error, PGM_P const lcd_component);
#else
static inline void kill_screen(PGM_P const, PGM_P const) {}
#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(int8_t level, FSTR_P const fmt, ...);
#if HAS_DISPLAY
static void init();
static void update();
static void abort_print();
@@ -373,7 +387,7 @@ public:
static void resume_print();
static void flow_fault();
#if BOTH(PSU_CONTROL, PS_OFF_CONFIRM)
#if BOTH(HAS_MARLINUI_MENU, PSU_CONTROL)
static void poweroff();
#endif
@@ -441,14 +455,10 @@ public:
#endif
static void quick_feedback(const bool clear_buttons=true);
#if HAS_BUZZER
#if HAS_SOUND
static void completion_feedback(const bool good=true);
#else
static inline void completion_feedback(const bool=true) { TERN_(HAS_TOUCH_SLEEP, wakeup_screen()); }
#endif
#if DISABLED(LIGHTWEIGHT_UI)
static void draw_status_message(const bool blink);
static void completion_feedback(const bool=true) { TERN_(HAS_TOUCH_SLEEP, wakeup_screen()); }
#endif
#if ENABLED(ADVANCED_PAUSE_FEATURE)
@@ -472,20 +482,29 @@ public:
#if IS_DWIN_MARLINUI
static bool did_first_redraw;
static bool old_is_printing;
#endif
#if EITHER(BABYSTEP_ZPROBE_GFX_OVERLAY, MESH_EDIT_GFX_OVERLAY)
static void zoffset_overlay(const int8_t dir);
static void zoffset_overlay(const_float_t zvalue);
#endif
static void draw_kill_screen();
static void kill_screen(FSTR_P const lcd_error, FSTR_P const lcd_component);
#if DISABLED(LIGHTWEIGHT_UI)
static void draw_status_message(const bool blink);
#endif
#else // No LCD
static inline void init() {}
static inline void update() {}
static inline void return_to_status() {}
static void update() {}
static void kill_screen(FSTR_P const, FSTR_P const) {}
#endif
#if ENABLED(SDSUPPORT)
#if BOTH(SCROLL_LONG_FILENAMES, HAS_LCD_MENU)
#if BOTH(SCROLL_LONG_FILENAMES, HAS_MARLINUI_MENU)
#define MARLINUI_SCROLL_NAME 1
#endif
#if MARLINUI_SCROLL_NAME
@@ -494,18 +513,23 @@ public:
static const char * scrolled_filename(CardReader &theCard, const uint8_t maxlen, uint8_t hash, const bool doScroll);
#endif
#if PREHEAT_COUNT
#if HAS_PREHEAT
enum PreheatTarget : uint8_t { PT_HOTEND, PT_BED, PT_FAN, PT_CHAMBER, PT_ALL = 0xFF };
static preheat_t material_preset[PREHEAT_COUNT];
static PGM_P get_preheat_label(const uint8_t m);
static FSTR_P get_preheat_label(const uint8_t m);
static void apply_preheat(const uint8_t m, const uint8_t pmask, const uint8_t e=active_extruder);
static void preheat_set_fan(const uint8_t m) { TERN_(HAS_FAN, apply_preheat(m, _BV(PT_FAN))); }
static void preheat_hotend(const uint8_t m, const uint8_t e=active_extruder) { TERN_(HAS_HOTEND, apply_preheat(m, _BV(PT_HOTEND))); }
static void preheat_hotend_and_fan(const uint8_t m, const uint8_t e=active_extruder) { preheat_hotend(m, e); preheat_set_fan(m); }
static void preheat_bed(const uint8_t m) { TERN_(HAS_HEATED_BED, apply_preheat(m, _BV(PT_BED))); }
static void preheat_all(const uint8_t m) { apply_preheat(m, PT_ALL); }
#endif
#if SCREENS_CAN_TIME_OUT
static inline void reset_status_timeout(const millis_t ms) { return_to_status_ms = ms + LCD_TIMEOUT_TO_STATUS; }
#else
static inline void reset_status_timeout(const millis_t) {}
#endif
static void reset_status_timeout(const millis_t ms) {
TERN(SCREENS_CAN_TIME_OUT, return_to_status_ms = ms + LCD_TIMEOUT_TO_STATUS, UNUSED(ms));
}
#if HAS_LCD_MENU
#if HAS_MARLINUI_MENU
#if HAS_TOUCH_BUTTONS
static uint8_t touch_buttons;
@@ -525,13 +549,14 @@ public:
// Manual Movement
static ManualMove manual_move;
static bool can_show_slider() { return !external_control && currentScreen != manual_move.screen_ptr; }
// Select Screen (modal NO/YES style dialog)
static bool selection;
static void set_selection(const bool sel) { selection = sel; }
static bool update_selection();
static void synchronize(PGM_P const msg=nullptr);
static void synchronize(FSTR_P const msg=nullptr);
static screenFunc_t currentScreen;
static bool screen_changed;
@@ -540,11 +565,11 @@ public:
// goto_previous_screen and go_back may also be used as menu item callbacks
static void _goto_previous_screen(TERN_(TURBO_BACK_MENU_ITEM, const bool is_back));
static inline void goto_previous_screen() { _goto_previous_screen(TERN_(TURBO_BACK_MENU_ITEM, false)); }
static inline void go_back() { _goto_previous_screen(TERN_(TURBO_BACK_MENU_ITEM, true)); }
static void goto_previous_screen() { _goto_previous_screen(TERN_(TURBO_BACK_MENU_ITEM, false)); }
static void go_back() { _goto_previous_screen(TERN_(TURBO_BACK_MENU_ITEM, true)); }
static void return_to_status();
static inline bool on_status_screen() { return currentScreen == status_screen; }
static bool on_status_screen() { return currentScreen == status_screen; }
FORCE_INLINE static void run_current_screen() { (*currentScreen)(); }
#if ENABLED(LIGHTWEIGHT_UI)
@@ -559,7 +584,7 @@ public:
TERN(SCREENS_CAN_TIME_OUT, defer_return_to_status = defer, UNUSED(defer));
}
static inline void goto_previous_screen_no_defer() {
static void goto_previous_screen_no_defer() {
defer_status_screen(false);
goto_previous_screen();
}
@@ -577,10 +602,12 @@ public:
static float ubl_mesh_value();
#endif
static void draw_select_screen_prompt(PGM_P const pref, const char * const string=nullptr, PGM_P const suff=nullptr);
static void draw_select_screen_prompt(FSTR_P const pref, const char * const string=nullptr, FSTR_P const suff=nullptr);
#else
static void return_to_status() {}
static constexpr bool on_status_screen() { return true; }
#if HAS_WIRED_LCD
@@ -589,50 +616,50 @@ public:
#endif
#if EITHER(HAS_LCD_MENU, EXTENSIBLE_UI)
#if EITHER(HAS_MARLINUI_MENU, EXTENSIBLE_UI)
static bool lcd_clicked;
static inline bool use_click() {
static bool use_click() {
const bool click = lcd_clicked;
lcd_clicked = false;
return click;
}
#else
static constexpr bool lcd_clicked = false;
static inline bool use_click() { return false; }
static bool use_click() { return false; }
#endif
#if ENABLED(ADVANCED_PAUSE_FEATURE) && ANY(HAS_LCD_MENU, EXTENSIBLE_UI, DWIN_CREALITY_LCD_ENHANCED, DWIN_CREALITY_LCD_JYERSUI)
#if ENABLED(ADVANCED_PAUSE_FEATURE) && ANY(HAS_MARLINUI_MENU, EXTENSIBLE_UI, DWIN_LCD_PROUI, DWIN_CREALITY_LCD_JYERSUI)
static void pause_show_message(const PauseMessage message, const PauseMode mode=PAUSE_MODE_SAME, const uint8_t extruder=active_extruder);
#else
static inline void _pause_show_message() {}
static void _pause_show_message() {}
#define pause_show_message(...) _pause_show_message()
#endif
//
// EEPROM: Reset / Init / Load / Store
//
#if HAS_LCD_MENU
#if HAS_MARLINUI_MENU
static void reset_settings();
#endif
#if ENABLED(EEPROM_SETTINGS)
#if HAS_LCD_MENU
#if HAS_MARLINUI_MENU
static void init_eeprom();
static void load_settings();
static void store_settings();
#endif
#if DISABLED(EEPROM_AUTO_INIT)
static void eeprom_alert(const uint8_t msgid);
static inline void eeprom_alert_crc() { eeprom_alert(0); }
static inline void eeprom_alert_index() { eeprom_alert(1); }
static inline void eeprom_alert_version() { eeprom_alert(2); }
static void eeprom_alert_crc() { eeprom_alert(0); }
static void eeprom_alert_index() { eeprom_alert(1); }
static void eeprom_alert_version() { eeprom_alert(2); }
#endif
#endif
//
// Special handling if a move is underway
//
#if ANY(DELTA_CALIBRATION_MENU, DELTA_AUTO_CALIBRATION, PROBE_OFFSET_WIZARD) || (ENABLED(LCD_BED_LEVELING) && EITHER(PROBE_MANUALLY, MESH_BED_LEVELING))
#if ANY(DELTA_CALIBRATION_MENU, DELTA_AUTO_CALIBRATION, PROBE_OFFSET_WIZARD, X_AXIS_TWIST_COMPENSATION) || (ENABLED(LCD_BED_LEVELING) && EITHER(PROBE_MANUALLY, MESH_BED_LEVELING))
#define LCD_HAS_WAIT_FOR_MOVE 1
static bool wait_for_move;
#else
@@ -642,7 +669,7 @@ public:
//
// Block interaction while under external control
//
#if HAS_LCD_MENU && EITHER(AUTO_BED_LEVELING_UBL, G26_MESH_VALIDATION)
#if HAS_MARLINUI_MENU && EITHER(AUTO_BED_LEVELING_UBL, G26_MESH_VALIDATION)
static bool external_control;
FORCE_INLINE static void capture() { external_control = true; }
FORCE_INLINE static void release() { external_control = false; }
@@ -666,7 +693,25 @@ public:
#endif
static void update_buttons();
static inline bool button_pressed() { return BUTTON_CLICK() || TERN(TOUCH_SCREEN, touch_pressed(), false); }
#if ENABLED(ENCODER_NOISE_FILTER)
/**
* Some printers may have issues with EMI noise especially using a motherboard with 3.3V logic levels
* it may cause the logical LOW to float into the undefined region and register as a logical HIGH
* causing it to erroneously register as if someone clicked the button and in worst case make the
* printer unusable in practice.
*/
static bool hw_button_pressed() {
LOOP_L_N(s, ENCODER_SAMPLES) {
if (!BUTTON_CLICK()) return false;
safe_delay(1);
}
return true;
}
#else
static bool hw_button_pressed() { return BUTTON_CLICK(); }
#endif
#if EITHER(AUTO_BED_LEVELING_UBL, G26_MESH_VALIDATION)
static void wait_for_release();
#endif
@@ -697,10 +742,13 @@ public:
#else
static inline void update_buttons() {}
static void update_buttons() {}
static bool hw_button_pressed() { return false; }
#endif
static bool button_pressed() { return hw_button_pressed() || TERN0(TOUCH_SCREEN, touch_pressed()); }
#if ENABLED(TOUCH_SCREEN_CALIBRATION)
static void touch_calibration_screen();
#endif
@@ -733,10 +781,7 @@ private:
#endif
};
extern MarlinUI ui;
#define LCD_MESSAGEPGM_P(x) ui.set_status_P(x)
#define LCD_ALERTMESSAGEPGM_P(x) ui.set_alert_status_P(x)
#define LCD_MESSAGEPGM(x) LCD_MESSAGEPGM_P(GET_TEXT(x))
#define LCD_ALERTMESSAGEPGM(x) LCD_ALERTMESSAGEPGM_P(GET_TEXT(x))
#define LCD_MESSAGE_F(S) ui.set_status(F(S))
#define LCD_MESSAGE(M) ui.set_status(GET_TEXT_F(M))
#define LCD_ALERTMESSAGE_F(S) ui.set_alert_status(F(S))
#define LCD_ALERTMESSAGE(M) ui.set_alert_status(GET_TEXT_F(M))