2016-03-25 07:19:46 +01:00
|
|
|
/**
|
2016-03-24 19:01:20 +01:00
|
|
|
* Marlin 3D Printer Firmware
|
2020-02-03 15:00:57 +01:00
|
|
|
* Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
|
2016-03-24 19:01:20 +01:00
|
|
|
*
|
|
|
|
* Based on Sprinter and grbl.
|
2019-06-28 06:57:50 +02:00
|
|
|
* Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
|
2016-03-24 19:01:20 +01:00
|
|
|
*
|
|
|
|
* This program is free software: you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
2020-07-23 05:20:14 +02:00
|
|
|
* along with this program. If not, see <https://www.gnu.org/licenses/>.
|
2016-03-24 19:01:20 +01:00
|
|
|
*
|
|
|
|
*/
|
2018-10-23 23:00:34 +02:00
|
|
|
#pragma once
|
2012-11-06 12:06:41 +01:00
|
|
|
|
2022-01-22 17:14:47 +01:00
|
|
|
#include "../sd/cardreader.h"
|
2021-01-03 02:01:09 +01:00
|
|
|
#include "../module/motion.h"
|
2021-01-13 03:43:52 +01:00
|
|
|
#include "buttons.h"
|
|
|
|
|
2021-09-16 02:48:29 +02:00
|
|
|
#include "../inc/MarlinConfig.h"
|
|
|
|
|
2018-11-17 04:44:48 +01:00
|
|
|
#if HAS_BUZZER
|
|
|
|
#include "../libs/buzzer.h"
|
|
|
|
#endif
|
|
|
|
|
2020-11-15 23:39:58 +01:00
|
|
|
#if ENABLED(TOUCH_SCREEN_CALIBRATION)
|
|
|
|
#include "tft_io/touch_calibration.h"
|
|
|
|
#endif
|
|
|
|
|
2022-01-25 22:33:03 +01:00
|
|
|
#if ANY(HAS_MARLINUI_MENU, ULTIPANEL_FEEDMULTIPLY, SOFT_RESET_ON_KILL)
|
2020-03-08 05:20:41 +01:00
|
|
|
#define HAS_ENCODER_ACTION 1
|
|
|
|
#endif
|
2019-03-12 00:10:56 +01:00
|
|
|
|
2021-03-29 08:41:56 +02:00
|
|
|
#if HAS_STATUS_MESSAGE
|
|
|
|
#define START_OF_UTF8_CHAR(C) (((C) & 0xC0u) != 0x80U)
|
|
|
|
#endif
|
|
|
|
|
2020-04-26 00:53:06 +02:00
|
|
|
#if E_MANUAL > 1
|
2021-05-21 00:12:18 +02:00
|
|
|
#define MULTI_E_MANUAL 1
|
2020-04-26 00:53:06 +02:00
|
|
|
#endif
|
|
|
|
|
2020-12-23 23:37:17 +01:00
|
|
|
#if HAS_DISPLAY
|
|
|
|
#include "../module/printcounter.h"
|
|
|
|
#endif
|
|
|
|
|
2022-01-25 22:33:03 +01:00
|
|
|
#if ENABLED(ADVANCED_PAUSE_FEATURE)
|
2021-01-21 10:40:07 +01:00
|
|
|
#include "../feature/pause.h"
|
|
|
|
#endif
|
2018-11-11 19:16:24 +01:00
|
|
|
|
2021-09-07 09:15:24 +02:00
|
|
|
#if ENABLED(DWIN_CREALITY_LCD)
|
|
|
|
#include "e3v2/creality/dwin.h"
|
|
|
|
#elif ENABLED(DWIN_CREALITY_LCD_ENHANCED)
|
2022-02-05 17:30:17 +01:00
|
|
|
#include "e3v2/proui/dwin.h"
|
2021-09-07 09:15:24 +02:00
|
|
|
#endif
|
|
|
|
|
2021-03-24 18:21:11 +01:00
|
|
|
#define START_OF_UTF8_CHAR(C) (((C) & 0xC0u) != 0x80U)
|
|
|
|
|
2021-01-21 10:40:07 +01:00
|
|
|
#if HAS_WIRED_LCD
|
2018-11-11 19:16:24 +01:00
|
|
|
|
2018-10-01 12:19:35 +02:00
|
|
|
enum LCDViewAction : uint8_t {
|
|
|
|
LCDVIEW_NONE,
|
|
|
|
LCDVIEW_REDRAW_NOW,
|
|
|
|
LCDVIEW_CALL_REDRAW_NEXT,
|
|
|
|
LCDVIEW_CLEAR_CALL_REDRAW,
|
|
|
|
LCDVIEW_CALL_NO_REDRAW
|
|
|
|
};
|
|
|
|
|
2018-11-19 03:39:49 +01:00
|
|
|
#if HAS_ADC_BUTTONS
|
2017-06-10 07:12:18 +02:00
|
|
|
uint8_t get_ADC_keyValue();
|
|
|
|
#endif
|
|
|
|
|
2022-01-25 22:33:03 +01:00
|
|
|
#if HAS_MARLINUI_MENU
|
2016-10-27 09:12:54 +02:00
|
|
|
|
2019-08-18 02:58:38 +02:00
|
|
|
#include "lcdprint.h"
|
2019-04-24 17:13:44 +02:00
|
|
|
|
2020-11-11 02:39:34 +01:00
|
|
|
#if !HAS_GRAPHICAL_TFT
|
|
|
|
void _wrap_string(uint8_t &col, uint8_t &row, const char * const string, read_byte_cb_t cb_read_byte, const bool wordwrap=false);
|
|
|
|
inline void wrap_string_P(uint8_t &col, uint8_t &row, PGM_P const pstr, const bool wordwrap=false) { _wrap_string(col, row, pstr, read_byte_rom, wordwrap); }
|
|
|
|
inline void wrap_string(uint8_t &col, uint8_t &row, const char * const string, const bool wordwrap=false) { _wrap_string(col, row, string, read_byte_ram, wordwrap); }
|
2018-11-17 04:44:48 +01:00
|
|
|
#endif
|
|
|
|
|
2017-09-06 13:28:32 +02:00
|
|
|
typedef void (*screenFunc_t)();
|
2017-10-03 06:33:57 +02:00
|
|
|
typedef void (*menuAction_t)();
|
2018-05-01 04:16:31 +02:00
|
|
|
|
2022-01-25 22:33:03 +01:00
|
|
|
#endif // HAS_MARLINUI_MENU
|
2015-03-20 10:50:28 +01:00
|
|
|
|
2020-09-28 08:13:27 +02:00
|
|
|
#endif // HAS_WIRED_LCD
|
2012-12-03 12:52:00 +01:00
|
|
|
|
2021-09-07 06:06:27 +02:00
|
|
|
#if EITHER(HAS_WIRED_LCD, DWIN_CREALITY_LCD_JYERSUI)
|
|
|
|
#define LCD_UPDATE_INTERVAL TERN(HAS_TOUCH_BUTTONS, 50, 100)
|
|
|
|
#endif
|
|
|
|
|
2020-09-28 08:13:27 +02:00
|
|
|
#if HAS_MARLINUI_U8GLIB
|
2018-11-13 08:47:45 +01:00
|
|
|
enum MarlinFont : uint8_t {
|
|
|
|
FONT_STATUSMENU = 1,
|
|
|
|
FONT_EDIT,
|
|
|
|
FONT_MENU
|
|
|
|
};
|
2018-11-19 02:58:02 +01:00
|
|
|
#else
|
|
|
|
enum HD44780CharSet : uint8_t {
|
|
|
|
CHARSET_MENU,
|
|
|
|
CHARSET_INFO,
|
|
|
|
CHARSET_BOOT
|
|
|
|
};
|
2018-11-13 08:47:45 +01:00
|
|
|
#endif
|
|
|
|
|
2021-10-28 04:15:58 +02:00
|
|
|
#if HAS_PREHEAT
|
2020-06-25 02:44:50 +02:00
|
|
|
typedef struct {
|
2021-07-10 00:09:58 +02:00
|
|
|
#if HAS_HOTEND
|
2021-03-24 11:40:28 +01:00
|
|
|
celsius_t hotend_temp;
|
|
|
|
#endif
|
2021-07-10 00:09:58 +02:00
|
|
|
#if HAS_HEATED_BED
|
2021-03-24 11:40:28 +01:00
|
|
|
celsius_t bed_temp;
|
|
|
|
#endif
|
2021-07-10 00:09:58 +02:00
|
|
|
#if HAS_FAN
|
2021-03-24 11:40:28 +01:00
|
|
|
uint16_t fan_speed;
|
|
|
|
#endif
|
2020-06-25 02:44:50 +02:00
|
|
|
} preheat_t;
|
|
|
|
#endif
|
|
|
|
|
2022-01-25 22:33:03 +01:00
|
|
|
#if HAS_MARLINUI_MENU
|
2020-07-03 16:53:22 +02:00
|
|
|
|
|
|
|
// Manual Movement class
|
|
|
|
class ManualMove {
|
2021-01-02 03:08:10 +01:00
|
|
|
private:
|
|
|
|
static AxisEnum axis;
|
2021-05-21 00:12:18 +02:00
|
|
|
#if MULTI_E_MANUAL
|
2021-01-02 03:08:10 +01:00
|
|
|
static int8_t e_index;
|
|
|
|
#else
|
|
|
|
static int8_t constexpr e_index = 0;
|
|
|
|
#endif
|
2020-07-03 16:53:22 +02:00
|
|
|
static millis_t start_time;
|
2021-07-10 00:09:58 +02:00
|
|
|
#if IS_KINEMATIC
|
2021-03-24 11:40:28 +01:00
|
|
|
static xyze_pos_t all_axes_destination;
|
|
|
|
#endif
|
2021-01-02 03:08:10 +01:00
|
|
|
public:
|
2020-07-03 16:53:22 +02:00
|
|
|
static float menu_scale;
|
2021-07-10 00:09:58 +02:00
|
|
|
#if IS_KINEMATIC
|
2021-03-24 11:40:28 +01:00
|
|
|
static float offset;
|
|
|
|
#endif
|
2021-01-03 02:01:09 +01:00
|
|
|
template <typename T>
|
|
|
|
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.
|
|
|
|
all_axes_destination = current_position;
|
|
|
|
all_axes_destination.set(dest);
|
|
|
|
#else
|
|
|
|
// Moves are submitted as single line to the planner using buffer_line.
|
|
|
|
current_position.set(dest);
|
|
|
|
#endif
|
|
|
|
}
|
2021-04-28 11:08:21 +02:00
|
|
|
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) {
|
|
|
|
#if IS_KINEMATIC
|
|
|
|
float &valref = offset;
|
|
|
|
const float rmin = min - current_position[axis], rmax = max - current_position[axis];
|
|
|
|
#else
|
|
|
|
float &valref = current_position[axis];
|
|
|
|
const float rmin = min, rmax = max;
|
|
|
|
#endif
|
|
|
|
valref += diff;
|
|
|
|
const float pre = valref;
|
|
|
|
if (min != max) {
|
|
|
|
if (diff < 0)
|
|
|
|
NOLESS(valref, rmin);
|
|
|
|
else
|
|
|
|
NOMORE(valref, rmax);
|
|
|
|
}
|
|
|
|
return pre != valref;
|
|
|
|
}
|
2020-07-03 16:53:22 +02:00
|
|
|
#if IS_KINEMATIC
|
|
|
|
static bool processing;
|
|
|
|
#else
|
|
|
|
static bool constexpr processing = false;
|
|
|
|
#endif
|
|
|
|
static void task();
|
2021-05-24 04:33:22 +02:00
|
|
|
static void soon(const AxisEnum axis OPTARG(MULTI_E_MANUAL, const int8_t eindex=active_extruder));
|
2020-07-03 16:53:22 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
2018-11-11 19:16:24 +01:00
|
|
|
////////////////////////////////////////////
|
|
|
|
//////////// MarlinUI Singleton ////////////
|
|
|
|
////////////////////////////////////////////
|
2017-05-30 03:12:10 +02:00
|
|
|
|
2018-11-11 19:16:24 +01:00
|
|
|
class MarlinUI {
|
|
|
|
public:
|
2017-07-03 17:06:23 +02:00
|
|
|
|
2018-11-11 19:16:24 +01:00
|
|
|
MarlinUI() {
|
2022-01-25 22:33:03 +01:00
|
|
|
TERN_(HAS_MARLINUI_MENU, currentScreen = status_screen);
|
2018-11-11 19:16:24 +01:00
|
|
|
}
|
2017-10-27 06:39:51 +02:00
|
|
|
|
2022-01-22 17:14:47 +01:00
|
|
|
static void init();
|
|
|
|
|
|
|
|
#if HAS_DISPLAY || HAS_DWIN_E3V2
|
|
|
|
static void init_lcd();
|
|
|
|
#else
|
|
|
|
static void init_lcd() {}
|
|
|
|
#endif
|
|
|
|
|
2022-02-13 20:44:24 +01:00
|
|
|
static void reinit_lcd() { TERN_(REINIT_NOISY_LCD, init_lcd()); }
|
|
|
|
|
2022-01-22 17:14:47 +01:00
|
|
|
#if HAS_WIRED_LCD
|
|
|
|
static bool detected();
|
|
|
|
#else
|
|
|
|
static bool detected() { return true; }
|
|
|
|
#endif
|
|
|
|
|
2021-01-21 01:52:06 +01:00
|
|
|
#if HAS_MULTI_LANGUAGE
|
|
|
|
static uint8_t language;
|
2021-07-19 02:56:28 +02:00
|
|
|
static void set_language(const uint8_t lang);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if HAS_MARLINUI_U8GLIB
|
|
|
|
static void update_language_font();
|
2021-01-21 01:52:06 +01:00
|
|
|
#endif
|
|
|
|
|
2020-10-28 02:41:12 +01:00
|
|
|
#if ENABLED(SOUND_MENU_ITEM)
|
|
|
|
static bool buzzer_enabled; // Initialized by settings.load()
|
|
|
|
#else
|
|
|
|
static constexpr bool buzzer_enabled = true;
|
|
|
|
#endif
|
|
|
|
|
2019-07-29 02:14:50 +02:00
|
|
|
#if HAS_BUZZER
|
2019-08-20 09:01:37 +02:00
|
|
|
static void buzz(const long duration, const uint16_t freq);
|
|
|
|
#endif
|
|
|
|
|
2020-05-27 20:38:37 +02:00
|
|
|
FORCE_INLINE static void chirp() {
|
|
|
|
TERN_(HAS_CHIRP, buzz(LCD_FEEDBACK_FREQUENCY_DURATION_MS, LCD_FEEDBACK_FREQUENCY_HZ));
|
|
|
|
}
|
|
|
|
|
2019-08-20 09:01:37 +02:00
|
|
|
#if ENABLED(LCD_HAS_STATUS_INDICATORS)
|
|
|
|
static void update_indicators();
|
2019-07-29 02:14:50 +02:00
|
|
|
#endif
|
2018-11-11 19:16:24 +01:00
|
|
|
|
|
|
|
// LCD implementations
|
|
|
|
static void clear_lcd();
|
2020-04-02 08:22:48 +02:00
|
|
|
|
2022-01-25 22:33:03 +01:00
|
|
|
#if BOTH(HAS_MARLINUI_MENU, TOUCH_SCREEN_CALIBRATION)
|
2020-11-15 23:39:58 +01:00
|
|
|
static void check_touch_calibration() {
|
|
|
|
if (touch_calibration.need_calibration()) currentScreen = touch_calibration_screen;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2020-04-04 07:08:25 +02:00
|
|
|
#if ENABLED(SDSUPPORT)
|
2020-11-18 05:30:32 +01:00
|
|
|
#define MEDIA_MENU_GATEWAY TERN(PASSWORD_ON_SD_PRINT_MENU, password.media_gatekeeper, menu_media)
|
2020-04-04 07:08:25 +02:00
|
|
|
static void media_changed(const uint8_t old_stat, const uint8_t stat);
|
|
|
|
#endif
|
|
|
|
|
2021-08-01 21:28:53 +02:00
|
|
|
#if HAS_LCD_BRIGHTNESS
|
2021-09-25 12:59:43 +02:00
|
|
|
#ifndef LCD_BRIGHTNESS_MIN
|
|
|
|
#define LCD_BRIGHTNESS_MIN 1
|
2021-08-01 21:28:53 +02:00
|
|
|
#endif
|
2021-09-25 12:59:43 +02:00
|
|
|
#ifndef LCD_BRIGHTNESS_MAX
|
|
|
|
#define LCD_BRIGHTNESS_MAX 255
|
2021-08-01 21:28:53 +02:00
|
|
|
#endif
|
2022-02-05 17:30:17 +01:00
|
|
|
#ifndef LCD_BRIGHTNESS_DEFAULT
|
|
|
|
#define LCD_BRIGHTNESS_DEFAULT LCD_BRIGHTNESS_MAX
|
2021-08-01 21:28:53 +02:00
|
|
|
#endif
|
|
|
|
static uint8_t brightness;
|
|
|
|
static bool backlight;
|
2021-09-25 12:59:43 +02:00
|
|
|
static void _set_brightness(); // Implementation-specific
|
2021-08-01 21:28:53 +02:00
|
|
|
static void set_brightness(const uint8_t value);
|
|
|
|
FORCE_INLINE static void refresh_brightness() { set_brightness(brightness); }
|
|
|
|
#endif
|
|
|
|
|
2021-09-07 09:15:24 +02:00
|
|
|
#if HAS_DWIN_E3V2_BASIC
|
2020-09-07 04:40:58 +02:00
|
|
|
static void refresh();
|
|
|
|
#else
|
|
|
|
FORCE_INLINE static void refresh() {
|
2020-09-28 08:13:27 +02:00
|
|
|
TERN_(HAS_WIRED_LCD, refresh(LCDVIEW_CLEAR_CALL_REDRAW));
|
2020-09-07 04:40:58 +02:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2020-09-16 12:52:01 +02:00
|
|
|
#if HAS_PRINT_PROGRESS
|
|
|
|
#if HAS_PRINT_PROGRESS_PERMYRIAD
|
|
|
|
typedef uint16_t progress_t;
|
|
|
|
#define PROGRESS_SCALE 100U
|
|
|
|
#define PROGRESS_MASK 0x7FFF
|
|
|
|
#else
|
|
|
|
typedef uint8_t progress_t;
|
|
|
|
#define PROGRESS_SCALE 1U
|
|
|
|
#define PROGRESS_MASK 0x7F
|
|
|
|
#endif
|
|
|
|
#if ENABLED(LCD_SET_PROGRESS_MANUALLY)
|
|
|
|
static progress_t progress_override;
|
|
|
|
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); }
|
2022-01-12 17:13:21 +01:00
|
|
|
#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(); }
|
2020-09-16 12:52:01 +02:00
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
static progress_t _get_progress();
|
|
|
|
#if HAS_PRINT_PROGRESS_PERMYRIAD
|
|
|
|
FORCE_INLINE static uint16_t get_progress_permyriad() { return _get_progress(); }
|
|
|
|
#endif
|
|
|
|
static uint8_t get_progress_percent() { return uint8_t(_get_progress() / (PROGRESS_SCALE)); }
|
|
|
|
#else
|
|
|
|
static constexpr uint8_t get_progress_percent() { return 0; }
|
|
|
|
#endif
|
|
|
|
|
2020-11-23 01:44:17 +01:00
|
|
|
#if HAS_STATUS_MESSAGE
|
2021-07-31 12:32:13 +02:00
|
|
|
|
2021-09-07 09:15:24 +02:00
|
|
|
#if EITHER(HAS_WIRED_LCD, DWIN_CREALITY_LCD_ENHANCED)
|
2021-07-31 12:32:13 +02:00
|
|
|
#if ENABLED(STATUS_MESSAGE_SCROLLING)
|
|
|
|
#define MAX_MESSAGE_LENGTH _MAX(LONG_FILENAME_LENGTH, MAX_LANG_CHARSIZE * 2 * (LCD_WIDTH))
|
|
|
|
#else
|
|
|
|
#define MAX_MESSAGE_LENGTH (MAX_LANG_CHARSIZE * (LCD_WIDTH))
|
|
|
|
#endif
|
|
|
|
#else
|
|
|
|
#define MAX_MESSAGE_LENGTH 63
|
|
|
|
#endif
|
|
|
|
|
2018-11-18 05:21:44 +01:00
|
|
|
static char status_message[];
|
2019-07-01 07:44:39 +02:00
|
|
|
static uint8_t alert_level; // Higher levels block lower levels
|
2018-11-18 05:21:44 +01:00
|
|
|
|
2019-03-17 11:32:12 +01:00
|
|
|
#if ENABLED(STATUS_MESSAGE_SCROLLING)
|
|
|
|
static uint8_t status_scroll_offset;
|
|
|
|
static void advance_status_scroll();
|
|
|
|
static char* status_and_len(uint8_t &len);
|
|
|
|
#endif
|
|
|
|
|
2020-11-23 01:44:17 +01:00
|
|
|
static bool has_status();
|
|
|
|
static void reset_status(const bool no_welcome=false);
|
2021-09-26 00:05:11 +02:00
|
|
|
static void set_alert_status(FSTR_P const fstr);
|
2021-12-28 09:57:24 +01:00
|
|
|
static void reset_alert_level() { alert_level = 0; }
|
2020-11-23 01:44:17 +01:00
|
|
|
#else
|
|
|
|
static constexpr bool has_status() { return false; }
|
2021-12-28 09:57:24 +01:00
|
|
|
static void reset_status(const bool=false) {}
|
|
|
|
static void set_alert_status(FSTR_P const) {}
|
|
|
|
static void reset_alert_level() {}
|
2020-11-23 01:44:17 +01:00
|
|
|
#endif
|
|
|
|
|
2021-09-26 00:05:11 +02:00
|
|
|
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, ...);
|
|
|
|
|
2021-09-07 09:15:24 +02:00
|
|
|
#if EITHER(HAS_DISPLAY, DWIN_CREALITY_LCD_ENHANCED)
|
2021-09-29 03:15:52 +02:00
|
|
|
static void kill_screen(FSTR_P const lcd_error, FSTR_P const lcd_component);
|
2021-11-10 17:31:35 +01:00
|
|
|
#if DISABLED(LIGHTWEIGHT_UI)
|
|
|
|
static void draw_status_message(const bool blink);
|
|
|
|
#endif
|
2021-09-07 09:15:24 +02:00
|
|
|
#else
|
2021-12-28 09:57:24 +01:00
|
|
|
static void kill_screen(FSTR_P const, FSTR_P const) {}
|
2021-09-07 09:15:24 +02:00
|
|
|
#endif
|
|
|
|
|
2020-11-23 01:44:17 +01:00
|
|
|
#if HAS_DISPLAY
|
|
|
|
|
|
|
|
static void update();
|
|
|
|
|
2019-05-30 23:24:13 +02:00
|
|
|
static void abort_print();
|
|
|
|
static void pause_print();
|
|
|
|
static void resume_print();
|
2021-03-29 08:41:56 +02:00
|
|
|
static void flow_fault();
|
2019-06-18 03:08:51 +02:00
|
|
|
|
2022-01-25 22:33:03 +01:00
|
|
|
#if BOTH(HAS_MARLINUI_MENU, PSU_CONTROL)
|
2021-06-23 18:40:32 +02:00
|
|
|
static void poweroff();
|
|
|
|
#endif
|
|
|
|
|
2021-09-07 06:06:27 +02:00
|
|
|
#if EITHER(HAS_WIRED_LCD, DWIN_CREALITY_LCD_JYERSUI)
|
|
|
|
static bool get_blink();
|
|
|
|
#endif
|
|
|
|
|
2020-09-28 08:13:27 +02:00
|
|
|
#if HAS_WIRED_LCD
|
2018-11-11 19:16:24 +01:00
|
|
|
|
2019-09-04 20:13:05 +02:00
|
|
|
static millis_t next_button_update_ms;
|
|
|
|
|
2018-11-11 19:16:24 +01:00
|
|
|
static LCDViewAction lcdDrawUpdate;
|
2019-11-13 02:36:54 +01:00
|
|
|
FORCE_INLINE static bool should_draw() { return bool(lcdDrawUpdate); }
|
|
|
|
FORCE_INLINE static void refresh(const LCDViewAction type) { lcdDrawUpdate = type; }
|
2018-11-11 19:16:24 +01:00
|
|
|
|
2019-07-29 05:47:20 +02:00
|
|
|
#if ENABLED(SHOW_CUSTOM_BOOTSCREEN)
|
|
|
|
static void draw_custom_bootscreen(const uint8_t frame=0);
|
|
|
|
static void show_custom_bootscreen();
|
|
|
|
#endif
|
|
|
|
|
2018-11-11 19:16:24 +01:00
|
|
|
#if ENABLED(SHOW_BOOTSCREEN)
|
2020-03-09 21:03:57 +01:00
|
|
|
#ifndef BOOTSCREEN_TIMEOUT
|
|
|
|
#define BOOTSCREEN_TIMEOUT 2500
|
|
|
|
#endif
|
2019-08-28 14:40:18 +02:00
|
|
|
static void draw_marlin_bootscreen(const bool line2=false);
|
2019-07-29 05:47:20 +02:00
|
|
|
static void show_marlin_bootscreen();
|
2018-11-11 19:16:24 +01:00
|
|
|
static void show_bootscreen();
|
2021-04-24 08:29:30 +02:00
|
|
|
static void bootscreen_completion(const millis_t sofar);
|
2018-11-11 19:16:24 +01:00
|
|
|
#endif
|
|
|
|
|
2020-09-28 08:13:27 +02:00
|
|
|
#if HAS_MARLINUI_U8GLIB
|
2018-11-11 19:16:24 +01:00
|
|
|
static void set_font(const MarlinFont font_nr);
|
2021-08-22 12:25:07 +02:00
|
|
|
#elif IS_DWIN_MARLINUI
|
|
|
|
static void set_font(const uint8_t font_nr);
|
|
|
|
#endif
|
2018-11-11 19:16:24 +01:00
|
|
|
|
2021-08-22 12:25:07 +02:00
|
|
|
#if HAS_MARLINUI_HD44780
|
2018-11-19 02:58:02 +01:00
|
|
|
static void set_custom_characters(const HD44780CharSet screen_charset=CHARSET_INFO);
|
2021-08-22 12:25:07 +02:00
|
|
|
#endif
|
2018-11-11 19:16:24 +01:00
|
|
|
|
2021-08-22 12:25:07 +02:00
|
|
|
#if ENABLED(LCD_PROGRESS_BAR) && !HAS_MARLINUI_U8GLIB
|
|
|
|
static millis_t progress_bar_ms; // Start time for the current progress bar cycle
|
|
|
|
static void draw_progress_bar(const uint8_t percent);
|
|
|
|
#if PROGRESS_MSG_EXPIRE > 0
|
|
|
|
static millis_t expire_status_ms; // = 0
|
|
|
|
FORCE_INLINE static void reset_progress_bar_timeout() { expire_status_ms = 0; }
|
2018-11-11 19:16:24 +01:00
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
|
|
|
|
static uint8_t lcd_status_update_delay;
|
|
|
|
|
|
|
|
#if HAS_LCD_CONTRAST
|
2021-09-25 12:59:43 +02:00
|
|
|
static uint8_t contrast;
|
|
|
|
static void _set_contrast(); // Implementation-specific
|
|
|
|
static void set_contrast(const uint8_t value);
|
2019-11-13 02:36:54 +01:00
|
|
|
FORCE_INLINE static void refresh_contrast() { set_contrast(contrast); }
|
2018-11-11 19:16:24 +01:00
|
|
|
#endif
|
|
|
|
|
2019-03-17 05:43:06 +01:00
|
|
|
#if BOTH(FILAMENT_LCD_DISPLAY, SDSUPPORT)
|
2018-11-11 19:16:24 +01:00
|
|
|
static millis_t next_filament_display;
|
|
|
|
#endif
|
|
|
|
|
2021-09-14 04:07:08 +02:00
|
|
|
#if HAS_TOUCH_SLEEP
|
|
|
|
static void wakeup_screen();
|
|
|
|
#endif
|
|
|
|
|
2018-11-11 19:16:24 +01:00
|
|
|
static void quick_feedback(const bool clear_buttons=true);
|
2019-07-29 02:14:50 +02:00
|
|
|
#if HAS_BUZZER
|
|
|
|
static void completion_feedback(const bool good=true);
|
2020-04-23 22:14:32 +02:00
|
|
|
#else
|
2021-12-28 09:57:24 +01:00
|
|
|
static void completion_feedback(const bool=true) { TERN_(HAS_TOUCH_SLEEP, wakeup_screen()); }
|
2019-07-29 02:14:50 +02:00
|
|
|
#endif
|
2018-11-11 19:16:24 +01:00
|
|
|
|
|
|
|
#if ENABLED(ADVANCED_PAUSE_FEATURE)
|
|
|
|
static void draw_hotend_status(const uint8_t row, const uint8_t extruder);
|
|
|
|
#endif
|
|
|
|
|
2020-11-15 23:39:58 +01:00
|
|
|
#if HAS_TOUCH_BUTTONS
|
2020-06-12 04:21:18 +02:00
|
|
|
static bool on_edit_screen;
|
2020-06-11 23:13:52 +02:00
|
|
|
static void screen_click(const uint8_t row, const uint8_t col, const uint8_t x, const uint8_t y);
|
|
|
|
#endif
|
|
|
|
|
2018-11-11 19:16:24 +01:00
|
|
|
static void status_screen();
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
2020-09-28 08:13:27 +02:00
|
|
|
#if HAS_MARLINUI_U8GLIB
|
2020-09-07 04:40:58 +02:00
|
|
|
static bool drawing_screen, first_page;
|
|
|
|
#else
|
|
|
|
static constexpr bool drawing_screen = false, first_page = true;
|
|
|
|
#endif
|
|
|
|
|
2021-08-22 12:25:07 +02:00
|
|
|
#if IS_DWIN_MARLINUI
|
|
|
|
static bool did_first_redraw;
|
2022-01-17 14:07:45 +01:00
|
|
|
static bool old_is_printing;
|
2021-08-22 12:25:07 +02:00
|
|
|
#endif
|
|
|
|
|
2021-10-02 09:33:14 +02:00
|
|
|
#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
|
|
|
|
|
2018-11-11 19:16:24 +01:00
|
|
|
static void draw_kill_screen();
|
|
|
|
|
2019-05-08 03:32:50 +02:00
|
|
|
#else // No LCD
|
2018-11-11 19:16:24 +01:00
|
|
|
|
2021-12-28 09:57:24 +01:00
|
|
|
static void update() {}
|
|
|
|
static void return_to_status() {}
|
2018-11-11 19:16:24 +01:00
|
|
|
|
|
|
|
#endif
|
|
|
|
|
2020-06-16 08:45:27 +02:00
|
|
|
#if ENABLED(SDSUPPORT)
|
2022-01-25 22:33:03 +01:00
|
|
|
#if BOTH(SCROLL_LONG_FILENAMES, HAS_MARLINUI_MENU)
|
2020-06-16 08:45:27 +02:00
|
|
|
#define MARLINUI_SCROLL_NAME 1
|
|
|
|
#endif
|
|
|
|
#if MARLINUI_SCROLL_NAME
|
|
|
|
static uint8_t filename_scroll_pos, filename_scroll_max;
|
|
|
|
#endif
|
|
|
|
static const char * scrolled_filename(CardReader &theCard, const uint8_t maxlen, uint8_t hash, const bool doScroll);
|
|
|
|
#endif
|
|
|
|
|
2021-10-28 04:15:58 +02:00
|
|
|
#if HAS_PREHEAT
|
2022-01-07 12:44:44 +01:00
|
|
|
enum PreheatTarget : uint8_t { PT_HOTEND, PT_BED, PT_FAN, PT_CHAMBER, PT_ALL = 0xFF };
|
2020-06-25 02:44:50 +02:00
|
|
|
static preheat_t material_preset[PREHEAT_COUNT];
|
2020-07-09 10:11:57 +02:00
|
|
|
static PGM_P get_preheat_label(const uint8_t m);
|
2021-10-28 03:01:44 +02:00
|
|
|
static void apply_preheat(const uint8_t m, const uint8_t pmask, const uint8_t e=active_extruder);
|
2022-01-07 12:44:44 +01:00
|
|
|
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))); }
|
2021-12-28 09:57:24 +01:00
|
|
|
static void preheat_hotend_and_fan(const uint8_t m, const uint8_t e=active_extruder) { preheat_hotend(m, e); preheat_set_fan(m); }
|
2022-01-07 12:44:44 +01:00
|
|
|
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); }
|
2020-06-25 02:44:50 +02:00
|
|
|
#endif
|
|
|
|
|
2022-01-07 12:44:44 +01:00
|
|
|
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));
|
|
|
|
}
|
2021-06-27 07:33:44 +02:00
|
|
|
|
2022-01-25 22:33:03 +01:00
|
|
|
#if HAS_MARLINUI_MENU
|
2018-11-11 19:16:24 +01:00
|
|
|
|
2020-11-15 23:39:58 +01:00
|
|
|
#if HAS_TOUCH_BUTTONS
|
2019-12-06 07:47:50 +01:00
|
|
|
static uint8_t touch_buttons;
|
2019-09-13 05:14:24 +02:00
|
|
|
static uint8_t repeat_delay;
|
2021-01-13 03:43:52 +01:00
|
|
|
#else
|
|
|
|
static constexpr uint8_t touch_buttons = 0;
|
2019-09-13 05:14:24 +02:00
|
|
|
#endif
|
|
|
|
|
2018-11-11 19:16:24 +01:00
|
|
|
#if ENABLED(ENCODER_RATE_MULTIPLIER)
|
|
|
|
static bool encoderRateMultiplierEnabled;
|
|
|
|
static millis_t lastEncoderMovementMillis;
|
|
|
|
static void enable_encoder_multiplier(const bool onoff);
|
2020-08-21 12:21:34 +02:00
|
|
|
#define ENCODER_RATE_MULTIPLY(F) (ui.encoderRateMultiplierEnabled = F)
|
|
|
|
#else
|
|
|
|
#define ENCODER_RATE_MULTIPLY(F) NOOP
|
2018-11-11 19:16:24 +01:00
|
|
|
#endif
|
|
|
|
|
2020-07-03 16:53:22 +02:00
|
|
|
// Manual Movement
|
|
|
|
static ManualMove manual_move;
|
2018-10-24 09:27:19 +02:00
|
|
|
|
2019-07-18 02:41:15 +02:00
|
|
|
// Select Screen (modal NO/YES style dialog)
|
|
|
|
static bool selection;
|
|
|
|
static void set_selection(const bool sel) { selection = sel; }
|
|
|
|
static bool update_selection();
|
|
|
|
|
2019-05-09 18:45:55 +02:00
|
|
|
static void synchronize(PGM_P const msg=nullptr);
|
2018-11-11 19:16:24 +01:00
|
|
|
|
|
|
|
static screenFunc_t currentScreen;
|
2019-11-15 03:30:30 +01:00
|
|
|
static bool screen_changed;
|
2019-04-09 04:10:41 +02:00
|
|
|
static void goto_screen(const screenFunc_t screen, const uint16_t encoder=0, const uint8_t top=0, const uint8_t items=0);
|
2021-06-27 07:33:44 +02:00
|
|
|
static void push_current_screen();
|
2019-08-21 02:37:03 +02:00
|
|
|
|
2019-11-10 02:27:30 +01:00
|
|
|
// goto_previous_screen and go_back may also be used as menu item callbacks
|
2020-04-26 00:53:06 +02:00
|
|
|
static void _goto_previous_screen(TERN_(TURBO_BACK_MENU_ITEM, const bool is_back));
|
2021-12-28 09:57:24 +01:00
|
|
|
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)); }
|
2019-08-24 05:29:00 +02:00
|
|
|
|
2018-11-11 19:16:24 +01:00
|
|
|
static void return_to_status();
|
2021-12-28 09:57:24 +01:00
|
|
|
static bool on_status_screen() { return currentScreen == status_screen; }
|
2019-11-13 02:36:54 +01:00
|
|
|
FORCE_INLINE static void run_current_screen() { (*currentScreen)(); }
|
2018-11-11 19:16:24 +01:00
|
|
|
|
2018-11-13 08:47:45 +01:00
|
|
|
#if ENABLED(LIGHTWEIGHT_UI)
|
|
|
|
static void lcd_in_status(const bool inStatus);
|
|
|
|
#endif
|
|
|
|
|
2021-06-27 07:33:44 +02:00
|
|
|
FORCE_INLINE static bool screen_is_sticky() {
|
|
|
|
return TERN1(SCREENS_CAN_TIME_OUT, defer_return_to_status);
|
|
|
|
}
|
|
|
|
|
2019-11-13 02:36:54 +01:00
|
|
|
FORCE_INLINE static void defer_status_screen(const bool defer=true) {
|
2021-06-27 07:33:44 +02:00
|
|
|
TERN(SCREENS_CAN_TIME_OUT, defer_return_to_status = defer, UNUSED(defer));
|
2018-11-11 19:16:24 +01:00
|
|
|
}
|
|
|
|
|
2021-12-28 09:57:24 +01:00
|
|
|
static void goto_previous_screen_no_defer() {
|
2018-11-11 19:16:24 +01:00
|
|
|
defer_status_screen(false);
|
|
|
|
goto_previous_screen();
|
|
|
|
}
|
|
|
|
|
|
|
|
#if ENABLED(SD_REPRINT_LAST_SELECTED_FILE)
|
|
|
|
static void reselect_last_file();
|
2018-10-30 22:34:45 +01:00
|
|
|
#endif
|
2018-11-11 19:16:24 +01:00
|
|
|
|
|
|
|
#if ENABLED(AUTO_BED_LEVELING_UBL)
|
2019-08-18 02:58:38 +02:00
|
|
|
static void ubl_plot(const uint8_t x_plot, const uint8_t y_plot);
|
2018-11-11 19:16:24 +01:00
|
|
|
#endif
|
|
|
|
|
2021-03-24 09:28:48 +01:00
|
|
|
#if ENABLED(AUTO_BED_LEVELING_UBL)
|
2021-04-02 00:59:57 +02:00
|
|
|
static void ubl_mesh_edit_start(const_float_t initial);
|
2021-03-24 09:28:48 +01:00
|
|
|
static float ubl_mesh_value();
|
|
|
|
#endif
|
|
|
|
|
2019-05-09 18:45:55 +02:00
|
|
|
static void draw_select_screen_prompt(PGM_P const pref, const char * const string=nullptr, PGM_P const suff=nullptr);
|
2019-04-24 17:13:44 +02:00
|
|
|
|
2021-06-29 19:58:11 +02:00
|
|
|
#else
|
2018-11-11 19:16:24 +01:00
|
|
|
|
|
|
|
static constexpr bool on_status_screen() { return true; }
|
2021-06-29 19:58:11 +02:00
|
|
|
|
|
|
|
#if HAS_WIRED_LCD
|
|
|
|
FORCE_INLINE static void run_current_screen() { status_screen(); }
|
|
|
|
#endif
|
2018-11-11 19:16:24 +01:00
|
|
|
|
|
|
|
#endif
|
|
|
|
|
2022-01-25 22:33:03 +01:00
|
|
|
#if EITHER(HAS_MARLINUI_MENU, EXTENSIBLE_UI)
|
2021-06-14 05:08:46 +02:00
|
|
|
static bool lcd_clicked;
|
2021-12-28 09:57:24 +01:00
|
|
|
static bool use_click() {
|
2021-06-14 05:08:46 +02:00
|
|
|
const bool click = lcd_clicked;
|
|
|
|
lcd_clicked = false;
|
|
|
|
return click;
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
static constexpr bool lcd_clicked = false;
|
2021-12-28 09:57:24 +01:00
|
|
|
static bool use_click() { return false; }
|
2021-06-14 05:08:46 +02:00
|
|
|
#endif
|
|
|
|
|
2022-01-25 22:33:03 +01:00
|
|
|
#if ENABLED(ADVANCED_PAUSE_FEATURE) && ANY(HAS_MARLINUI_MENU, EXTENSIBLE_UI, DWIN_CREALITY_LCD_ENHANCED, DWIN_CREALITY_LCD_JYERSUI)
|
2021-01-21 10:40:07 +01:00
|
|
|
static void pause_show_message(const PauseMessage message, const PauseMode mode=PAUSE_MODE_SAME, const uint8_t extruder=active_extruder);
|
|
|
|
#else
|
2021-12-28 09:57:24 +01:00
|
|
|
static void _pause_show_message() {}
|
2021-01-21 10:40:07 +01:00
|
|
|
#define pause_show_message(...) _pause_show_message()
|
|
|
|
#endif
|
|
|
|
|
2020-05-10 07:12:56 +02:00
|
|
|
//
|
|
|
|
// EEPROM: Reset / Init / Load / Store
|
|
|
|
//
|
2022-01-25 22:33:03 +01:00
|
|
|
#if HAS_MARLINUI_MENU
|
2020-05-10 07:12:56 +02:00
|
|
|
static void reset_settings();
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if ENABLED(EEPROM_SETTINGS)
|
2022-01-25 22:33:03 +01:00
|
|
|
#if HAS_MARLINUI_MENU
|
2020-05-10 07:12:56 +02:00
|
|
|
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);
|
2021-12-28 09:57:24 +01:00
|
|
|
static void eeprom_alert_crc() { eeprom_alert(0); }
|
|
|
|
static void eeprom_alert_index() { eeprom_alert(1); }
|
|
|
|
static void eeprom_alert_version() { eeprom_alert(2); }
|
2020-05-10 07:12:56 +02:00
|
|
|
#endif
|
|
|
|
#endif
|
2020-01-26 07:02:06 +01:00
|
|
|
|
2020-05-10 07:12:56 +02:00
|
|
|
//
|
|
|
|
// Special handling if a move is underway
|
|
|
|
//
|
2021-12-07 02:53:51 +01:00
|
|
|
#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))
|
2020-05-10 07:12:56 +02:00
|
|
|
#define LCD_HAS_WAIT_FOR_MOVE 1
|
2020-01-26 07:02:06 +01:00
|
|
|
static bool wait_for_move;
|
2018-10-30 22:34:45 +01:00
|
|
|
#else
|
2020-01-26 07:02:06 +01:00
|
|
|
static constexpr bool wait_for_move = false;
|
2018-10-30 22:34:45 +01:00
|
|
|
#endif
|
2018-10-24 09:27:19 +02:00
|
|
|
|
2020-05-10 07:12:56 +02:00
|
|
|
//
|
|
|
|
// Block interaction while under external control
|
|
|
|
//
|
2022-01-25 22:33:03 +01:00
|
|
|
#if HAS_MARLINUI_MENU && EITHER(AUTO_BED_LEVELING_UBL, G26_MESH_VALIDATION)
|
2018-11-11 19:16:24 +01:00
|
|
|
static bool external_control;
|
|
|
|
FORCE_INLINE static void capture() { external_control = true; }
|
|
|
|
FORCE_INLINE static void release() { external_control = false; }
|
2020-07-03 16:53:22 +02:00
|
|
|
#if ENABLED(AUTO_BED_LEVELING_UBL)
|
|
|
|
static void external_encoder();
|
|
|
|
#endif
|
2018-11-11 19:16:24 +01:00
|
|
|
#else
|
|
|
|
static constexpr bool external_control = false;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if HAS_ENCODER_ACTION
|
|
|
|
|
|
|
|
static volatile uint8_t buttons;
|
2020-10-15 10:00:27 +02:00
|
|
|
#if IS_RRW_KEYPAD
|
2018-11-19 03:39:49 +01:00
|
|
|
static volatile uint8_t keypad_buttons;
|
2018-11-14 13:00:21 +01:00
|
|
|
static bool handle_keypad();
|
|
|
|
#endif
|
2018-11-21 04:39:30 +01:00
|
|
|
#if HAS_SLOW_BUTTONS
|
2018-11-11 19:16:24 +01:00
|
|
|
static volatile uint8_t slow_buttons;
|
|
|
|
static uint8_t read_slow_buttons();
|
|
|
|
#endif
|
2019-07-15 01:16:26 +02:00
|
|
|
|
2018-11-11 19:16:24 +01:00
|
|
|
static void update_buttons();
|
2021-12-28 09:57:24 +01:00
|
|
|
static bool button_pressed() { return BUTTON_CLICK() || TERN(TOUCH_SCREEN, touch_pressed(), false); }
|
2019-03-17 05:43:06 +01:00
|
|
|
#if EITHER(AUTO_BED_LEVELING_UBL, G26_MESH_VALIDATION)
|
2018-11-11 19:16:24 +01:00
|
|
|
static void wait_for_release();
|
|
|
|
#endif
|
|
|
|
|
2019-10-22 01:34:29 +02:00
|
|
|
static uint32_t encoderPosition;
|
2018-11-11 19:16:24 +01:00
|
|
|
|
2020-04-26 00:53:06 +02:00
|
|
|
#define ENCODERBASE (TERN(REVERSE_ENCODER_DIRECTION, -1, +1))
|
2019-07-31 00:42:57 +02:00
|
|
|
|
|
|
|
#if EITHER(REVERSE_MENU_DIRECTION, REVERSE_SELECT_DIRECTION)
|
2018-11-11 19:16:24 +01:00
|
|
|
static int8_t encoderDirection;
|
|
|
|
#else
|
|
|
|
static constexpr int8_t encoderDirection = ENCODERBASE;
|
2019-07-31 00:42:57 +02:00
|
|
|
#endif
|
|
|
|
|
2019-11-13 02:36:54 +01:00
|
|
|
FORCE_INLINE static void encoder_direction_normal() {
|
|
|
|
#if EITHER(REVERSE_MENU_DIRECTION, REVERSE_SELECT_DIRECTION)
|
|
|
|
encoderDirection = ENCODERBASE;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
FORCE_INLINE static void encoder_direction_menus() {
|
2020-04-22 23:35:03 +02:00
|
|
|
TERN_(REVERSE_MENU_DIRECTION, encoderDirection = -(ENCODERBASE));
|
2019-11-13 02:36:54 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
FORCE_INLINE static void encoder_direction_select() {
|
2020-04-22 23:35:03 +02:00
|
|
|
TERN_(REVERSE_SELECT_DIRECTION, encoderDirection = -(ENCODERBASE));
|
2019-11-13 02:36:54 +01:00
|
|
|
}
|
2018-11-11 19:16:24 +01:00
|
|
|
|
|
|
|
#else
|
|
|
|
|
2021-12-28 09:57:24 +01:00
|
|
|
static void update_buttons() {}
|
2018-11-11 19:16:24 +01:00
|
|
|
|
|
|
|
#endif
|
|
|
|
|
2020-07-30 08:43:19 +02:00
|
|
|
#if ENABLED(TOUCH_SCREEN_CALIBRATION)
|
2020-11-15 23:39:58 +01:00
|
|
|
static void touch_calibration_screen();
|
2020-07-30 08:43:19 +02:00
|
|
|
#endif
|
|
|
|
|
2020-09-17 13:52:21 +02:00
|
|
|
#if HAS_GRAPHICAL_TFT
|
|
|
|
static void move_axis_screen();
|
|
|
|
#endif
|
|
|
|
|
2018-11-11 19:16:24 +01:00
|
|
|
private:
|
|
|
|
|
2021-06-27 07:33:44 +02:00
|
|
|
#if SCREENS_CAN_TIME_OUT
|
|
|
|
static millis_t return_to_status_ms;
|
|
|
|
static bool defer_return_to_status;
|
|
|
|
#else
|
|
|
|
static constexpr bool defer_return_to_status = false;
|
|
|
|
#endif
|
|
|
|
|
2020-11-23 01:44:17 +01:00
|
|
|
#if HAS_STATUS_MESSAGE
|
2019-03-17 11:32:12 +01:00
|
|
|
static void finish_status(const bool persist);
|
2018-11-18 05:21:44 +01:00
|
|
|
#endif
|
|
|
|
|
2020-09-28 08:13:27 +02:00
|
|
|
#if HAS_WIRED_LCD
|
2018-11-11 19:16:24 +01:00
|
|
|
static void draw_status_screen();
|
2020-07-30 08:43:19 +02:00
|
|
|
#if HAS_GRAPHICAL_TFT
|
|
|
|
static void tft_idle();
|
|
|
|
#if ENABLED(TOUCH_SCREEN)
|
|
|
|
static bool touch_pressed();
|
|
|
|
#endif
|
|
|
|
#endif
|
2018-11-11 19:16:24 +01:00
|
|
|
#endif
|
|
|
|
};
|
|
|
|
|
|
|
|
extern MarlinUI ui;
|
2018-11-17 04:44:48 +01:00
|
|
|
|
2021-09-26 00:05:11 +02:00
|
|
|
#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))
|