2016-03-25 06:19:46 +00:00
|
|
|
/**
|
2016-03-24 18:01:20 +00:00
|
|
|
* Marlin 3D Printer Firmware
|
|
|
|
* Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
|
|
|
|
*
|
|
|
|
* Based on Sprinter and grbl.
|
|
|
|
* Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm
|
|
|
|
*
|
|
|
|
* 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
|
|
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
*
|
|
|
|
*/
|
2018-10-23 21:00:34 +00:00
|
|
|
#pragma once
|
2012-11-06 11:06:41 +00:00
|
|
|
|
2017-09-06 11:28:32 +00:00
|
|
|
#include "../inc/MarlinConfig.h"
|
2016-03-27 11:25:33 +00:00
|
|
|
|
2018-11-17 03:44:48 +00:00
|
|
|
#if HAS_BUZZER
|
|
|
|
#include "../libs/buzzer.h"
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#define HAS_ENCODER_ACTION (HAS_LCD_MENU || ENABLED(ULTIPANEL_FEEDMULTIPLY))
|
|
|
|
|
2018-11-11 18:16:24 +00:00
|
|
|
#if HAS_SPI_LCD
|
|
|
|
|
|
|
|
#include "../Marlin.h"
|
|
|
|
|
|
|
|
#if ENABLED(ADVANCED_PAUSE_FEATURE)
|
|
|
|
#include "../feature/pause.h"
|
|
|
|
#include "../module/motion.h" // for active_extruder
|
|
|
|
#endif
|
|
|
|
|
2018-10-01 10:19:35 +00: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 02:39:49 +00:00
|
|
|
#if HAS_ADC_BUTTONS
|
2017-06-10 05:12:18 +00:00
|
|
|
uint8_t get_ADC_keyValue();
|
|
|
|
#endif
|
|
|
|
|
2018-10-30 21:34:45 +00:00
|
|
|
#if HAS_GRAPHICAL_LCD
|
2018-10-31 03:39:44 +00:00
|
|
|
#define SETCURSOR(col, row) lcd_moveto(col * (MENU_FONT_WIDTH), (row + 1) * (MENU_FONT_HEIGHT))
|
|
|
|
#define SETCURSOR_RJ(len, row) lcd_moveto(LCD_PIXEL_WIDTH - len * (MENU_FONT_WIDTH), (row + 1) * (MENU_FONT_HEIGHT))
|
2018-10-25 20:17:53 +00:00
|
|
|
#else
|
|
|
|
#define SETCURSOR(col, row) lcd_moveto(col, row)
|
|
|
|
#define SETCURSOR_RJ(len, row) lcd_moveto(LCD_WIDTH - len, row)
|
|
|
|
#endif
|
|
|
|
|
2012-12-03 11:52:00 +00:00
|
|
|
#define LCD_UPDATE_INTERVAL 100
|
|
|
|
|
2018-10-23 21:00:34 +00:00
|
|
|
#if HAS_LCD_MENU
|
2016-10-27 07:12:54 +00:00
|
|
|
|
2018-11-17 03:44:48 +00:00
|
|
|
#if ENABLED(SDSUPPORT)
|
|
|
|
#include "../sd/cardreader.h"
|
|
|
|
#endif
|
|
|
|
|
2017-09-06 11:28:32 +00:00
|
|
|
typedef void (*screenFunc_t)();
|
2017-10-03 04:33:57 +00:00
|
|
|
typedef void (*menuAction_t)();
|
2018-05-01 02:16:31 +00:00
|
|
|
|
2018-10-23 21:00:34 +00:00
|
|
|
// Manual Movement
|
|
|
|
constexpr float manual_feedrate_mm_m[XYZE] = MANUAL_FEEDRATE;
|
2018-10-27 21:45:37 +00:00
|
|
|
extern float move_menu_scale;
|
2016-04-28 16:57:21 +00:00
|
|
|
|
2017-05-26 18:01:02 +00:00
|
|
|
#if ENABLED(ADVANCED_PAUSE_FEATURE)
|
2018-01-04 11:06:34 +00:00
|
|
|
void lcd_advanced_pause_show_message(const AdvancedPauseMessage message,
|
2018-11-07 01:25:57 +00:00
|
|
|
const AdvancedPauseMode mode=ADVANCED_PAUSE_MODE_SAME,
|
2018-01-04 11:06:34 +00:00
|
|
|
const uint8_t extruder=active_extruder);
|
2018-05-22 01:32:16 +00:00
|
|
|
#endif
|
2017-09-06 11:28:32 +00:00
|
|
|
|
|
|
|
#if ENABLED(AUTO_BED_LEVELING_UBL)
|
2018-02-04 06:39:01 +00:00
|
|
|
void lcd_mesh_edit_setup(const float &initial);
|
2017-09-06 11:28:32 +00:00
|
|
|
float lcd_mesh_edit();
|
|
|
|
#endif
|
|
|
|
|
2018-10-30 21:34:45 +00:00
|
|
|
#endif // HAS_LCD_MENU
|
2015-03-20 09:50:28 +00:00
|
|
|
|
2018-10-24 07:27:19 +00:00
|
|
|
#endif
|
2012-12-03 11:52:00 +00:00
|
|
|
|
2018-11-19 02:39:49 +00:00
|
|
|
#if ENABLED(REPRAPWORLD_KEYPAD)
|
|
|
|
#define REPRAPWORLD_BTN_OFFSET 0 // Bit offset into buttons for shift register values
|
|
|
|
|
|
|
|
#define BLEN_REPRAPWORLD_KEYPAD_F3 0
|
|
|
|
#define BLEN_REPRAPWORLD_KEYPAD_F2 1
|
|
|
|
#define BLEN_REPRAPWORLD_KEYPAD_F1 2
|
|
|
|
#define BLEN_REPRAPWORLD_KEYPAD_DOWN 3
|
|
|
|
#define BLEN_REPRAPWORLD_KEYPAD_RIGHT 4
|
|
|
|
#define BLEN_REPRAPWORLD_KEYPAD_MIDDLE 5
|
|
|
|
#define BLEN_REPRAPWORLD_KEYPAD_UP 6
|
|
|
|
#define BLEN_REPRAPWORLD_KEYPAD_LEFT 7
|
|
|
|
|
|
|
|
#define EN_REPRAPWORLD_KEYPAD_F1 (_BV(REPRAPWORLD_BTN_OFFSET + BLEN_REPRAPWORLD_KEYPAD_F1))
|
|
|
|
#define EN_REPRAPWORLD_KEYPAD_F2 (_BV(REPRAPWORLD_BTN_OFFSET + BLEN_REPRAPWORLD_KEYPAD_F2))
|
|
|
|
#define EN_REPRAPWORLD_KEYPAD_F3 (_BV(REPRAPWORLD_BTN_OFFSET + BLEN_REPRAPWORLD_KEYPAD_F3))
|
|
|
|
#define EN_REPRAPWORLD_KEYPAD_DOWN (_BV(REPRAPWORLD_BTN_OFFSET + BLEN_REPRAPWORLD_KEYPAD_DOWN))
|
|
|
|
#define EN_REPRAPWORLD_KEYPAD_RIGHT (_BV(REPRAPWORLD_BTN_OFFSET + BLEN_REPRAPWORLD_KEYPAD_RIGHT))
|
|
|
|
#define EN_REPRAPWORLD_KEYPAD_MIDDLE (_BV(REPRAPWORLD_BTN_OFFSET + BLEN_REPRAPWORLD_KEYPAD_MIDDLE))
|
|
|
|
#define EN_REPRAPWORLD_KEYPAD_UP (_BV(REPRAPWORLD_BTN_OFFSET + BLEN_REPRAPWORLD_KEYPAD_UP))
|
|
|
|
#define EN_REPRAPWORLD_KEYPAD_LEFT (_BV(REPRAPWORLD_BTN_OFFSET + BLEN_REPRAPWORLD_KEYPAD_LEFT))
|
|
|
|
|
|
|
|
#define RRK(B) (keypad_buttons & (B))
|
|
|
|
#endif
|
|
|
|
|
2018-11-18 03:21:30 +00:00
|
|
|
#if HAS_DIGITAL_BUTTONS
|
2018-05-22 01:32:16 +00:00
|
|
|
|
2018-11-09 06:07:16 +00:00
|
|
|
// Wheel spin pins where BA is 00, 10, 11, 01 (1 bit always changes)
|
|
|
|
#define BLEN_A 0
|
|
|
|
#define BLEN_B 1
|
2018-05-22 01:32:16 +00:00
|
|
|
|
2018-11-09 06:07:16 +00:00
|
|
|
#define EN_A _BV(BLEN_A)
|
|
|
|
#define EN_B _BV(BLEN_B)
|
2018-05-22 01:32:16 +00:00
|
|
|
|
2018-11-14 12:00:21 +00:00
|
|
|
#define BUTTON_EXISTS(BN) (defined(BTN_## BN) && BTN_## BN >= 0)
|
|
|
|
#define BUTTON_PRESSED(BN) !READ(BTN_## BN)
|
|
|
|
|
2018-11-09 06:07:16 +00:00
|
|
|
#if BUTTON_EXISTS(ENC)
|
|
|
|
#define BLEN_C 2
|
|
|
|
#define EN_C _BV(BLEN_C)
|
|
|
|
#endif
|
2018-05-22 01:32:16 +00:00
|
|
|
|
2018-11-09 06:07:16 +00:00
|
|
|
#if BUTTON_EXISTS(BACK)
|
|
|
|
#define BLEN_D 3
|
|
|
|
#define EN_D _BV(BLEN_D)
|
2018-11-11 18:16:24 +00:00
|
|
|
#define LCD_BACK_CLICKED() (buttons & EN_D)
|
2018-11-09 06:07:16 +00:00
|
|
|
#endif
|
2018-05-22 01:32:16 +00:00
|
|
|
|
2018-11-11 18:16:24 +00:00
|
|
|
#if ENABLED(REPRAPWORLD_KEYPAD)
|
|
|
|
|
|
|
|
#ifdef EN_C
|
|
|
|
#define BUTTON_CLICK() ((buttons & EN_C) || RRK(EN_REPRAPWORLD_KEYPAD_MIDDLE))
|
|
|
|
#else
|
|
|
|
#define BUTTON_CLICK() RRK(EN_REPRAPWORLD_KEYPAD_MIDDLE)
|
|
|
|
#endif
|
2018-11-09 06:07:16 +00:00
|
|
|
|
2018-11-11 18:16:24 +00:00
|
|
|
#elif ENABLED(LCD_I2C_VIKI)
|
2018-05-22 01:32:16 +00:00
|
|
|
|
2018-11-11 18:16:24 +00:00
|
|
|
#define B_I2C_BTN_OFFSET 3 // (the first three bit positions reserved for EN_A, EN_B, EN_C)
|
2018-05-22 01:32:16 +00:00
|
|
|
|
2018-11-11 18:16:24 +00:00
|
|
|
// button and encoder bit positions within 'buttons'
|
|
|
|
#define B_LE (BUTTON_LEFT << B_I2C_BTN_OFFSET) // The remaining normalized buttons are all read via I2C
|
|
|
|
#define B_UP (BUTTON_UP << B_I2C_BTN_OFFSET)
|
|
|
|
#define B_MI (BUTTON_SELECT << B_I2C_BTN_OFFSET)
|
|
|
|
#define B_DW (BUTTON_DOWN << B_I2C_BTN_OFFSET)
|
|
|
|
#define B_RI (BUTTON_RIGHT << B_I2C_BTN_OFFSET)
|
2018-05-22 01:32:16 +00:00
|
|
|
|
2018-11-11 18:16:24 +00:00
|
|
|
#if BUTTON_EXISTS(ENC) // The pause/stop/restart button is connected to BTN_ENC when used
|
|
|
|
#define B_ST (EN_C) // Map the pause/stop/resume button into its normalized functional name
|
|
|
|
#define BUTTON_CLICK() (buttons & (B_MI|B_RI|B_ST)) // Pause/stop also acts as click until a proper pause/stop is implemented.
|
|
|
|
#else
|
|
|
|
#define BUTTON_CLICK() (buttons & (B_MI|B_RI))
|
|
|
|
#endif
|
2018-05-22 01:32:16 +00:00
|
|
|
|
2018-11-11 18:16:24 +00:00
|
|
|
// I2C buttons take too long to read inside an interrupt context and so we read them during lcd_update
|
|
|
|
#define LCD_HAS_SLOW_BUTTONS
|
2018-05-22 01:32:16 +00:00
|
|
|
|
2018-11-11 18:16:24 +00:00
|
|
|
#elif ENABLED(LCD_I2C_PANELOLU2)
|
2018-10-23 21:00:34 +00:00
|
|
|
|
2018-11-11 18:16:24 +00:00
|
|
|
#if !BUTTON_EXISTS(ENC) // Use I2C if not directly connected to a pin
|
|
|
|
|
|
|
|
#define B_I2C_BTN_OFFSET 3 // (the first three bit positions reserved for EN_A, EN_B, EN_C)
|
|
|
|
|
|
|
|
#define B_MI (PANELOLU2_ENCODER_C << B_I2C_BTN_OFFSET) // requires LiquidTWI2 library v1.2.3 or later
|
|
|
|
|
|
|
|
#define BUTTON_CLICK() (buttons & B_MI)
|
|
|
|
|
|
|
|
// I2C buttons take too long to read inside an interrupt context and so we read them during lcd_update
|
|
|
|
#define LCD_HAS_SLOW_BUTTONS
|
|
|
|
|
|
|
|
#endif
|
2018-11-03 03:29:32 +00:00
|
|
|
|
|
|
|
#endif
|
|
|
|
|
2018-11-11 18:16:24 +00:00
|
|
|
#else
|
|
|
|
|
2018-11-19 02:39:49 +00:00
|
|
|
#define BUTTON_EXISTS(BN) 0
|
|
|
|
|
2018-11-11 18:16:24 +00:00
|
|
|
// Shift register bits correspond to buttons:
|
|
|
|
#define BL_LE 7 // Left
|
|
|
|
#define BL_UP 6 // Up
|
|
|
|
#define BL_MI 5 // Middle
|
|
|
|
#define BL_DW 4 // Down
|
|
|
|
#define BL_RI 3 // Right
|
|
|
|
#define BL_ST 2 // Red Button
|
|
|
|
#define B_LE (_BV(BL_LE))
|
|
|
|
#define B_UP (_BV(BL_UP))
|
|
|
|
#define B_MI (_BV(BL_MI))
|
|
|
|
#define B_DW (_BV(BL_DW))
|
|
|
|
#define B_RI (_BV(BL_RI))
|
|
|
|
#define B_ST (_BV(BL_ST))
|
|
|
|
#define BUTTON_CLICK() (buttons & (B_MI|B_ST))
|
|
|
|
|
|
|
|
#endif
|
2018-11-03 03:29:32 +00:00
|
|
|
|
2018-11-11 18:16:24 +00:00
|
|
|
#ifndef BUTTON_CLICK
|
2018-11-03 03:29:32 +00:00
|
|
|
#ifdef EN_C
|
2018-11-11 18:16:24 +00:00
|
|
|
#define BUTTON_CLICK() (buttons & EN_C)
|
2018-11-03 03:29:32 +00:00
|
|
|
#else
|
2018-11-11 18:16:24 +00:00
|
|
|
#define BUTTON_CLICK() false
|
2018-05-23 01:34:59 +00:00
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
|
2018-11-13 07:47:45 +00:00
|
|
|
#if HAS_GRAPHICAL_LCD
|
|
|
|
enum MarlinFont : uint8_t {
|
|
|
|
FONT_STATUSMENU = 1,
|
|
|
|
FONT_EDIT,
|
|
|
|
FONT_MENU
|
|
|
|
};
|
2018-11-19 01:58:02 +00:00
|
|
|
#else
|
|
|
|
enum HD44780CharSet : uint8_t {
|
|
|
|
CHARSET_MENU,
|
|
|
|
CHARSET_INFO,
|
|
|
|
CHARSET_BOOT
|
|
|
|
};
|
2018-11-13 07:47:45 +00:00
|
|
|
#endif
|
|
|
|
|
2018-11-11 18:16:24 +00:00
|
|
|
////////////////////////////////////////////
|
|
|
|
//////////// MarlinUI Singleton ////////////
|
|
|
|
////////////////////////////////////////////
|
2017-05-30 01:12:10 +00:00
|
|
|
|
2018-11-11 18:16:24 +00:00
|
|
|
class MarlinUI {
|
|
|
|
public:
|
2017-07-03 15:06:23 +00:00
|
|
|
|
2018-11-11 18:16:24 +00:00
|
|
|
MarlinUI() {
|
|
|
|
#if HAS_LCD_MENU
|
|
|
|
currentScreen = status_screen;
|
|
|
|
#endif
|
|
|
|
}
|
2017-10-27 04:39:51 +00:00
|
|
|
|
2018-11-11 18:16:24 +00:00
|
|
|
static inline void buzz(const long duration, const uint16_t freq) {
|
|
|
|
#if ENABLED(LCD_USE_I2C_BUZZER)
|
|
|
|
lcd.buzz(duration, freq);
|
|
|
|
#elif PIN_EXISTS(BEEPER)
|
|
|
|
buzzer.tone(duration, freq);
|
|
|
|
#else
|
|
|
|
UNUSED(duration); UNUSED(freq);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
// LCD implementations
|
|
|
|
static void clear_lcd();
|
|
|
|
static void init_lcd();
|
|
|
|
|
|
|
|
#if HAS_SPI_LCD || ENABLED(MALYAN_LCD) || ENABLED(EXTENSIBLE_UI)
|
|
|
|
static void init();
|
|
|
|
static void update();
|
2018-11-18 04:21:44 +00:00
|
|
|
static void set_alert_status_P(PGM_P message);
|
2018-11-11 18:16:24 +00:00
|
|
|
#else // NO LCD
|
|
|
|
static inline void init() {}
|
|
|
|
static inline void update() {}
|
2018-11-18 04:21:44 +00:00
|
|
|
static inline void set_alert_status_P(PGM_P message) { UNUSED(message); }
|
2018-11-11 18:16:24 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#if HAS_SPI_LCD || ENABLED(EXTENSIBLE_UI)
|
|
|
|
|
2018-11-18 04:21:44 +00:00
|
|
|
static char status_message[];
|
|
|
|
static bool has_status();
|
|
|
|
|
|
|
|
|
|
|
|
static uint8_t status_message_level; // Higher levels block lower levels
|
|
|
|
static inline void reset_alert_level() { status_message_level = 0; }
|
|
|
|
|
2018-11-11 18:16:24 +00:00
|
|
|
#if HAS_SPI_LCD
|
|
|
|
|
2018-11-13 07:47:45 +00:00
|
|
|
static bool detected();
|
|
|
|
|
2018-11-11 18:16:24 +00:00
|
|
|
static LCDViewAction lcdDrawUpdate;
|
|
|
|
static inline bool should_draw() { return bool(lcdDrawUpdate); }
|
|
|
|
static inline void refresh(const LCDViewAction type) { lcdDrawUpdate = type; }
|
|
|
|
static inline void refresh() { refresh(LCDVIEW_CLEAR_CALL_REDRAW); }
|
|
|
|
|
|
|
|
#if ENABLED(SHOW_BOOTSCREEN)
|
|
|
|
static void show_bootscreen();
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if HAS_GRAPHICAL_LCD
|
|
|
|
|
|
|
|
static bool drawing_screen, first_page;
|
|
|
|
|
|
|
|
static void set_font(const MarlinFont font_nr);
|
|
|
|
|
|
|
|
#else
|
|
|
|
|
|
|
|
static constexpr bool drawing_screen = false, first_page = true;
|
|
|
|
|
2018-11-19 01:58:02 +00:00
|
|
|
static void set_custom_characters(const HD44780CharSet screen_charset=CHARSET_INFO);
|
2018-11-11 18:16:24 +00:00
|
|
|
|
|
|
|
#if ENABLED(LCD_PROGRESS_BAR)
|
|
|
|
static millis_t progress_bar_ms; // Start time for the current progress bar cycle
|
2018-11-19 01:58:02 +00:00
|
|
|
static void draw_progress_bar(const uint8_t percent);
|
2018-11-11 18:16:24 +00:00
|
|
|
#if PROGRESS_MSG_EXPIRE > 0
|
|
|
|
static millis_t MarlinUI::expire_status_ms; // = 0
|
|
|
|
static inline void reset_progress_bar_timeout() { expire_status_ms = 0; }
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if ENABLED(STATUS_MESSAGE_SCROLLING)
|
|
|
|
static uint8_t status_scroll_offset;
|
|
|
|
#endif
|
|
|
|
static uint8_t lcd_status_update_delay;
|
|
|
|
|
|
|
|
#if HAS_PRINT_PROGRESS
|
|
|
|
#if ENABLED(LCD_SET_PROGRESS_MANUALLY)
|
|
|
|
static uint8_t progress_bar_percent;
|
|
|
|
static void set_progress(const uint8_t progress) { progress_bar_percent = MIN(progress, 100); }
|
|
|
|
#endif
|
|
|
|
static uint8_t get_progress();
|
|
|
|
#else
|
|
|
|
static constexpr uint8_t get_progress() { return 0; }
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if HAS_LCD_CONTRAST
|
|
|
|
static int16_t contrast;
|
|
|
|
static void set_contrast(const int16_t value);
|
|
|
|
static inline void refresh_contrast() { set_contrast(contrast); }
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if ENABLED(FILAMENT_LCD_DISPLAY) && ENABLED(SDSUPPORT)
|
|
|
|
static millis_t next_filament_display;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
static void quick_feedback(const bool clear_buttons=true);
|
|
|
|
static void completion_feedback(const bool good=true);
|
|
|
|
|
|
|
|
#if DISABLED(LIGHTWEIGHT_UI)
|
|
|
|
static void draw_status_message(const bool blink);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if ENABLED(ADVANCED_PAUSE_FEATURE)
|
|
|
|
static void draw_hotend_status(const uint8_t row, const uint8_t extruder);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
static void status_screen();
|
|
|
|
|
|
|
|
#else
|
2018-11-13 07:47:45 +00:00
|
|
|
static void refresh() {}
|
2018-11-11 18:16:24 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
static bool get_blink();
|
|
|
|
static void kill_screen(PGM_P const lcd_msg);
|
|
|
|
static void draw_kill_screen();
|
2018-11-18 04:21:44 +00:00
|
|
|
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);
|
2018-11-11 18:16:24 +00:00
|
|
|
static void status_printf_P(const uint8_t level, PGM_P const fmt, ...);
|
|
|
|
static void reset_status();
|
|
|
|
|
|
|
|
#else // MALYAN_LCD or NO LCD
|
|
|
|
|
|
|
|
static inline void refresh() {}
|
2018-11-18 04:21:44 +00:00
|
|
|
static inline void set_status(const char* const message, const bool persist=false) { UNUSED(message); UNUSED(persist); }
|
|
|
|
static inline void set_status_P(PGM_P const message, const int8_t level=0) { UNUSED(message); UNUSED(level); }
|
2018-11-11 18:16:24 +00:00
|
|
|
static inline void status_printf_P(const uint8_t level, PGM_P const fmt, ...) { UNUSED(level); UNUSED(fmt); }
|
|
|
|
static inline void reset_status() {}
|
|
|
|
static inline void reset_alert_level() {}
|
2018-11-14 07:34:16 +00:00
|
|
|
static constexpr bool has_status() { return false; }
|
2018-11-11 18:16:24 +00:00
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if HAS_LCD_MENU
|
|
|
|
|
|
|
|
#if ENABLED(ENCODER_RATE_MULTIPLIER)
|
|
|
|
static bool encoderRateMultiplierEnabled;
|
|
|
|
static millis_t lastEncoderMovementMillis;
|
|
|
|
static void enable_encoder_multiplier(const bool onoff);
|
|
|
|
#endif
|
|
|
|
|
2018-11-17 03:44:48 +00:00
|
|
|
#if ENABLED(SDSUPPORT)
|
|
|
|
#if ENABLED(SCROLL_LONG_FILENAMES)
|
|
|
|
static uint8_t filename_scroll_pos, filename_scroll_max;
|
|
|
|
#endif
|
|
|
|
static const char * const scrolled_filename(CardReader &theCard, const uint8_t maxlen, uint8_t hash, const bool doScroll);
|
2018-11-11 18:16:24 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#if IS_KINEMATIC
|
|
|
|
static bool processing_manual_move;
|
|
|
|
#else
|
|
|
|
static constexpr bool processing_manual_move = false;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if E_MANUAL > 1
|
|
|
|
static int8_t manual_move_e_index;
|
|
|
|
#else
|
|
|
|
static constexpr int8_t manual_move_e_index = 0;
|
|
|
|
#endif
|
2018-10-24 07:27:19 +00:00
|
|
|
|
2018-11-11 18:16:24 +00:00
|
|
|
static int16_t preheat_hotend_temp[2], preheat_bed_temp[2];
|
|
|
|
static uint8_t preheat_fan_speed[2];
|
2018-10-30 21:34:45 +00:00
|
|
|
|
2018-11-11 18:16:24 +00:00
|
|
|
static void manage_manual_move();
|
2018-10-24 07:27:19 +00:00
|
|
|
|
2018-11-11 18:16:24 +00:00
|
|
|
static bool lcd_clicked;
|
|
|
|
static bool use_click();
|
2018-10-30 21:34:45 +00:00
|
|
|
|
2018-11-11 18:16:24 +00:00
|
|
|
static void synchronize(PGM_P const msg=NULL);
|
|
|
|
|
|
|
|
static screenFunc_t currentScreen;
|
|
|
|
static void goto_screen(const screenFunc_t screen, const uint32_t encoder=0);
|
|
|
|
static void save_previous_screen();
|
|
|
|
static void goto_previous_screen();
|
|
|
|
static void return_to_status();
|
|
|
|
static inline bool on_status_screen() { return currentScreen == status_screen; }
|
|
|
|
static inline void run_current_screen() { (*currentScreen)(); }
|
|
|
|
|
2018-11-13 07:47:45 +00:00
|
|
|
#if ENABLED(LIGHTWEIGHT_UI)
|
|
|
|
static void lcd_in_status(const bool inStatus);
|
|
|
|
#endif
|
|
|
|
|
2018-11-11 18:16:24 +00:00
|
|
|
static inline void defer_status_screen(const bool defer) {
|
|
|
|
#if LCD_TIMEOUT_TO_STATUS
|
|
|
|
defer_return_to_status = defer;
|
|
|
|
#else
|
|
|
|
UNUSED(defer);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void goto_previous_screen_no_defer() {
|
|
|
|
defer_status_screen(false);
|
|
|
|
goto_previous_screen();
|
|
|
|
}
|
|
|
|
|
|
|
|
#if ENABLED(SD_REPRINT_LAST_SELECTED_FILE)
|
|
|
|
static void reselect_last_file();
|
2018-10-30 21:34:45 +00:00
|
|
|
#endif
|
2018-11-11 18:16:24 +00:00
|
|
|
|
|
|
|
#if ENABLED(G26_MESH_VALIDATION)
|
|
|
|
static inline void chirp() { buzz(LCD_FEEDBACK_FREQUENCY_DURATION_MS, LCD_FEEDBACK_FREQUENCY_HZ); }
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if ENABLED(AUTO_BED_LEVELING_UBL)
|
|
|
|
static void ubl_plot(const uint8_t x, const uint8_t inverted_y);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#elif HAS_SPI_LCD
|
|
|
|
|
|
|
|
static constexpr bool lcd_clicked = false;
|
|
|
|
static constexpr bool on_status_screen() { return true; }
|
|
|
|
static inline void run_current_screen() { status_screen(); }
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if ENABLED(LCD_BED_LEVELING) && (ENABLED(PROBE_MANUALLY) || ENABLED(MESH_BED_LEVELING))
|
|
|
|
static bool wait_for_bl_move;
|
2018-10-30 21:34:45 +00:00
|
|
|
#else
|
2018-11-11 18:16:24 +00:00
|
|
|
static constexpr bool wait_for_bl_move = false;
|
2018-10-30 21:34:45 +00:00
|
|
|
#endif
|
2018-10-24 07:27:19 +00:00
|
|
|
|
2018-11-11 18:16:24 +00:00
|
|
|
#if HAS_LCD_MENU && (ENABLED(AUTO_BED_LEVELING_UBL) || ENABLED(G26_MESH_VALIDATION))
|
|
|
|
static bool external_control;
|
|
|
|
FORCE_INLINE static void capture() { external_control = true; }
|
|
|
|
FORCE_INLINE static void release() { external_control = false; }
|
|
|
|
#else
|
|
|
|
static constexpr bool external_control = false;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if HAS_ENCODER_ACTION
|
|
|
|
|
|
|
|
static volatile uint8_t buttons;
|
2018-11-14 12:00:21 +00:00
|
|
|
#if ENABLED(REPRAPWORLD_KEYPAD)
|
2018-11-19 02:39:49 +00:00
|
|
|
static volatile uint8_t keypad_buttons;
|
2018-11-14 12:00:21 +00:00
|
|
|
static bool handle_keypad();
|
|
|
|
#endif
|
2018-11-11 18:16:24 +00:00
|
|
|
#if ENABLED(LCD_HAS_SLOW_BUTTONS)
|
|
|
|
static volatile uint8_t slow_buttons;
|
|
|
|
static uint8_t read_slow_buttons();
|
|
|
|
#endif
|
|
|
|
static void update_buttons();
|
|
|
|
static inline bool button_pressed() { return BUTTON_CLICK(); }
|
|
|
|
#if ENABLED(AUTO_BED_LEVELING_UBL) || ENABLED(G26_MESH_VALIDATION)
|
|
|
|
static void wait_for_release();
|
|
|
|
#endif
|
|
|
|
|
|
|
|
static uint32_t encoderPosition;
|
|
|
|
|
|
|
|
#if ENABLED(REVERSE_ENCODER_DIRECTION)
|
|
|
|
#define ENCODERBASE -1
|
|
|
|
#else
|
|
|
|
#define ENCODERBASE +1
|
|
|
|
#endif
|
|
|
|
#if ENABLED(REVERSE_MENU_DIRECTION)
|
|
|
|
static int8_t encoderDirection;
|
|
|
|
static inline void encoder_direction_normal() { encoderDirection = +(ENCODERBASE); }
|
|
|
|
static inline void encoder_direction_menus() { encoderDirection = -(ENCODERBASE); }
|
|
|
|
#else
|
|
|
|
static constexpr int8_t encoderDirection = ENCODERBASE;
|
2018-11-13 07:47:45 +00:00
|
|
|
static inline void encoder_direction_normal() {}
|
|
|
|
static inline void encoder_direction_menus() {}
|
2018-11-11 18:16:24 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#else
|
|
|
|
|
2018-11-13 07:47:45 +00:00
|
|
|
static inline void update_buttons() {}
|
2018-11-11 18:16:24 +00:00
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
private:
|
|
|
|
|
|
|
|
static void _synchronize();
|
|
|
|
|
2018-11-18 04:21:44 +00:00
|
|
|
#if HAS_SPI_LCD || ENABLED(EXTENSIBLE_UI)
|
|
|
|
static void finishstatus(const bool persist);
|
|
|
|
#endif
|
|
|
|
|
2018-11-11 18:16:24 +00:00
|
|
|
#if HAS_SPI_LCD
|
|
|
|
#if HAS_LCD_MENU
|
|
|
|
#if LCD_TIMEOUT_TO_STATUS
|
|
|
|
static bool defer_return_to_status;
|
|
|
|
#else
|
|
|
|
static constexpr bool defer_return_to_status = false;
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
static void draw_status_screen();
|
|
|
|
#endif
|
|
|
|
};
|
|
|
|
|
|
|
|
extern MarlinUI ui;
|
2018-11-17 03:44:48 +00:00
|
|
|
|
2018-11-18 04:21:44 +00:00
|
|
|
#define LCD_MESSAGEPGM(x) ui.set_status_P(PSTR(x))
|
|
|
|
#define LCD_ALERTMESSAGEPGM(x) ui.set_alert_status_P(PSTR(x))
|