Firmware/Marlin/ultralcd.cpp

5150 lines
175 KiB
C++
Raw Normal View History

/**
2016-03-24 19:01:20 +01: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/>.
*
*/
#include "MarlinConfig.h"
#if ENABLED(ULTRA_LCD)
#include "ultralcd.h"
#include "Marlin.h"
#include "language.h"
#include "cardreader.h"
#include "temperature.h"
#include "planner.h"
#include "stepper.h"
2015-04-26 06:04:54 +02:00
#include "configuration_store.h"
#include "utility.h"
2017-11-10 09:38:53 +01:00
#include "gcode.h"
2016-10-10 22:34:35 +02:00
#if HAS_BUZZER && DISABLED(LCD_USE_I2C_BUZZER)
#include "buzzer.h"
#endif
#if ENABLED(PRINTCOUNTER)
#include "printcounter.h"
2016-07-24 04:13:35 +02:00
#include "duration_t.h"
#endif
#if ENABLED(BLTOUCH)
#include "endstops.h"
#endif
#if ENABLED(AUTO_BED_LEVELING_UBL)
#include "ubl.h"
2017-10-13 17:03:59 +02:00
#elif HAS_ABL
#include "planner.h"
#elif ENABLED(MESH_BED_LEVELING) && ENABLED(LCD_BED_LEVELING)
#include "mesh_bed_leveling.h"
extern void mesh_probing_done();
#endif
#if ENABLED(AUTO_BED_LEVELING_UBL) || ENABLED(G26_MESH_VALIDATION)
bool lcd_external_control;
#endif
// Initialized by settings.load()
int16_t lcd_preheat_hotend_temp[2], lcd_preheat_bed_temp[2], lcd_preheat_fan_speed[2];
2017-10-15 08:40:34 +02:00
#if ENABLED(LCD_SET_PROGRESS_MANUALLY) && (ENABLED(LCD_PROGRESS_BAR) || ENABLED(DOGLCD))
uint8_t progress_bar_percent;
#endif
#if ENABLED(FILAMENT_LCD_DISPLAY) && ENABLED(SDSUPPORT)
2015-04-13 03:07:08 +02:00
millis_t previous_lcd_status_ms = 0;
#endif
#if ENABLED(BABYSTEPPING)
long babysteps_done = 0;
#if ENABLED(BABYSTEP_ZPROBE_OFFSET)
static void lcd_babystep_zoffset();
#else
static void lcd_babystep_z();
#endif
#endif
uint8_t lcd_status_update_delay = 1, // First update one loop delayed
lcd_status_message_level; // Higher level blocks lower level
2016-03-13 07:38:55 +01:00
char lcd_status_message[3 * (LCD_WIDTH) + 1] = WELCOME_MSG; // worst case is kana with up to 3*LCD_WIDTH+1
2017-05-28 18:12:12 +02:00
#if ENABLED(STATUS_MESSAGE_SCROLLING)
uint8_t status_scroll_pos = 0;
#endif
#if ENABLED(SCROLL_LONG_FILENAMES)
uint8_t filename_scroll_pos, filename_scroll_max, filename_scroll_hash;
#endif
#if ENABLED(DOGLCD)
#include "ultralcd_impl_DOGM.h"
#include <U8glib.h>
#else
#include "ultralcd_impl_HD44780.h"
#endif
#if ENABLED(ULTIPANEL)
#define DEFINE_LCD_IMPLEMENTATION_DRAWMENU_SETTING_EDIT_TYPE(_type, _name, _strFunc) \
inline void lcd_implementation_drawmenu_setting_edit_ ## _name (const bool sel, const uint8_t row, const char* pstr, const char* pstr2, _type * const data, ...) { \
UNUSED(pstr2); \
DRAWMENU_SETTING_EDIT_GENERIC(_strFunc(*(data))); \
} \
inline void lcd_implementation_drawmenu_setting_edit_callback_ ## _name (const bool sel, const uint8_t row, const char* pstr, const char* pstr2, _type * const data, ...) { \
UNUSED(pstr2); \
DRAWMENU_SETTING_EDIT_GENERIC(_strFunc(*(data))); \
} \
inline void lcd_implementation_drawmenu_setting_edit_accessor_ ## _name (const bool sel, const uint8_t row, const char* pstr, const char* pstr2, _type (*pget)(), void (*pset)(_type), ...) { \
UNUSED(pstr2); UNUSED(pset); \
DRAWMENU_SETTING_EDIT_GENERIC(_strFunc(pget())); \
} \
typedef void _name##_void
DEFINE_LCD_IMPLEMENTATION_DRAWMENU_SETTING_EDIT_TYPE(int16_t, int3, itostr3);
DEFINE_LCD_IMPLEMENTATION_DRAWMENU_SETTING_EDIT_TYPE(uint8_t, int8, i8tostr3);
DEFINE_LCD_IMPLEMENTATION_DRAWMENU_SETTING_EDIT_TYPE(float, float3, ftostr3);
DEFINE_LCD_IMPLEMENTATION_DRAWMENU_SETTING_EDIT_TYPE(float, float32, ftostr32);
DEFINE_LCD_IMPLEMENTATION_DRAWMENU_SETTING_EDIT_TYPE(float, float43, ftostr43sign);
DEFINE_LCD_IMPLEMENTATION_DRAWMENU_SETTING_EDIT_TYPE(float, float5, ftostr5rj);
DEFINE_LCD_IMPLEMENTATION_DRAWMENU_SETTING_EDIT_TYPE(float, float51, ftostr51sign);
DEFINE_LCD_IMPLEMENTATION_DRAWMENU_SETTING_EDIT_TYPE(float, float52, ftostr52sign);
DEFINE_LCD_IMPLEMENTATION_DRAWMENU_SETTING_EDIT_TYPE(float, float62, ftostr62rj);
DEFINE_LCD_IMPLEMENTATION_DRAWMENU_SETTING_EDIT_TYPE(uint32_t, long5, ftostr5rj);
#define lcd_implementation_drawmenu_setting_edit_bool(sel, row, pstr, pstr2, data) DRAW_BOOL_SETTING(sel, row, pstr, data)
#define lcd_implementation_drawmenu_setting_edit_callback_bool(sel, row, pstr, pstr2, data, callback) DRAW_BOOL_SETTING(sel, row, pstr, data)
#define lcd_implementation_drawmenu_setting_edit_accessor_bool(sel, row, pstr, pstr2, pget, pset) DRAW_BOOL_SETTING(sel, row, pstr, data)
#endif // ULTIPANEL
// The main status screen
void lcd_status_screen();
2016-06-11 23:12:00 +02:00
millis_t next_lcd_update_ms;
uint8_t lcdDrawUpdate = LCDVIEW_CLEAR_CALL_REDRAW; // Set when the LCD needs to draw, decrements after every draw. Set to 2 in LCD routines so the LCD gets at least 1 full redraw (first redraw is partial)
uint16_t max_display_update_time = 0;
Distribute GLCD screen updates in time Currently we draw and send the screens for a graphical LCD all at once. We draw in two or four parts but draw them directly behind each other. For the tested status screen this takes 59-62ms in a single block. During this time nothing else (except the interrupts) can be done. When printing a sequence of very short moves the buffer drains - sometimes until it's empty. This PR splits the screen update into parts. Currently we have 10 time slots. During the first one the complete screen is drawn. (60,0,0,0,0,0,0,0,0,0,0) Here i introduce pauses for doing other things. (30,30,0,0,0,0,0,0) or (15,15,15,15,0,0,0,0,0,0) Drawing in consecutive time slots prevents from lagging too much. Even with a 4 stripe display all the drawing is done after 400ms. Previous experiments with a even better distribution of the time slots like (30,0,0,0,0,30,0,0,0,0) and (15,0,15,0,15,0,15,0,0,0) did not feel good when using the menu, because of too much lag. Because of the previous PRs to speed up the display updates and especially reducing the difference between drawing 2 or 4 stripes, it now makes sense for the REPRAP_DISCOUNT_FULL_GRAPHIC_SMART_CONTROLLER to go from 2 to 4 stripes. This costs about 1-2ms per complete screen update, but is payed back by having partial updates lasting only the half time and two additional brakes. Also ~256 byte of framebuffer are saved in RAM. 13:45:59.213 : echo: #:17 >:13 s:30; #:16 >:13 s:29; S#:33 S>:26 S:59 13:46:00.213 : echo: #:16 >:14 s:30; #:17 >:13 s:30; S#:33 S>:27 S:60 13:46:01.215 : echo: #:17 >:13 s:30; #:16 >:13 s:29; S#:33 S>:26 S:59 13:46:02.215 : echo: #:16 >:13 s:29; #:16 >:14 s:30; S#:32 S>:27 S:59 13:46:03.214 : echo: #:17 >:13 s:30; #:17 >:13 s:30; S#:34 S>:26 S:60 13:46:04.214 : echo: #:16 >:13 s:29; #:16 >:14 s:30; S#:32 S>:27 S:59 13:46:05.212 : echo: #:16 >:14 s:30; #:17 >:13 s:30; S#:33 S>:27 S:60 13:46:06.212 : echo: #:17 >:13 s:30; #:16 >:13 s:29; S#:33 S>:26 S:59 03:30:36.779 : echo: #:8 >:7 s:15; #:10 >:7 s:17; #:8 >:6 s:14; #:8 >:7 s:15; S#:34 S>:27 S:61 03:30:37.778 : echo: #:8 >:6 s:14; #:10 >:7 s:17; #:9 >:7 s:16; #:8 >:6 s:14; S#:35 S>:26 S:61 03:30:38.778 : echo: #:8 >:6 s:14; #:11 >:7 s:18; #:8 >:6 s:14; #:8 >:7 s:15; S#:35 S>:26 S:61 03:30:39.777 : echo: #:8 >:6 s:14; #:10 >:7 s:17; #:8 >:8 s:16; #:8 >:6 s:14; S#:34 S>:27 S:61 03:30:40.780 : echo: #:8 >:6 s:14; #:11 >:7 s:18; #:8 >:6 s:14; #:8 >:6 s:14; S#:35 S>:25 S:60 03:30:41.780 : echo: #:9 >:6 s:15; #:10 >:7 s:17; #:8 >:6 s:14; #:9 >:6 s:15; S#:36 S>:25 S:61 03:30:42.779 : echo: #:8 >:6 s:14; #:10 >:8 s:18; #:8 >:6 s:14; #:8 >:6 s:14; S#:34 S>:26 S:60 03:30:43.778 : echo: #:9 >:6 s:15; #:10 >:7 s:17; #:8 >:7 s:15; #:9 >:6 s:15; S#:36 S>:26 S:62 #: draw a stripe >: transfer a stripe s: sum of of draw and transfer for one stripe S#: sum of draws for a complete screen S>: sum of transfers for a complete screen S: time to draw and transfer a complete screen
2016-11-24 21:17:25 +01:00
#if ENABLED(DOGLCD)
bool drawing_screen = false;
#endif
2016-06-11 23:12:00 +02:00
2016-10-04 00:15:29 +02:00
#if ENABLED(DAC_STEPPER_CURRENT)
#include "stepper_dac.h" //was dac_mcp4728.h MarlinMain uses stepper dac for the m-codes
uint8_t driverPercent[XYZE];
2016-10-04 00:15:29 +02:00
#endif
#if ENABLED(ULTIPANEL)
2017-04-17 04:32:52 +02:00
#ifndef TALL_FONT_CORRECTION
#define TALL_FONT_CORRECTION 0
2016-06-11 23:12:00 +02:00
#endif
2017-04-17 04:32:52 +02:00
// Function pointer to menu functions.
typedef void (*screenFunc_t)();
typedef void (*menuAction_t)();
2016-06-11 23:12:00 +02:00
2017-04-17 04:32:52 +02:00
#if HAS_POWER_SWITCH
extern bool powersupply_on;
#endif
2016-06-11 23:12:00 +02:00
2017-04-17 04:32:52 +02:00
////////////////////////////////////////////
///////////////// Menu Tree ////////////////
////////////////////////////////////////////
2016-11-28 06:51:51 +01:00
void lcd_main_menu();
void lcd_tune_menu();
void lcd_prepare_menu();
void lcd_move_menu();
void lcd_control_menu();
void lcd_control_temperature_menu();
2016-11-28 07:39:06 +01:00
void lcd_control_temperature_preheat_material1_settings_menu();
void lcd_control_temperature_preheat_material2_settings_menu();
void lcd_control_motion_menu();
void lcd_control_filament_menu();
#if ENABLED(LCD_INFO_MENU)
#if ENABLED(PRINTCOUNTER)
void lcd_info_stats_menu();
#endif
void lcd_info_thermistors_menu();
void lcd_info_board_menu();
void lcd_info_menu();
#endif // LCD_INFO_MENU
#if ENABLED(ADVANCED_PAUSE_FEATURE)
void lcd_advanced_pause_toocold_menu();
void lcd_advanced_pause_option_menu();
void lcd_advanced_pause_init_message();
void lcd_advanced_pause_unload_message();
void lcd_advanced_pause_insert_message();
void lcd_advanced_pause_load_message();
void lcd_advanced_pause_heat_nozzle();
void lcd_advanced_pause_extrude_message();
void lcd_advanced_pause_resume_message();
#endif
2017-04-17 04:32:52 +02:00
#if ENABLED(DAC_STEPPER_CURRENT)
void dac_driver_commit();
void dac_driver_getValues();
void lcd_dac_menu();
void lcd_dac_write_eeprom();
#endif
#if ENABLED(FWRETRACT)
void lcd_control_retract_menu();
#endif
2017-11-08 09:43:29 +01:00
#if ENABLED(DELTA_CALIBRATION_MENU) || ENABLED(DELTA_AUTO_CALIBRATION)
void lcd_delta_calibrate_menu();
#endif
2017-04-17 04:32:52 +02:00
////////////////////////////////////////////
//////////// Menu System Actions ///////////
////////////////////////////////////////////
2016-06-11 23:12:00 +02:00
#define menu_action_back(dummy) _menu_action_back()
void _menu_action_back();
void menu_action_submenu(screenFunc_t data);
void menu_action_gcode(const char* pgcode);
void menu_action_function(menuAction_t data);
#define DECLARE_MENU_EDIT_TYPE(_type, _name) \
bool _menu_edit_ ## _name(); \
void menu_edit_ ## _name(); \
void menu_edit_callback_ ## _name(); \
void _menu_action_setting_edit_ ## _name(const char * const pstr, _type* const ptr, const _type minValue, const _type maxValue); \
void menu_action_setting_edit_ ## _name(const char * const pstr, _type * const ptr, const _type minValue, const _type maxValue); \
2017-05-21 02:54:23 +02:00
void menu_action_setting_edit_callback_ ## _name(const char * const pstr, _type * const ptr, const _type minValue, const _type maxValue, const screenFunc_t callback, const bool live=false); \
typedef void _name##_void
DECLARE_MENU_EDIT_TYPE(int16_t, int3);
DECLARE_MENU_EDIT_TYPE(uint8_t, int8);
DECLARE_MENU_EDIT_TYPE(float, float3);
DECLARE_MENU_EDIT_TYPE(float, float32);
DECLARE_MENU_EDIT_TYPE(float, float43);
DECLARE_MENU_EDIT_TYPE(float, float5);
DECLARE_MENU_EDIT_TYPE(float, float51);
DECLARE_MENU_EDIT_TYPE(float, float52);
DECLARE_MENU_EDIT_TYPE(float, float62);
DECLARE_MENU_EDIT_TYPE(uint32_t, long5);
2017-04-21 00:43:19 +02:00
void menu_action_setting_edit_bool(const char* pstr, bool* ptr);
void menu_action_setting_edit_callback_bool(const char* pstr, bool* ptr, screenFunc_t callbackFunc);
#if ENABLED(SDSUPPORT)
void lcd_sdcard_menu();
void menu_action_sdfile(const char* filename, char* longFilename);
void menu_action_sddirectory(const char* filename, char* longFilename);
#endif
2017-04-17 04:32:52 +02:00
////////////////////////////////////////////
//////////// Menu System Macros ////////////
////////////////////////////////////////////
#ifndef ENCODER_FEEDRATE_DEADZONE
2017-09-27 04:19:32 +02:00
#define ENCODER_FEEDRATE_DEADZONE 6
#endif
/**
* MENU_ITEM generates draw & handler code for a menu item, potentially calling:
*
* lcd_implementation_drawmenu_[type](sel, row, label, arg3...)
* menu_action_[type](arg3...)
*
* Examples:
* MENU_ITEM(back, MSG_WATCH, 0 [dummy parameter] )
* or
* MENU_BACK(MSG_WATCH)
* lcd_implementation_drawmenu_back(sel, row, PSTR(MSG_WATCH))
* menu_action_back()
*
* MENU_ITEM(function, MSG_PAUSE_PRINT, lcd_sdcard_pause)
* lcd_implementation_drawmenu_function(sel, row, PSTR(MSG_PAUSE_PRINT), lcd_sdcard_pause)
* menu_action_function(lcd_sdcard_pause)
*
2016-07-16 03:49:34 +02:00
* MENU_ITEM_EDIT(int3, MSG_SPEED, &feedrate_percentage, 10, 999)
* MENU_ITEM(setting_edit_int3, MSG_SPEED, PSTR(MSG_SPEED), &feedrate_percentage, 10, 999)
* lcd_implementation_drawmenu_setting_edit_int3(sel, row, PSTR(MSG_SPEED), PSTR(MSG_SPEED), &feedrate_percentage, 10, 999)
* menu_action_setting_edit_int3(PSTR(MSG_SPEED), &feedrate_percentage, 10, 999)
*
*/
2017-05-30 02:09:38 +02:00
#define _MENU_ITEM_PART_1(TYPE, ...) \
if (_menuLineNr == _thisItemNr) { \
if (lcd_clicked && encoderLine == _thisItemNr) {
2016-04-12 08:28:20 +02:00
2017-05-30 02:09:38 +02:00
#define _MENU_ITEM_PART_2(TYPE, LABEL, ...) \
menu_action_ ## TYPE(__VA_ARGS__); \
if (screen_changed) return; \
2015-02-20 11:17:16 +01:00
} \
2017-05-30 02:09:38 +02:00
if (lcdDrawUpdate) \
lcd_implementation_drawmenu_ ## TYPE(encoderLine == _thisItemNr, _lcdLineNr, PSTR(LABEL), ## __VA_ARGS__); \
2015-02-20 11:17:16 +01:00
} \
2016-08-03 02:39:20 +02:00
++_thisItemNr
2016-04-12 08:28:20 +02:00
#define MENU_ITEM(TYPE, LABEL, ...) do { \
2016-07-15 04:01:57 +02:00
_skipStatic = false; \
2017-05-30 02:09:38 +02:00
_MENU_ITEM_PART_1(TYPE, ## __VA_ARGS__); \
_MENU_ITEM_PART_2(TYPE, LABEL, ## __VA_ARGS__); \
2017-06-15 22:10:45 +02:00
}while(0)
#define MENU_BACK(LABEL) MENU_ITEM(back, LABEL, 0)
// Used to print static text with no visible cursor.
// Parameters: label [, bool center [, bool invert [, char *value] ] ]
#define STATIC_ITEM(LABEL, ...) \
if (_menuLineNr == _thisItemNr) { \
2016-07-15 04:01:57 +02:00
if (_skipStatic && encoderLine <= _thisItemNr) { \
encoderPosition += ENCODER_STEPS_PER_MENU_ITEM; \
++encoderLine; \
} \
if (lcdDrawUpdate) \
lcd_implementation_drawmenu_static(_lcdLineNr, PSTR(LABEL), ## __VA_ARGS__); \
} \
2016-08-03 02:39:20 +02:00
++_thisItemNr
#if ENABLED(ENCODER_RATE_MULTIPLIER)
2017-04-17 04:32:52 +02:00
bool encoderRateMultiplierEnabled;
#define ENCODER_RATE_MULTIPLY(F) (encoderRateMultiplierEnabled = F)
//#define ENCODER_RATE_MULTIPLIER_DEBUG // If defined, output the encoder steps per second value
/**
* MENU_MULTIPLIER_ITEM generates drawing and handling code for a multiplier menu item
*/
#define MENU_MULTIPLIER_ITEM(type, label, ...) do { \
2017-05-30 02:09:38 +02:00
_MENU_ITEM_PART_1(type, ## __VA_ARGS__); \
2016-04-12 08:28:20 +02:00
encoderRateMultiplierEnabled = true; \
lastEncoderMovementMillis = 0; \
2017-05-30 02:09:38 +02:00
_MENU_ITEM_PART_2(type, label, ## __VA_ARGS__); \
2017-06-15 22:10:45 +02:00
}while(0)
2016-04-12 08:28:20 +02:00
2017-05-09 19:35:43 +02:00
#else // !ENCODER_RATE_MULTIPLIER
2017-04-17 04:32:52 +02:00
#define ENCODER_RATE_MULTIPLY(F) NOOP
#endif // !ENCODER_RATE_MULTIPLIER
2017-06-15 22:10:45 +02:00
#define MENU_ITEM_DUMMY() do { _thisItemNr++; }while(0)
#define MENU_ITEM_EDIT(type, label, ...) MENU_ITEM(setting_edit_ ## type, label, PSTR(label), ## __VA_ARGS__)
#define MENU_ITEM_EDIT_CALLBACK(type, label, ...) MENU_ITEM(setting_edit_callback_ ## type, label, PSTR(label), ## __VA_ARGS__)
#if ENABLED(ENCODER_RATE_MULTIPLIER)
#define MENU_MULTIPLIER_ITEM_EDIT(type, label, ...) MENU_MULTIPLIER_ITEM(setting_edit_ ## type, label, PSTR(label), ## __VA_ARGS__)
#define MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(type, label, ...) MENU_MULTIPLIER_ITEM(setting_edit_callback_ ## type, label, PSTR(label), ## __VA_ARGS__)
2017-05-09 19:35:43 +02:00
#else // !ENCODER_RATE_MULTIPLIER
#define MENU_MULTIPLIER_ITEM_EDIT(type, label, ...) MENU_ITEM(setting_edit_ ## type, label, PSTR(label), ## __VA_ARGS__)
#define MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(type, label, ...) MENU_ITEM(setting_edit_callback_ ## type, label, PSTR(label), ## __VA_ARGS__)
2017-05-09 19:35:43 +02:00
#endif // !ENCODER_RATE_MULTIPLIER
2017-04-17 04:32:52 +02:00
/**
* START_SCREEN_OR_MENU generates init code for a screen or menu
*
* encoderLine is the position based on the encoder
* encoderTopLine is the top menu line to display
* _lcdLineNr is the index of the LCD line (e.g., 0-3)
* _menuLineNr is the menu item to draw and process
* _thisItemNr is the index of each MENU_ITEM or STATIC_ITEM
* _countedItems is the total number of items in the menu (after one call)
*/
#define START_SCREEN_OR_MENU(LIMIT) \
ENCODER_DIRECTION_MENUS(); \
ENCODER_RATE_MULTIPLY(false); \
if (encoderPosition > 0x8000) encoderPosition = 0; \
static int8_t _countedItems = 0; \
int8_t encoderLine = encoderPosition / (ENCODER_STEPS_PER_MENU_ITEM); \
if (_countedItems > 0 && encoderLine >= _countedItems - (LIMIT)) { \
encoderLine = max(0, _countedItems - (LIMIT)); \
encoderPosition = encoderLine * (ENCODER_STEPS_PER_MENU_ITEM); \
}
2017-04-17 04:32:52 +02:00
#define SCREEN_OR_MENU_LOOP() \
int8_t _menuLineNr = encoderTopLine, _thisItemNr; \
for (int8_t _lcdLineNr = 0; _lcdLineNr < LCD_HEIGHT - (TALL_FONT_CORRECTION); _lcdLineNr++, _menuLineNr++) { \
_thisItemNr = 0
/**
* START_SCREEN Opening code for a screen having only static items.
* Do simplified scrolling of the entire screen.
*
* START_MENU Opening code for a screen with menu items.
* Scroll as-needed to keep the selected line in view.
*/
#define START_SCREEN() \
START_SCREEN_OR_MENU(LCD_HEIGHT - (TALL_FONT_CORRECTION)); \
encoderTopLine = encoderLine; \
bool _skipStatic = false; \
SCREEN_OR_MENU_LOOP()
#define START_MENU() \
START_SCREEN_OR_MENU(1); \
screen_changed = false; \
NOMORE(encoderTopLine, encoderLine); \
if (encoderLine >= encoderTopLine + LCD_HEIGHT - (TALL_FONT_CORRECTION)) { \
encoderTopLine = encoderLine - (LCD_HEIGHT - (TALL_FONT_CORRECTION) - 1); \
} \
bool _skipStatic = true; \
SCREEN_OR_MENU_LOOP()
#define END_SCREEN() \
} \
_countedItems = _thisItemNr
#define END_MENU() \
} \
_countedItems = _thisItemNr; \
UNUSED(_skipStatic)
////////////////////////////////////////////
///////////// Global Variables /////////////
////////////////////////////////////////////
/**
* REVERSE_MENU_DIRECTION
*
* To reverse the menu direction we need a general way to reverse
* the direction of the encoder everywhere. So encoderDirection is
* added to allow the encoder to go the other way.
*
* This behavior is limited to scrolling Menus and SD card listings,
* and is disabled in other contexts.
*/
#if ENABLED(REVERSE_MENU_DIRECTION)
int8_t encoderDirection = 1;
#define ENCODER_DIRECTION_NORMAL() (encoderDirection = 1)
#define ENCODER_DIRECTION_MENUS() (encoderDirection = -1)
#else
#define ENCODER_DIRECTION_NORMAL() ;
#define ENCODER_DIRECTION_MENUS() ;
#endif
2017-04-17 04:32:52 +02:00
// Encoder Movement
volatile int8_t encoderDiff; // Updated in lcd_buttons_update, added to encoderPosition every LCD update
uint32_t encoderPosition;
2017-04-17 04:32:52 +02:00
millis_t lastEncoderMovementMillis = 0;
// Button States
bool lcd_clicked, wait_for_unclick;
volatile uint8_t buttons;
millis_t next_button_update_ms;
#if ENABLED(REPRAPWORLD_KEYPAD)
volatile uint8_t buttons_reprapworld_keypad;
#endif
#if ENABLED(LCD_HAS_SLOW_BUTTONS)
volatile uint8_t slow_buttons;
#endif
2017-04-17 04:32:52 +02:00
// Menu System Navigation
screenFunc_t currentScreen = lcd_status_screen;
int8_t encoderTopLine;
2016-06-11 23:12:00 +02:00
typedef struct {
2016-06-11 23:19:17 +02:00
screenFunc_t menu_function;
uint32_t encoder_position;
2016-06-11 23:12:00 +02:00
} menuPosition;
2017-04-17 04:32:52 +02:00
menuPosition screen_history[6];
uint8_t screen_history_depth = 0;
bool screen_changed, defer_return_to_status;
2017-04-17 04:32:52 +02:00
// Value Editing
const char *editLabel;
void *editValue;
2017-04-17 04:32:52 +02:00
int32_t minEditValue, maxEditValue;
screenFunc_t callbackFunc;
2017-05-21 02:54:23 +02:00
bool liveEdit;
2017-04-17 04:32:52 +02:00
// Manual Moves
const float manual_feedrate_mm_m[] = MANUAL_FEEDRATE;
millis_t manual_move_start_time = 0;
int8_t manual_move_axis = (int8_t)NO_AXIS;
#if EXTRUDERS > 1
int8_t manual_move_e_index = 0;
#else
#define manual_move_e_index 0
#endif
2016-04-03 01:09:56 +02:00
2017-10-10 02:54:15 +02:00
#if IS_KINEMATIC
bool processing_manual_move = false;
float manual_move_offset = 0.0;
#else
constexpr bool processing_manual_move = false;
#endif
2017-04-17 04:32:52 +02:00
#if PIN_EXISTS(SD_DETECT)
uint8_t lcd_sd_status;
#endif
2016-04-03 01:09:56 +02:00
2017-04-17 04:32:52 +02:00
#if ENABLED(PIDTEMP)
float raw_Ki, raw_Kd; // place-holders for Ki and Kd edits
#endif
2016-06-11 23:12:00 +02:00
/**
* General function to go directly to a screen
2016-06-11 23:12:00 +02:00
*/
void lcd_goto_screen(screenFunc_t screen, const uint32_t encoder = 0) {
2016-06-11 23:19:17 +02:00
if (currentScreen != screen) {
2017-03-03 02:15:21 +01:00
#if ENABLED(DOUBLECLICK_FOR_Z_BABYSTEPPING) && ENABLED(BABYSTEPPING)
static millis_t doubleclick_expire_ms = 0;
// Going to lcd_main_menu from status screen? Remember first click time.
// Going back to status screen within a very short time? Go to Z babystepping.
if (screen == lcd_main_menu) {
if (currentScreen == lcd_status_screen)
doubleclick_expire_ms = millis() + DOUBLECLICK_MAX_INTERVAL;
}
else if (screen == lcd_status_screen && currentScreen == lcd_main_menu && PENDING(millis(), doubleclick_expire_ms))
screen =
#if ENABLED(BABYSTEP_ZPROBE_OFFSET)
lcd_babystep_zoffset
#else
lcd_babystep_z
#endif
;
2017-03-17 03:25:36 +01:00
#endif
2017-03-03 02:15:21 +01:00
2016-06-11 23:19:17 +02:00
currentScreen = screen;
encoderPosition = encoder;
2016-06-11 23:19:17 +02:00
if (screen == lcd_status_screen) {
2016-06-11 23:12:00 +02:00
defer_return_to_status = false;
#if ENABLED(AUTO_BED_LEVELING_UBL)
ubl.lcd_map_control = false;
#endif
2016-06-11 23:19:17 +02:00
screen_history_depth = 0;
2016-06-11 23:12:00 +02:00
}
lcd_implementation_clear();
2017-07-02 01:33:54 +02:00
// Re-initialize custom characters that may be re-used
#if DISABLED(DOGLCD) && ENABLED(AUTO_BED_LEVELING_UBL)
if (!ubl.lcd_map_control) {
2017-11-23 00:44:56 +01:00
lcd_set_custom_characters(
#if ENABLED(LCD_PROGRESS_BAR)
screen == lcd_status_screen ? CHARSET_INFO : CHARSET_MENU
#endif
);
}
2017-07-02 01:33:54 +02:00
#elif ENABLED(LCD_PROGRESS_BAR)
2017-11-23 00:44:56 +01:00
lcd_set_custom_characters(screen == lcd_status_screen ? CHARSET_INFO : CHARSET_MENU);
2016-06-11 23:12:00 +02:00
#endif
2017-05-25 22:29:14 +02:00
lcdDrawUpdate = LCDVIEW_CALL_REDRAW_NEXT;
screen_changed = true;
Distribute GLCD screen updates in time Currently we draw and send the screens for a graphical LCD all at once. We draw in two or four parts but draw them directly behind each other. For the tested status screen this takes 59-62ms in a single block. During this time nothing else (except the interrupts) can be done. When printing a sequence of very short moves the buffer drains - sometimes until it's empty. This PR splits the screen update into parts. Currently we have 10 time slots. During the first one the complete screen is drawn. (60,0,0,0,0,0,0,0,0,0,0) Here i introduce pauses for doing other things. (30,30,0,0,0,0,0,0) or (15,15,15,15,0,0,0,0,0,0) Drawing in consecutive time slots prevents from lagging too much. Even with a 4 stripe display all the drawing is done after 400ms. Previous experiments with a even better distribution of the time slots like (30,0,0,0,0,30,0,0,0,0) and (15,0,15,0,15,0,15,0,0,0) did not feel good when using the menu, because of too much lag. Because of the previous PRs to speed up the display updates and especially reducing the difference between drawing 2 or 4 stripes, it now makes sense for the REPRAP_DISCOUNT_FULL_GRAPHIC_SMART_CONTROLLER to go from 2 to 4 stripes. This costs about 1-2ms per complete screen update, but is payed back by having partial updates lasting only the half time and two additional brakes. Also ~256 byte of framebuffer are saved in RAM. 13:45:59.213 : echo: #:17 >:13 s:30; #:16 >:13 s:29; S#:33 S>:26 S:59 13:46:00.213 : echo: #:16 >:14 s:30; #:17 >:13 s:30; S#:33 S>:27 S:60 13:46:01.215 : echo: #:17 >:13 s:30; #:16 >:13 s:29; S#:33 S>:26 S:59 13:46:02.215 : echo: #:16 >:13 s:29; #:16 >:14 s:30; S#:32 S>:27 S:59 13:46:03.214 : echo: #:17 >:13 s:30; #:17 >:13 s:30; S#:34 S>:26 S:60 13:46:04.214 : echo: #:16 >:13 s:29; #:16 >:14 s:30; S#:32 S>:27 S:59 13:46:05.212 : echo: #:16 >:14 s:30; #:17 >:13 s:30; S#:33 S>:27 S:60 13:46:06.212 : echo: #:17 >:13 s:30; #:16 >:13 s:29; S#:33 S>:26 S:59 03:30:36.779 : echo: #:8 >:7 s:15; #:10 >:7 s:17; #:8 >:6 s:14; #:8 >:7 s:15; S#:34 S>:27 S:61 03:30:37.778 : echo: #:8 >:6 s:14; #:10 >:7 s:17; #:9 >:7 s:16; #:8 >:6 s:14; S#:35 S>:26 S:61 03:30:38.778 : echo: #:8 >:6 s:14; #:11 >:7 s:18; #:8 >:6 s:14; #:8 >:7 s:15; S#:35 S>:26 S:61 03:30:39.777 : echo: #:8 >:6 s:14; #:10 >:7 s:17; #:8 >:8 s:16; #:8 >:6 s:14; S#:34 S>:27 S:61 03:30:40.780 : echo: #:8 >:6 s:14; #:11 >:7 s:18; #:8 >:6 s:14; #:8 >:6 s:14; S#:35 S>:25 S:60 03:30:41.780 : echo: #:9 >:6 s:15; #:10 >:7 s:17; #:8 >:6 s:14; #:9 >:6 s:15; S#:36 S>:25 S:61 03:30:42.779 : echo: #:8 >:6 s:14; #:10 >:8 s:18; #:8 >:6 s:14; #:8 >:6 s:14; S#:34 S>:26 S:60 03:30:43.778 : echo: #:9 >:6 s:15; #:10 >:7 s:17; #:8 >:7 s:15; #:9 >:6 s:15; S#:36 S>:26 S:62 #: draw a stripe >: transfer a stripe s: sum of of draw and transfer for one stripe S#: sum of draws for a complete screen S>: sum of transfers for a complete screen S: time to draw and transfer a complete screen
2016-11-24 21:17:25 +01:00
#if ENABLED(DOGLCD)
drawing_screen = false;
#endif
2016-06-11 23:12:00 +02:00
}
}
/**
2017-05-25 22:13:57 +02:00
* Show "Moving..." till moves are done, then revert to previous display.
*/
2017-05-29 19:19:02 +02:00
static const char moving[] PROGMEM = MSG_MOVING;
static const char *sync_message = moving;
2017-05-29 23:01:17 +02:00
//
// Display the synchronize screen until moves are
// finished, and don't return to the caller until
// done. ** This blocks the command queue! **
//
2017-05-29 19:19:02 +02:00
void _lcd_synchronize() {
2017-04-11 02:17:14 +02:00
static bool no_reentry = false;
2017-05-29 19:19:02 +02:00
if (lcdDrawUpdate) lcd_implementation_drawmenu_static(LCD_HEIGHT >= 4 ? 1 : 0, sync_message);
2017-04-11 02:17:14 +02:00
if (no_reentry) return;
2017-05-25 22:13:57 +02:00
// Make this the current handler till all moves are done
2017-04-11 02:17:14 +02:00
no_reentry = true;
screenFunc_t old_screen = currentScreen;
2017-05-29 19:19:02 +02:00
lcd_goto_screen(_lcd_synchronize);
2017-05-25 22:13:57 +02:00
stepper.synchronize();
2017-04-11 02:17:14 +02:00
no_reentry = false;
lcd_goto_screen(old_screen);
}
2017-05-29 23:01:17 +02:00
// Display the synchronize screen with a custom message
// ** This blocks the command queue! **
2017-05-29 19:19:02 +02:00
void lcd_synchronize(const char * const msg=NULL) {
sync_message = msg ? msg : moving;
_lcd_synchronize();
}
void lcd_return_to_status() { lcd_goto_screen(lcd_status_screen); }
void lcd_save_previous_screen() {
2016-06-11 23:19:17 +02:00
if (screen_history_depth < COUNT(screen_history)) {
screen_history[screen_history_depth].menu_function = currentScreen;
screen_history[screen_history_depth].encoder_position = encoderPosition;
2016-06-11 23:19:17 +02:00
++screen_history_depth;
}
2014-12-18 16:30:05 +01:00
}
void lcd_goto_previous_menu() {
2016-06-11 23:19:17 +02:00
if (screen_history_depth > 0) {
--screen_history_depth;
lcd_goto_screen(
screen_history[screen_history_depth].menu_function,
screen_history[screen_history_depth].encoder_position
2016-06-11 23:12:00 +02:00
);
}
else
lcd_return_to_status();
}
2017-08-16 09:27:50 +02:00
void lcd_goto_previous_menu_no_defer() {
defer_return_to_status = false;
lcd_goto_previous_menu();
}
2016-06-11 23:12:00 +02:00
#endif // ULTIPANEL
/**
*
* "Info Screen"
*
* This is very display-dependent, so the lcd implementation draws this.
*/
void lcd_status_screen() {
2016-06-11 23:12:00 +02:00
#if ENABLED(ULTIPANEL)
ENCODER_DIRECTION_NORMAL();
2017-04-17 04:32:52 +02:00
ENCODER_RATE_MULTIPLY(false);
2016-06-11 23:12:00 +02:00
#endif
#if ENABLED(LCD_PROGRESS_BAR)
2017-10-15 08:40:34 +02:00
//
// HD44780 implements the following message blinking and
// message expiration because Status Line and Progress Bar
// share the same line on the display.
//
// Set current percentage from SD when actively printing
#if ENABLED(LCD_SET_PROGRESS_MANUALLY)
if (IS_SD_PRINTING)
progress_bar_percent = card.percentDone();
#endif
2015-04-13 03:07:08 +02:00
millis_t ms = millis();
2017-10-15 08:40:34 +02:00
// If the message will blink rather than expire...
#if DISABLED(PROGRESS_MSG_ONCE)
2017-10-15 08:40:34 +02:00
if (ELAPSED(ms, progress_bar_ms + PROGRESS_BAR_MSG_TIME + PROGRESS_BAR_BAR_TIME))
progress_bar_ms = ms;
2014-12-28 07:26:14 +01:00
#endif
2017-10-15 08:40:34 +02:00
2014-12-28 07:26:14 +01:00
#if PROGRESS_MSG_EXPIRE > 0
2017-10-15 08:40:34 +02:00
// Handle message expire
if (expire_status_ms > 0) {
2017-10-15 08:40:34 +02:00
#if DISABLED(LCD_SET_PROGRESS_MANUALLY)
const uint8_t progress_bar_percent = card.percentDone();
#endif
// Expire the message if a job is active and the bar has ticks
if (progress_bar_percent > 2 && !print_job_timer.isPaused()) {
if (ELAPSED(ms, expire_status_ms)) {
lcd_status_message[0] = '\0';
expire_status_ms = 0;
2014-12-28 07:26:14 +01:00
}
2017-10-15 08:40:34 +02:00
}
else {
// Defer message expiration before bar appears
// and during any pause (not just SD)
expire_status_ms += LCD_UPDATE_INTERVAL;
}
2014-12-28 07:26:14 +01:00
}
2017-10-15 08:40:34 +02:00
#endif // PROGRESS_MSG_EXPIRE
2017-05-09 19:35:43 +02:00
#endif // LCD_PROGRESS_BAR
2014-12-28 07:26:14 +01:00
#if ENABLED(ULTIPANEL)
if (lcd_clicked) {
#if ENABLED(FILAMENT_LCD_DISPLAY) && ENABLED(SDSUPPORT)
2016-08-07 01:24:26 +02:00
previous_lcd_status_ms = millis(); // get status message to show up for a while
#endif
lcd_implementation_init( // to maybe revive the LCD if static electricity killed it.
#if ENABLED(LCD_PROGRESS_BAR)
2017-11-23 00:44:56 +01:00
CHARSET_MENU
2014-12-28 07:26:14 +01:00
#endif
);
lcd_goto_screen(lcd_main_menu);
2017-05-30 02:09:38 +02:00
return;
}
#if ENABLED(ULTIPANEL_FEEDMULTIPLY)
const int16_t new_frm = feedrate_percentage + (int32_t)encoderPosition;
// Dead zone at 100% feedrate
2016-07-16 03:49:34 +02:00
if ((feedrate_percentage < 100 && new_frm > 100) || (feedrate_percentage > 100 && new_frm < 100)) {
feedrate_percentage = 100;
2016-04-05 23:06:52 +02:00
encoderPosition = 0;
}
2016-07-16 03:49:34 +02:00
else if (feedrate_percentage == 100) {
if ((int32_t)encoderPosition > ENCODER_FEEDRATE_DEADZONE) {
2016-07-16 03:49:34 +02:00
feedrate_percentage += (int32_t)encoderPosition - (ENCODER_FEEDRATE_DEADZONE);
2015-04-11 13:56:08 +02:00
encoderPosition = 0;
}
else if ((int32_t)encoderPosition < -(ENCODER_FEEDRATE_DEADZONE)) {
2016-07-16 03:49:34 +02:00
feedrate_percentage += (int32_t)encoderPosition + ENCODER_FEEDRATE_DEADZONE;
2015-04-11 13:56:08 +02:00
encoderPosition = 0;
}
}
2015-04-11 13:56:08 +02:00
else {
2016-07-16 03:49:34 +02:00
feedrate_percentage = new_frm;
encoderPosition = 0;
}
#endif // ULTIPANEL_FEEDMULTIPLY
2016-07-16 03:49:34 +02:00
feedrate_percentage = constrain(feedrate_percentage, 10, 999);
2017-05-09 19:35:43 +02:00
#endif // ULTIPANEL
2017-05-30 02:09:38 +02:00
lcd_implementation_status_screen();
}
void lcd_reset_status() { lcd_setstatusPGM(PSTR(""), -1); }
2016-07-10 04:50:45 +02:00
/**
*
* draw the kill screen
*
*/
void kill_screen(const char* lcd_msg) {
lcd_init();
lcd_setalertstatusPGM(lcd_msg);
lcd_kill_screen();
2016-07-10 04:50:45 +02:00
}
#if ENABLED(ULTIPANEL)
2014-12-28 07:26:14 +01:00
/**
*
* Audio feedback for controller clicks
*
*/
void lcd_buzz(long duration, 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
}
void lcd_quick_feedback() {
lcdDrawUpdate = LCDVIEW_CLEAR_CALL_REDRAW;
buttons = 0;
next_button_update_ms = millis() + 500;
// Buzz and wait. The delay is needed for buttons to settle!
lcd_buzz(LCD_FEEDBACK_FREQUENCY_DURATION_MS, LCD_FEEDBACK_FREQUENCY_HZ);
#if ENABLED(LCD_USE_I2C_BUZZER)
delay(10);
#elif PIN_EXISTS(BEEPER)
for (int8_t i = 5; i--;) { buzzer.tick(); delay(2); }
#endif
}
void lcd_completion_feedback(const bool good/*=true*/) {
if (good) {
lcd_buzz(100, 659);
lcd_buzz(100, 698);
}
else lcd_buzz(20, 440);
}
inline void line_to_current_z() {
planner.buffer_line_kinematic(current_position, MMM_TO_MMS(manual_feedrate_mm_m[Z_AXIS]), active_extruder);
}
inline void line_to_z(const float &z) {
current_position[Z_AXIS] = z;
line_to_current_z();
}
2016-06-11 23:12:00 +02:00
#if ENABLED(SDSUPPORT)
void lcd_sdcard_pause() {
2016-06-11 23:12:00 +02:00
card.pauseSDPrint();
print_job_timer.pause();
2017-03-19 10:26:22 +01:00
#if ENABLED(PARK_HEAD_ON_PAUSE)
enqueue_and_echo_commands_P(PSTR("M125"));
2017-03-19 10:26:22 +01:00
#endif
lcd_setstatusPGM(PSTR(MSG_PRINT_PAUSED), -1);
2016-06-11 23:12:00 +02:00
}
void lcd_sdcard_resume() {
2017-03-19 10:26:22 +01:00
#if ENABLED(PARK_HEAD_ON_PAUSE)
enqueue_and_echo_commands_P(PSTR("M24"));
2017-03-19 10:26:22 +01:00
#else
card.startFileprint();
print_job_timer.start();
#endif
lcd_reset_status();
2016-06-11 23:12:00 +02:00
}
void lcd_sdcard_stop() {
card.stopSDPrint();
2016-06-11 23:12:00 +02:00
clear_command_queue();
quickstop_stepper();
2016-06-11 23:12:00 +02:00
print_job_timer.stop();
thermalManager.disable_all_heaters();
#if FAN_COUNT > 0
for (uint8_t i = 0; i < FAN_COUNT; i++) fanSpeeds[i] = 0;
2016-10-10 22:34:35 +02:00
#endif
wait_for_heatup = false;
2017-05-30 02:50:53 +02:00
lcd_setstatusPGM(PSTR(MSG_PRINT_ABORTED), -1);
lcd_return_to_status();
2016-06-11 23:12:00 +02:00
}
2017-03-19 10:26:22 +01:00
#endif // SDSUPPORT
#if ENABLED(MENU_ITEM_CASE_LIGHT)
2017-09-24 01:45:13 +02:00
extern uint8_t case_light_brightness;
extern bool case_light_on;
extern void update_case_light();
void case_light_menu() {
START_MENU();
//
// ^ Main
//
MENU_BACK(MSG_MAIN);
2017-09-24 01:45:13 +02:00
MENU_ITEM_EDIT_CALLBACK(int8, MSG_CASE_LIGHT_BRIGHTNESS, &case_light_brightness, 0, 255, update_case_light, true);
MENU_ITEM_EDIT_CALLBACK(bool, MSG_CASE_LIGHT, (bool*)&case_light_on, update_case_light);
END_MENU();
}
#endif // MENU_ITEM_CASE_LIGHT
#if ENABLED(BLTOUCH)
/**
*
* "BLTouch" submenu
*
*/
static void bltouch_menu() {
START_MENU();
//
// ^ Main
//
MENU_BACK(MSG_MAIN);
MENU_ITEM(gcode, MSG_BLTOUCH_RESET, PSTR("M280 P" STRINGIFY(Z_ENDSTOP_SERVO_NR) " S" STRINGIFY(BLTOUCH_RESET)));
MENU_ITEM(gcode, MSG_BLTOUCH_SELFTEST, PSTR("M280 P" STRINGIFY(Z_ENDSTOP_SERVO_NR) " S" STRINGIFY(BLTOUCH_SELFTEST)));
MENU_ITEM(gcode, MSG_BLTOUCH_DEPLOY, PSTR("M280 P" STRINGIFY(Z_ENDSTOP_SERVO_NR) " S" STRINGIFY(BLTOUCH_DEPLOY)));
MENU_ITEM(gcode, MSG_BLTOUCH_STOW, PSTR("M280 P" STRINGIFY(Z_ENDSTOP_SERVO_NR) " S" STRINGIFY(BLTOUCH_STOW)));
END_MENU();
}
#endif // BLTOUCH
#if ENABLED(LCD_PROGRESS_BAR_TEST)
static void progress_bar_test() {
static int8_t bar_percent = 0;
if (lcd_clicked) {
lcd_goto_previous_menu();
2017-11-23 00:44:56 +01:00
lcd_set_custom_characters(CHARSET_MENU);
return;
}
bar_percent += (int8_t)encoderPosition;
bar_percent = constrain(bar_percent, 0, 100);
encoderPosition = 0;
lcd_implementation_drawmenu_static(0, PSTR(MSG_PROGRESS_BAR_TEST), true, true);
lcd.setCursor((LCD_WIDTH) / 2 - 2, LCD_HEIGHT - 2);
2017-06-28 05:19:32 +02:00
lcd.print(itostr3(bar_percent)); lcd.write('%');
lcd.setCursor(0, LCD_HEIGHT - 1); lcd_draw_progress_bar(bar_percent);
}
void _progress_bar_test() {
lcd_goto_screen(progress_bar_test);
lcd_set_custom_characters();
}
#endif // LCD_PROGRESS_BAR_TEST
#if HAS_DEBUG_MENU
void lcd_debug_menu() {
START_MENU();
MENU_BACK(MSG_MAIN); // ^ Main
#if ENABLED(LCD_PROGRESS_BAR_TEST)
MENU_ITEM(submenu, MSG_PROGRESS_BAR_TEST, _progress_bar_test);
#endif
END_MENU();
}
#endif // HAS_DEBUG_MENU
#if ENABLED(CUSTOM_USER_MENUS)
#ifdef USER_SCRIPT_DONE
#define _DONE_SCRIPT "\n" USER_SCRIPT_DONE
#else
#define _DONE_SCRIPT ""
#endif
void _lcd_user_gcode(const char * const cmd) {
enqueue_and_echo_commands_P(cmd);
#if ENABLED(USER_SCRIPT_AUDIBLE_FEEDBACK)
lcd_completion_feedback();
#endif
#if ENABLED(USER_SCRIPT_RETURN)
lcd_return_to_status();
#endif
}
#if defined(USER_DESC_1) && defined(USER_GCODE_1)
void lcd_user_gcode_1() { _lcd_user_gcode(PSTR(USER_GCODE_1 _DONE_SCRIPT)); }
#endif
#if defined(USER_DESC_2) && defined(USER_GCODE_2)
void lcd_user_gcode_2() { _lcd_user_gcode(PSTR(USER_GCODE_2 _DONE_SCRIPT)); }
#endif
#if defined(USER_DESC_3) && defined(USER_GCODE_3)
void lcd_user_gcode_3() { _lcd_user_gcode(PSTR(USER_GCODE_3 _DONE_SCRIPT)); }
#endif
#if defined(USER_DESC_4) && defined(USER_GCODE_4)
void lcd_user_gcode_4() { _lcd_user_gcode(PSTR(USER_GCODE_4 _DONE_SCRIPT)); }
#endif
#if defined(USER_DESC_5) && defined(USER_GCODE_5)
void lcd_user_gcode_5() { _lcd_user_gcode(PSTR(USER_GCODE_5 _DONE_SCRIPT)); }
#endif
void _lcd_user_menu() {
START_MENU();
MENU_BACK(MSG_MAIN);
#if defined(USER_DESC_1) && defined(USER_GCODE_1)
MENU_ITEM(function, USER_DESC_1, lcd_user_gcode_1);
#endif
#if defined(USER_DESC_2) && defined(USER_GCODE_2)
MENU_ITEM(function, USER_DESC_2, lcd_user_gcode_2);
#endif
#if defined(USER_DESC_3) && defined(USER_GCODE_3)
MENU_ITEM(function, USER_DESC_3, lcd_user_gcode_3);
#endif
#if defined(USER_DESC_4) && defined(USER_GCODE_4)
MENU_ITEM(function, USER_DESC_4, lcd_user_gcode_4);
#endif
#if defined(USER_DESC_5) && defined(USER_GCODE_5)
MENU_ITEM(function, USER_DESC_5, lcd_user_gcode_5);
#endif
END_MENU();
}
#endif
2016-06-11 23:12:00 +02:00
/**
*
* "Main" menu
*
*/
void lcd_main_menu() {
2016-06-11 23:12:00 +02:00
START_MENU();
MENU_BACK(MSG_WATCH);
2016-09-19 01:02:53 +02:00
#if ENABLED(CUSTOM_USER_MENUS)
MENU_ITEM(submenu, MSG_USER_MENU, _lcd_user_menu);
#endif
//
// Debug Menu when certain options are enabled
//
#if HAS_DEBUG_MENU
MENU_ITEM(submenu, MSG_DEBUG_MENU, lcd_debug_menu);
#endif
2016-11-19 11:17:39 +01:00
//
// Set Case light on/off/brightness
2016-11-19 11:17:39 +01:00
//
2016-12-02 06:31:03 +01:00
#if ENABLED(MENU_ITEM_CASE_LIGHT)
if (USEABLE_HARDWARE_PWM(CASE_LIGHT_PIN)) {
MENU_ITEM(submenu, MSG_CASE_LIGHT, case_light_menu);
}
else
MENU_ITEM_EDIT_CALLBACK(bool, MSG_CASE_LIGHT, (bool*)&case_light_on, update_case_light);
2016-11-19 11:17:39 +01:00
#endif
2016-06-11 23:12:00 +02:00
if (planner.movesplanned() || IS_SD_PRINTING) {
MENU_ITEM(submenu, MSG_TUNE, lcd_tune_menu);
}
else {
MENU_ITEM(submenu, MSG_PREPARE, lcd_prepare_menu);
}
MENU_ITEM(submenu, MSG_CONTROL, lcd_control_menu);
#if ENABLED(SDSUPPORT)
if (card.cardOK) {
if (card.isFileOpen()) {
if (card.sdprinting)
MENU_ITEM(function, MSG_PAUSE_PRINT, lcd_sdcard_pause);
else
MENU_ITEM(function, MSG_RESUME_PRINT, lcd_sdcard_resume);
MENU_ITEM(function, MSG_STOP_PRINT, lcd_sdcard_stop);
}
else {
MENU_ITEM(submenu, MSG_CARD_MENU, lcd_sdcard_menu);
#if !PIN_EXISTS(SD_DETECT)
MENU_ITEM(gcode, MSG_CNG_SDCARD, PSTR("M21")); // SD-card changed by user
#endif
}
}
else {
2016-06-11 23:12:00 +02:00
MENU_ITEM(submenu, MSG_NO_CARD, lcd_sdcard_menu);
#if !PIN_EXISTS(SD_DETECT)
2016-06-11 23:12:00 +02:00
MENU_ITEM(gcode, MSG_INIT_SDCARD, PSTR("M21")); // Manually initialize the SD-card via user interface
#endif
}
2017-05-09 19:35:43 +02:00
#endif // SDSUPPORT
#if ENABLED(LCD_INFO_MENU)
MENU_ITEM(submenu, MSG_INFO_MENU, lcd_info_menu);
#endif
2016-06-11 23:12:00 +02:00
END_MENU();
2014-12-18 16:30:05 +01:00
}
2016-06-11 23:12:00 +02:00
/**
*
* "Tune" submenu items
*
*/
#if HAS_M206_COMMAND
2017-03-06 09:20:31 +01:00
/**
* Set the home offset based on the current_position
*/
void lcd_set_home_offsets() {
// M428 Command
enqueue_and_echo_commands_P(PSTR("M428"));
lcd_return_to_status();
}
#endif
2017-11-24 20:39:41 +01:00
#if ENABLED(BABYSTEP_ZPROBE_GFX_OVERLAY) || ENABLED(MESH_EDIT_GFX_OVERLAY)
void _lcd_zoffset_overlay_gfx(const float zvalue) {
// Determine whether the user is raising or lowering the nozzle.
static int8_t dir;
static float old_zvalue;
if (zvalue != old_zvalue) {
dir = zvalue ? zvalue < old_zvalue ? -1 : 1 : 0;
old_zvalue = zvalue;
}
#if ENABLED(OVERLAY_GFX_REVERSE)
const unsigned char *rot_up = ccw_bmp, *rot_down = cw_bmp;
#else
const unsigned char *rot_up = cw_bmp, *rot_down = ccw_bmp;
#endif
#if ENABLED(USE_BIG_EDIT_FONT)
const int left = 0, right = 45, nozzle = 95;
#else
const int left = 5, right = 90, nozzle = 60;
#endif
// Draw a representation of the nozzle
if (PAGE_CONTAINS(3, 16)) u8g.drawBitmapP(nozzle + 6, 4 - dir, 2, 12, nozzle_bmp);
if (PAGE_CONTAINS(20, 20)) u8g.drawBitmapP(nozzle + 0, 20, 3, 1, offset_bedline_bmp);
// Draw cw/ccw indicator and up/down arrows.
if (PAGE_CONTAINS(47, 62)) {
u8g.drawBitmapP(left + 0, 47, 3, 16, rot_down);
u8g.drawBitmapP(right + 0, 47, 3, 16, rot_up);
u8g.drawBitmapP(right + 20, 48 - dir, 2, 13, up_arrow_bmp);
u8g.drawBitmapP(left + 20, 49 - dir, 2, 13, down_arrow_bmp);
}
}
#endif // BABYSTEP_ZPROBE_GFX_OVERLAY || MESH_EDIT_GFX_OVERLAY
2016-06-11 23:12:00 +02:00
#if ENABLED(BABYSTEPPING)
void _lcd_babystep(const AxisEnum axis, const char* msg) {
2017-08-16 09:27:50 +02:00
if (lcd_clicked) { return lcd_goto_previous_menu_no_defer(); }
2016-06-11 23:12:00 +02:00
ENCODER_DIRECTION_NORMAL();
if (encoderPosition) {
const int16_t babystep_increment = (int32_t)encoderPosition * (BABYSTEP_MULTIPLICATOR);
2016-06-11 23:12:00 +02:00
encoderPosition = 0;
2017-05-25 22:13:57 +02:00
lcdDrawUpdate = LCDVIEW_REDRAW_NOW;
thermalManager.babystep_axis(axis, babystep_increment);
babysteps_done += babystep_increment;
2016-06-11 23:12:00 +02:00
}
if (lcdDrawUpdate)
lcd_implementation_drawedit(msg, ftostr43sign(planner.steps_to_mm[axis] * babysteps_done));
2016-06-11 23:12:00 +02:00
}
2016-06-11 23:12:00 +02:00
#if ENABLED(BABYSTEP_XY)
2017-09-27 04:21:10 +02:00
void _lcd_babystep_x() { _lcd_babystep(X_AXIS, PSTR(MSG_BABYSTEP_X)); }
void _lcd_babystep_y() { _lcd_babystep(Y_AXIS, PSTR(MSG_BABYSTEP_Y)); }
void lcd_babystep_x() { lcd_goto_screen(_lcd_babystep_x); babysteps_done = 0; defer_return_to_status = true; }
void lcd_babystep_y() { lcd_goto_screen(_lcd_babystep_y); babysteps_done = 0; defer_return_to_status = true; }
2016-06-11 23:12:00 +02:00
#endif
#if ENABLED(BABYSTEP_ZPROBE_OFFSET)
void lcd_babystep_zoffset() {
2017-08-16 09:27:50 +02:00
if (lcd_clicked) { return lcd_goto_previous_menu_no_defer(); }
defer_return_to_status = true;
ENCODER_DIRECTION_NORMAL();
if (encoderPosition) {
const int16_t babystep_increment = (int32_t)encoderPosition * (BABYSTEP_MULTIPLICATOR);
encoderPosition = 0;
const float new_zoffset = zprobe_zoffset + planner.steps_to_mm[Z_AXIS] * babystep_increment;
if (WITHIN(new_zoffset, Z_PROBE_OFFSET_RANGE_MIN, Z_PROBE_OFFSET_RANGE_MAX)) {
if (planner.leveling_active)
thermalManager.babystep_axis(Z_AXIS, babystep_increment);
zprobe_zoffset = new_zoffset;
2017-05-25 22:13:57 +02:00
lcdDrawUpdate = LCDVIEW_CALL_REDRAW_NEXT;
}
}
if (lcdDrawUpdate) {
lcd_implementation_drawedit(PSTR(MSG_ZPROBE_ZOFFSET), ftostr43sign(zprobe_zoffset));
#if ENABLED(BABYSTEP_ZPROBE_GFX_OVERLAY)
2017-11-24 20:39:41 +01:00
_lcd_zoffset_overlay_gfx(zprobe_zoffset);
#endif
}
}
#else // !BABYSTEP_ZPROBE_OFFSET
2017-09-27 04:21:10 +02:00
void _lcd_babystep_z() { _lcd_babystep(Z_AXIS, PSTR(MSG_BABYSTEP_Z)); }
void lcd_babystep_z() { lcd_goto_screen(_lcd_babystep_z); babysteps_done = 0; defer_return_to_status = true; }
#endif // !BABYSTEP_ZPROBE_OFFSET
#endif // BABYSTEPPING
2017-03-18 16:15:54 +01:00
#if ENABLED(AUTO_BED_LEVELING_UBL)
2017-06-19 05:58:19 +02:00
float mesh_edit_value, mesh_edit_accumulator; // We round mesh_edit_value to 2.5 decimal places. So we keep a
// separate value that doesn't lose precision.
static int16_t ubl_encoderPosition = 0;
2017-03-18 16:15:54 +01:00
2017-03-20 07:42:41 +01:00
static void _lcd_mesh_fine_tune(const char* msg) {
2017-03-18 16:15:54 +01:00
defer_return_to_status = true;
if (ubl.encoder_diff) {
ubl_encoderPosition = (ubl.encoder_diff > 0) ? 1 : -1;
ubl.encoder_diff = 0;
2017-03-29 02:45:54 +02:00
mesh_edit_accumulator += float(ubl_encoderPosition) * 0.005 / 2.0;
2017-03-20 07:42:41 +01:00
mesh_edit_value = mesh_edit_accumulator;
encoderPosition = 0;
2017-05-25 22:13:57 +02:00
lcdDrawUpdate = LCDVIEW_CALL_REDRAW_NEXT;
2017-03-18 16:15:54 +01:00
2017-03-29 02:45:54 +02:00
const int32_t rounded = (int32_t)(mesh_edit_value * 1000.0);
mesh_edit_value = float(rounded - (rounded % 5L)) / 1000.0;
2017-03-18 16:15:54 +01:00
}
2017-11-24 20:39:41 +01:00
if (lcdDrawUpdate) {
2017-03-20 07:42:41 +01:00
lcd_implementation_drawedit(msg, ftostr43sign(mesh_edit_value));
2017-11-24 20:39:41 +01:00
#if ENABLED(MESH_EDIT_GFX_OVERLAY)
_lcd_zoffset_overlay_gfx(mesh_edit_value);
#endif
}
2017-03-18 16:15:54 +01:00
}
void _lcd_mesh_edit_NOP() {
defer_return_to_status = true;
}
2017-03-18 16:15:54 +01:00
float lcd_mesh_edit() {
lcd_goto_screen(_lcd_mesh_edit_NOP);
lcdDrawUpdate = LCDVIEW_CALL_REDRAW_NEXT;
_lcd_mesh_fine_tune(PSTR("Mesh Editor"));
2017-03-20 07:42:41 +01:00
return mesh_edit_value;
2017-03-18 16:15:54 +01:00
}
2017-03-20 07:42:41 +01:00
void lcd_mesh_edit_setup(float initial) {
mesh_edit_value = mesh_edit_accumulator = initial;
lcd_goto_screen(_lcd_mesh_edit_NOP);
2017-03-18 16:15:54 +01:00
}
void _lcd_z_offset_edit() {
2017-03-20 07:42:41 +01:00
_lcd_mesh_fine_tune(PSTR("Z-Offset: "));
2017-03-18 16:15:54 +01:00
}
float lcd_z_offset_edit() {
lcd_goto_screen(_lcd_z_offset_edit);
2017-03-20 07:42:41 +01:00
return mesh_edit_value;
2017-03-18 16:15:54 +01:00
}
2017-03-20 07:42:41 +01:00
void lcd_z_offset_edit_setup(float initial) {
mesh_edit_value = mesh_edit_accumulator = initial;
2017-03-18 16:15:54 +01:00
lcd_goto_screen(_lcd_z_offset_edit);
}
#endif // AUTO_BED_LEVELING_UBL
2016-06-11 23:12:00 +02:00
/**
* Watch temperature callbacks
*/
2017-04-09 10:23:05 +02:00
#if HAS_TEMP_HOTEND
#if WATCH_HOTENDS
#define _WATCH_FUNC(N) thermalManager.start_watching_heater(N)
#else
#define _WATCH_FUNC(N) NOOP
#endif
2017-04-09 10:23:05 +02:00
void watch_temp_callback_E0() { _WATCH_FUNC(0); }
#if HOTENDS > 1
void watch_temp_callback_E1() { _WATCH_FUNC(1); }
#if HOTENDS > 2
void watch_temp_callback_E2() { _WATCH_FUNC(2); }
#if HOTENDS > 3
void watch_temp_callback_E3() { _WATCH_FUNC(3); }
#if HOTENDS > 4
void watch_temp_callback_E4() { _WATCH_FUNC(4); }
#endif // HOTENDS > 4
#endif // HOTENDS > 3
#endif // HOTENDS > 2
#endif // HOTENDS > 1
#endif // HAS_TEMP_HOTEND
void watch_temp_callback_bed() {
#if WATCH_THE_BED
thermalManager.start_watching_bed();
#endif
}
#if ENABLED(ADVANCED_PAUSE_FEATURE)
2017-06-05 00:03:22 +02:00
void lcd_enqueue_filament_change() {
2017-06-13 06:09:44 +02:00
#if ENABLED(PREVENT_COLD_EXTRUSION)
if (!DEBUGGING(DRYRUN) && !thermalManager.allow_cold_extrude &&
thermalManager.degTargetHotend(active_extruder) < thermalManager.extrude_min_temp) {
lcd_save_previous_screen();
lcd_goto_screen(lcd_advanced_pause_toocold_menu);
return;
}
#endif
lcd_advanced_pause_show_message(ADVANCED_PAUSE_MESSAGE_INIT);
enqueue_and_echo_commands_P(PSTR("M600 B0"));
}
2017-06-05 00:03:22 +02:00
#endif // ADVANCED_PAUSE_FEATURE
2017-10-07 16:29:22 +02:00
// First Fan Speed title in "Tune" and "Control>Temperature" menus
#if FAN_COUNT > 0 && HAS_FAN0
#if FAN_COUNT > 1
#define FAN_SPEED_1_SUFFIX " 1"
#else
#define FAN_SPEED_1_SUFFIX ""
#endif
#endif
2017-11-10 09:38:53 +01:00
// Refresh the E factor after changing flow
inline void _lcd_refresh_e_factor_0() { planner.refresh_e_factor(0); }
#if EXTRUDERS > 1
inline void _lcd_refresh_e_factor() { planner.refresh_e_factor(active_extruder); }
inline void _lcd_refresh_e_factor_1() { planner.refresh_e_factor(1); }
#if EXTRUDERS > 2
inline void _lcd_refresh_e_factor_2() { planner.refresh_e_factor(2); }
#if EXTRUDERS > 3
inline void _lcd_refresh_e_factor_3() { planner.refresh_e_factor(3); }
#if EXTRUDERS > 4
inline void _lcd_refresh_e_factor_4() { planner.refresh_e_factor(4); }
#endif // EXTRUDERS > 4
#endif // EXTRUDERS > 3
#endif // EXTRUDERS > 2
#endif // EXTRUDERS > 1
2016-06-11 23:12:00 +02:00
/**
*
* "Tune" submenu
*
*/
void lcd_tune_menu() {
2016-06-11 23:12:00 +02:00
START_MENU();
2016-06-11 23:12:00 +02:00
//
// ^ Main
//
MENU_BACK(MSG_MAIN);
2016-06-11 23:12:00 +02:00
//
// Speed:
//
2016-07-16 03:49:34 +02:00
MENU_ITEM_EDIT(int3, MSG_SPEED, &feedrate_percentage, 10, 999);
2016-06-11 23:12:00 +02:00
// Manual bed leveling, Bed Z:
#if ENABLED(MESH_BED_LEVELING) && ENABLED(LCD_BED_LEVELING)
2016-06-11 23:12:00 +02:00
MENU_ITEM_EDIT(float43, MSG_BED_Z, &mbl.z_offset, -1, 1);
#endif
2015-01-23 23:13:06 +01:00
2016-06-11 23:12:00 +02:00
//
// Nozzle:
// Nozzle [1-4]:
//
#if HOTENDS == 1
MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(int3, MSG_NOZZLE, &thermalManager.target_temperature[0], 0, HEATER_0_MAXTEMP - 15, watch_temp_callback_E0);
2017-05-09 19:35:43 +02:00
#else // HOTENDS > 1
MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(int3, MSG_NOZZLE MSG_N1, &thermalManager.target_temperature[0], 0, HEATER_0_MAXTEMP - 15, watch_temp_callback_E0);
MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(int3, MSG_NOZZLE MSG_N2, &thermalManager.target_temperature[1], 0, HEATER_1_MAXTEMP - 15, watch_temp_callback_E1);
2016-05-27 02:43:20 +02:00
#if HOTENDS > 2
MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(int3, MSG_NOZZLE MSG_N3, &thermalManager.target_temperature[2], 0, HEATER_2_MAXTEMP - 15, watch_temp_callback_E2);
2016-05-27 02:43:20 +02:00
#if HOTENDS > 3
MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(int3, MSG_NOZZLE MSG_N4, &thermalManager.target_temperature[3], 0, HEATER_3_MAXTEMP - 15, watch_temp_callback_E3);
#if HOTENDS > 4
MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(int3, MSG_NOZZLE MSG_N5, &thermalManager.target_temperature[4], 0, HEATER_4_MAXTEMP - 15, watch_temp_callback_E4);
#endif // HOTENDS > 4
2016-06-11 23:12:00 +02:00
#endif // HOTENDS > 3
#endif // HOTENDS > 2
#endif // HOTENDS > 1
//
// Bed:
//
#if HAS_TEMP_BED
2016-06-11 23:12:00 +02:00
MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(int3, MSG_BED, &thermalManager.target_temperature_bed, 0, BED_MAXTEMP - 15, watch_temp_callback_bed);
#endif
//
// Fan Speed:
//
#if FAN_COUNT > 0
#if HAS_FAN0
2017-10-07 16:29:22 +02:00
MENU_MULTIPLIER_ITEM_EDIT(int3, MSG_FAN_SPEED FAN_SPEED_1_SUFFIX, &fanSpeeds[0], 0, 255);
#if ENABLED(EXTRA_FAN_SPEED)
MENU_MULTIPLIER_ITEM_EDIT(int3, MSG_EXTRA_FAN_SPEED FAN_SPEED_1_SUFFIX, &new_fanSpeeds[0], 3, 255);
#endif
2016-06-11 23:12:00 +02:00
#endif
#if HAS_FAN1
MENU_MULTIPLIER_ITEM_EDIT(int3, MSG_FAN_SPEED " 2", &fanSpeeds[1], 0, 255);
2017-10-07 16:29:22 +02:00
#if ENABLED(EXTRA_FAN_SPEED)
MENU_MULTIPLIER_ITEM_EDIT(int3, MSG_EXTRA_FAN_SPEED " 2", &new_fanSpeeds[1], 3, 255);
#endif
2016-04-29 03:18:13 +02:00
#endif
2016-06-11 23:12:00 +02:00
#if HAS_FAN2
MENU_MULTIPLIER_ITEM_EDIT(int3, MSG_FAN_SPEED " 3", &fanSpeeds[2], 0, 255);
2017-10-07 16:29:22 +02:00
#if ENABLED(EXTRA_FAN_SPEED)
MENU_MULTIPLIER_ITEM_EDIT(int3, MSG_EXTRA_FAN_SPEED " 3", &new_fanSpeeds[2], 3, 255);
#endif
2016-06-11 23:12:00 +02:00
#endif
#endif // FAN_COUNT > 0
//
// Flow:
// Flow [1-5]:
2016-06-11 23:12:00 +02:00
//
#if EXTRUDERS == 1
2017-11-10 09:38:53 +01:00
MENU_ITEM_EDIT_CALLBACK(int3, MSG_FLOW, &planner.flow_percentage[0], 10, 999, _lcd_refresh_e_factor_0);
2016-06-11 23:12:00 +02:00
#else // EXTRUDERS > 1
2017-11-10 09:38:53 +01:00
MENU_ITEM_EDIT_CALLBACK(int3, MSG_FLOW, &planner.flow_percentage[active_extruder], 10, 999, _lcd_refresh_e_factor);
MENU_ITEM_EDIT_CALLBACK(int3, MSG_FLOW MSG_N1, &planner.flow_percentage[0], 10, 999, _lcd_refresh_e_factor_0);
MENU_ITEM_EDIT_CALLBACK(int3, MSG_FLOW MSG_N2, &planner.flow_percentage[1], 10, 999, _lcd_refresh_e_factor_1);
2016-06-11 23:12:00 +02:00
#if EXTRUDERS > 2
2017-11-10 09:38:53 +01:00
MENU_ITEM_EDIT_CALLBACK(int3, MSG_FLOW MSG_N3, &planner.flow_percentage[2], 10, 999, _lcd_refresh_e_factor_2);
2016-06-11 23:12:00 +02:00
#if EXTRUDERS > 3
2017-11-10 09:38:53 +01:00
MENU_ITEM_EDIT_CALLBACK(int3, MSG_FLOW MSG_N4, &planner.flow_percentage[3], 10, 999, _lcd_refresh_e_factor_3);
#if EXTRUDERS > 4
2017-11-10 09:38:53 +01:00
MENU_ITEM_EDIT_CALLBACK(int3, MSG_FLOW MSG_N5, &planner.flow_percentage[4], 10, 999, _lcd_refresh_e_factor_4);
#endif // EXTRUDERS > 4
#endif // EXTRUDERS > 3
#endif // EXTRUDERS > 2
#endif // EXTRUDERS > 1
2016-06-11 23:12:00 +02:00
//
// Babystep X:
// Babystep Y:
// Babystep Z:
//
#if ENABLED(BABYSTEPPING)
#if ENABLED(BABYSTEP_XY)
MENU_ITEM(submenu, MSG_BABYSTEP_X, lcd_babystep_x);
MENU_ITEM(submenu, MSG_BABYSTEP_Y, lcd_babystep_y);
#endif
#if ENABLED(BABYSTEP_ZPROBE_OFFSET)
MENU_ITEM(submenu, MSG_ZPROBE_ZOFFSET, lcd_babystep_zoffset);
#else
MENU_ITEM(submenu, MSG_BABYSTEP_Z, lcd_babystep_z);
#endif
#endif
2016-06-11 23:12:00 +02:00
//
// Change filament
//
#if ENABLED(ADVANCED_PAUSE_FEATURE)
2017-02-10 07:13:58 +01:00
if (!thermalManager.tooColdToExtrude(active_extruder))
MENU_ITEM(function, MSG_FILAMENTCHANGE, lcd_enqueue_filament_change);
#endif
2016-06-11 23:12:00 +02:00
END_MENU();
}
2016-10-04 00:15:29 +02:00
/**
*
* "Driver current control" submenu items
*
*/
#if ENABLED(DAC_STEPPER_CURRENT)
void dac_driver_getValues() { LOOP_XYZE(i) driverPercent[i] = dac_current_get_percent((AxisEnum)i); }
2016-10-07 22:57:24 +02:00
void dac_driver_commit() { dac_current_set_percents(driverPercent); }
2016-10-07 22:57:24 +02:00
void dac_driver_eeprom_write() { dac_commit_eeprom(); }
2016-10-07 22:57:24 +02:00
void lcd_dac_menu() {
2016-10-04 00:15:29 +02:00
dac_driver_getValues();
2016-11-19 11:17:39 +01:00
START_MENU();
MENU_BACK(MSG_CONTROL);
MENU_ITEM_EDIT_CALLBACK(int8, MSG_X " " MSG_DAC_PERCENT, &driverPercent[X_AXIS], 0, 100, dac_driver_commit);
MENU_ITEM_EDIT_CALLBACK(int8, MSG_Y " " MSG_DAC_PERCENT, &driverPercent[Y_AXIS], 0, 100, dac_driver_commit);
MENU_ITEM_EDIT_CALLBACK(int8, MSG_Z " " MSG_DAC_PERCENT, &driverPercent[Z_AXIS], 0, 100, dac_driver_commit);
MENU_ITEM_EDIT_CALLBACK(int8, MSG_E " " MSG_DAC_PERCENT, &driverPercent[E_AXIS], 0, 100, dac_driver_commit);
2016-10-04 00:15:29 +02:00
MENU_ITEM(function, MSG_DAC_EEPROM_WRITE, dac_driver_eeprom_write);
END_MENU();
}
#endif // DAC_STEPPER_CURRENT
#if HAS_MOTOR_CURRENT_PWM
void lcd_pwm_menu() {
START_MENU();
MENU_BACK(MSG_CONTROL);
#if PIN_EXISTS(MOTOR_CURRENT_PWM_XY)
MENU_ITEM_EDIT_CALLBACK(long5, MSG_X MSG_Y, &stepper.motor_current_setting[0], 100, 2000, Stepper::refresh_motor_power);
#endif
#if PIN_EXISTS(MOTOR_CURRENT_PWM_Z)
MENU_ITEM_EDIT_CALLBACK(long5, MSG_Z, &stepper.motor_current_setting[1], 100, 2000, Stepper::refresh_motor_power);
#endif
#if PIN_EXISTS(MOTOR_CURRENT_PWM_E)
MENU_ITEM_EDIT_CALLBACK(long5, MSG_E, &stepper.motor_current_setting[2], 100, 2000, Stepper::refresh_motor_power);
#endif
END_MENU();
}
#endif // HAS_MOTOR_CURRENT_PWM
2016-10-04 00:15:29 +02:00
constexpr int16_t heater_maxtemp[HOTENDS] = ARRAY_BY_HOTENDS(HEATER_0_MAXTEMP, HEATER_1_MAXTEMP, HEATER_2_MAXTEMP, HEATER_3_MAXTEMP, HEATER_4_MAXTEMP);
2016-06-11 23:12:00 +02:00
/**
*
* "Prepare" submenu items
*
*/
void _lcd_preheat(const int16_t endnum, const int16_t temph, const int16_t tempb, const int16_t fan) {
if (temph > 0) thermalManager.setTargetHotend(min(heater_maxtemp[endnum], temph), endnum);
2016-06-11 23:12:00 +02:00
#if TEMP_SENSOR_BED != 0
2017-03-06 05:10:19 +01:00
if (tempb >= 0) thermalManager.setTargetBed(tempb);
#else
2016-06-11 23:12:00 +02:00
UNUSED(tempb);
#endif
2016-06-11 23:12:00 +02:00
#if FAN_COUNT > 0
#if FAN_COUNT > 1
fanSpeeds[active_extruder < FAN_COUNT ? active_extruder : 0] = fan;
#else
fanSpeeds[0] = fan;
#endif
#else
UNUSED(fan);
#endif
2016-06-11 23:12:00 +02:00
lcd_return_to_status();
}
2016-06-11 23:12:00 +02:00
#if TEMP_SENSOR_0 != 0
2017-03-06 05:10:19 +01:00
void lcd_preheat_m1_e0_only() { _lcd_preheat(0, lcd_preheat_hotend_temp[0], -1, lcd_preheat_fan_speed[0]); }
void lcd_preheat_m2_e0_only() { _lcd_preheat(0, lcd_preheat_hotend_temp[1], -1, lcd_preheat_fan_speed[1]); }
#if TEMP_SENSOR_BED != 0
void lcd_preheat_m1_e0() { _lcd_preheat(0, lcd_preheat_hotend_temp[0], lcd_preheat_bed_temp[0], lcd_preheat_fan_speed[0]); }
void lcd_preheat_m2_e0() { _lcd_preheat(0, lcd_preheat_hotend_temp[1], lcd_preheat_bed_temp[1], lcd_preheat_fan_speed[1]); }
#endif
2016-03-06 03:27:45 +01:00
#endif
2016-06-11 23:12:00 +02:00
#if HOTENDS > 1
2017-03-06 05:10:19 +01:00
void lcd_preheat_m1_e1_only() { _lcd_preheat(1, lcd_preheat_hotend_temp[0], -1, lcd_preheat_fan_speed[0]); }
void lcd_preheat_m2_e1_only() { _lcd_preheat(1, lcd_preheat_hotend_temp[1], -1, lcd_preheat_fan_speed[1]); }
#if TEMP_SENSOR_BED != 0
void lcd_preheat_m1_e1() { _lcd_preheat(1, lcd_preheat_hotend_temp[0], lcd_preheat_bed_temp[0], lcd_preheat_fan_speed[0]); }
void lcd_preheat_m2_e1() { _lcd_preheat(1, lcd_preheat_hotend_temp[1], lcd_preheat_bed_temp[1], lcd_preheat_fan_speed[1]); }
#endif
2016-06-11 23:12:00 +02:00
#if HOTENDS > 2
2017-03-06 05:10:19 +01:00
void lcd_preheat_m1_e2_only() { _lcd_preheat(2, lcd_preheat_hotend_temp[0], -1, lcd_preheat_fan_speed[0]); }
void lcd_preheat_m2_e2_only() { _lcd_preheat(2, lcd_preheat_hotend_temp[1], -1, lcd_preheat_fan_speed[1]); }
#if TEMP_SENSOR_BED != 0
void lcd_preheat_m1_e2() { _lcd_preheat(2, lcd_preheat_hotend_temp[0], lcd_preheat_bed_temp[0], lcd_preheat_fan_speed[0]); }
void lcd_preheat_m2_e2() { _lcd_preheat(2, lcd_preheat_hotend_temp[1], lcd_preheat_bed_temp[1], lcd_preheat_fan_speed[1]); }
#endif
2016-06-11 23:12:00 +02:00
#if HOTENDS > 3
2017-03-06 05:10:19 +01:00
void lcd_preheat_m1_e3_only() { _lcd_preheat(3, lcd_preheat_hotend_temp[0], -1, lcd_preheat_fan_speed[0]); }
void lcd_preheat_m2_e3_only() { _lcd_preheat(3, lcd_preheat_hotend_temp[1], -1, lcd_preheat_fan_speed[1]); }
#if TEMP_SENSOR_BED != 0
void lcd_preheat_m1_e3() { _lcd_preheat(3, lcd_preheat_hotend_temp[0], lcd_preheat_bed_temp[0], lcd_preheat_fan_speed[0]); }
void lcd_preheat_m2_e3() { _lcd_preheat(3, lcd_preheat_hotend_temp[1], lcd_preheat_bed_temp[1], lcd_preheat_fan_speed[1]); }
#endif
#if HOTENDS > 4
void lcd_preheat_m1_e4_only() { _lcd_preheat(4, lcd_preheat_hotend_temp[0], -1, lcd_preheat_fan_speed[0]); }
void lcd_preheat_m2_e4_only() { _lcd_preheat(4, lcd_preheat_hotend_temp[1], -1, lcd_preheat_fan_speed[1]); }
#if TEMP_SENSOR_BED != 0
void lcd_preheat_m1_e4() { _lcd_preheat(4, lcd_preheat_hotend_temp[0], lcd_preheat_bed_temp[0], lcd_preheat_fan_speed[0]); }
void lcd_preheat_m2_e4() { _lcd_preheat(4, lcd_preheat_hotend_temp[1], lcd_preheat_bed_temp[1], lcd_preheat_fan_speed[1]); }
#endif
#endif // HOTENDS > 4
#endif // HOTENDS > 3
#endif // HOTENDS > 2
2017-03-06 05:10:19 +01:00
void lcd_preheat_m1_all() {
2016-06-11 23:12:00 +02:00
#if HOTENDS > 1
thermalManager.setTargetHotend(lcd_preheat_hotend_temp[0], 1);
2016-06-11 23:12:00 +02:00
#if HOTENDS > 2
thermalManager.setTargetHotend(lcd_preheat_hotend_temp[0], 2);
2016-06-11 23:12:00 +02:00
#if HOTENDS > 3
thermalManager.setTargetHotend(lcd_preheat_hotend_temp[0], 3);
#if HOTENDS > 4
thermalManager.setTargetHotend(lcd_preheat_hotend_temp[0], 4);
#endif // HOTENDS > 4
#endif // HOTENDS > 3
#endif // HOTENDS > 2
#endif // HOTENDS > 1
2017-03-06 05:10:19 +01:00
#if TEMP_SENSOR_BED != 0
lcd_preheat_m1_e0();
#else
lcd_preheat_m1_e0_only();
#endif
2016-06-11 23:12:00 +02:00
}
2017-03-06 05:10:19 +01:00
void lcd_preheat_m2_all() {
2016-06-11 23:12:00 +02:00
#if HOTENDS > 1
thermalManager.setTargetHotend(lcd_preheat_hotend_temp[1], 1);
2016-06-11 23:12:00 +02:00
#if HOTENDS > 2
thermalManager.setTargetHotend(lcd_preheat_hotend_temp[1], 2);
2016-06-11 23:12:00 +02:00
#if HOTENDS > 3
thermalManager.setTargetHotend(lcd_preheat_hotend_temp[1], 3);
#if HOTENDS > 4
thermalManager.setTargetHotend(lcd_preheat_hotend_temp[1], 4);
#endif // HOTENDS > 4
#endif // HOTENDS > 3
#endif // HOTENDS > 2
#endif // HOTENDS > 1
2017-03-06 05:10:19 +01:00
#if TEMP_SENSOR_BED != 0
2017-04-02 16:24:39 +02:00
lcd_preheat_m2_e0();
2017-03-06 05:10:19 +01:00
#else
2017-04-02 16:24:39 +02:00
lcd_preheat_m2_e0_only();
2017-03-06 05:10:19 +01:00
#endif
2016-06-11 23:12:00 +02:00
}
2016-06-11 23:12:00 +02:00
#endif // HOTENDS > 1
2016-04-03 07:46:15 +02:00
2016-06-11 23:12:00 +02:00
#if TEMP_SENSOR_BED != 0
2017-03-06 05:10:19 +01:00
void lcd_preheat_m1_bedonly() { _lcd_preheat(0, 0, lcd_preheat_bed_temp[0], lcd_preheat_fan_speed[0]); }
void lcd_preheat_m2_bedonly() { _lcd_preheat(0, 0, lcd_preheat_bed_temp[1], lcd_preheat_fan_speed[1]); }
2016-06-11 23:12:00 +02:00
#endif
2016-04-03 07:46:15 +02:00
#if TEMP_SENSOR_0 != 0 && (TEMP_SENSOR_1 != 0 || TEMP_SENSOR_2 != 0 || TEMP_SENSOR_3 != 0 || TEMP_SENSOR_4 != 0 || TEMP_SENSOR_BED != 0)
2016-04-03 07:46:15 +02:00
2017-03-06 05:10:19 +01:00
void lcd_preheat_m1_menu() {
2016-06-11 23:12:00 +02:00
START_MENU();
MENU_BACK(MSG_PREPARE);
2016-06-11 23:12:00 +02:00
#if HOTENDS == 1
2017-03-06 05:10:19 +01:00
#if TEMP_SENSOR_BED != 0
MENU_ITEM(function, MSG_PREHEAT_1, lcd_preheat_m1_e0);
2017-03-06 09:06:51 +01:00
MENU_ITEM(function, MSG_PREHEAT_1_END, lcd_preheat_m1_e0_only);
2017-03-06 05:10:19 +01:00
#else
MENU_ITEM(function, MSG_PREHEAT_1, lcd_preheat_m1_e0_only);
#endif
2016-06-11 23:12:00 +02:00
#else
2017-03-06 05:10:19 +01:00
#if TEMP_SENSOR_BED != 0
MENU_ITEM(function, MSG_PREHEAT_1_N MSG_H1, lcd_preheat_m1_e0);
2017-03-06 09:06:51 +01:00
MENU_ITEM(function, MSG_PREHEAT_1_END " " MSG_E1, lcd_preheat_m1_e0_only);
2017-03-06 05:10:19 +01:00
MENU_ITEM(function, MSG_PREHEAT_1_N MSG_H2, lcd_preheat_m1_e1);
2017-03-06 09:06:51 +01:00
MENU_ITEM(function, MSG_PREHEAT_1_END " " MSG_E2, lcd_preheat_m1_e1_only);
2017-03-06 05:10:19 +01:00
#else
MENU_ITEM(function, MSG_PREHEAT_1_N MSG_H1, lcd_preheat_m1_e0_only);
MENU_ITEM(function, MSG_PREHEAT_1_N MSG_H2, lcd_preheat_m1_e1_only);
#endif
2016-06-11 23:12:00 +02:00
#if HOTENDS > 2
2017-03-06 05:10:19 +01:00
#if TEMP_SENSOR_BED != 0
MENU_ITEM(function, MSG_PREHEAT_1_N MSG_H3, lcd_preheat_m1_e2);
2017-03-06 09:06:51 +01:00
MENU_ITEM(function, MSG_PREHEAT_1_END " " MSG_E3, lcd_preheat_m1_e2_only);
2017-03-06 05:10:19 +01:00
#else
MENU_ITEM(function, MSG_PREHEAT_1_N MSG_H3, lcd_preheat_m1_e2_only);
#endif
2016-06-11 23:12:00 +02:00
#if HOTENDS > 3
2017-03-06 05:10:19 +01:00
#if TEMP_SENSOR_BED != 0
MENU_ITEM(function, MSG_PREHEAT_1_N MSG_H4, lcd_preheat_m1_e3);
2017-03-06 09:06:51 +01:00
MENU_ITEM(function, MSG_PREHEAT_1_END " " MSG_E4, lcd_preheat_m1_e3_only);
2017-03-06 05:10:19 +01:00
#else
MENU_ITEM(function, MSG_PREHEAT_1_N MSG_H4, lcd_preheat_m1_e3_only);
#endif
#if HOTENDS > 4
#if TEMP_SENSOR_BED != 0
MENU_ITEM(function, MSG_PREHEAT_1_N MSG_H5, lcd_preheat_m1_e4);
MENU_ITEM(function, MSG_PREHEAT_1_END " " MSG_E5, lcd_preheat_m1_e4_only);
#else
MENU_ITEM(function, MSG_PREHEAT_1_N MSG_H5, lcd_preheat_m1_e4_only);
#endif
#endif // HOTENDS > 4
#endif // HOTENDS > 3
#endif // HOTENDS > 2
2017-03-06 05:10:19 +01:00
MENU_ITEM(function, MSG_PREHEAT_1_ALL, lcd_preheat_m1_all);
#endif // HOTENDS > 1
2016-06-11 23:12:00 +02:00
#if TEMP_SENSOR_BED != 0
2017-03-06 05:10:19 +01:00
MENU_ITEM(function, MSG_PREHEAT_1_BEDONLY, lcd_preheat_m1_bedonly);
2016-06-11 23:12:00 +02:00
#endif
END_MENU();
}
2016-04-13 11:37:41 +02:00
2017-03-06 05:10:19 +01:00
void lcd_preheat_m2_menu() {
2016-06-11 23:12:00 +02:00
START_MENU();
MENU_BACK(MSG_PREPARE);
2016-06-11 23:12:00 +02:00
#if HOTENDS == 1
2017-03-06 05:10:19 +01:00
#if TEMP_SENSOR_BED != 0
MENU_ITEM(function, MSG_PREHEAT_2, lcd_preheat_m2_e0);
2017-03-06 09:06:51 +01:00
MENU_ITEM(function, MSG_PREHEAT_2_END, lcd_preheat_m2_e0_only);
2017-03-06 05:10:19 +01:00
#else
MENU_ITEM(function, MSG_PREHEAT_2, lcd_preheat_m2_e0_only);
#endif
2016-06-11 23:12:00 +02:00
#else
2017-03-06 05:10:19 +01:00
#if TEMP_SENSOR_BED != 0
MENU_ITEM(function, MSG_PREHEAT_2_N MSG_H1, lcd_preheat_m2_e0);
2017-03-06 09:06:51 +01:00
MENU_ITEM(function, MSG_PREHEAT_2_END " " MSG_E1, lcd_preheat_m2_e0_only);
2017-03-06 05:10:19 +01:00
MENU_ITEM(function, MSG_PREHEAT_2_N MSG_H2, lcd_preheat_m2_e1);
2017-03-06 09:06:51 +01:00
MENU_ITEM(function, MSG_PREHEAT_2_END " " MSG_E2, lcd_preheat_m2_e1_only);
2017-03-06 05:10:19 +01:00
#else
MENU_ITEM(function, MSG_PREHEAT_2_N MSG_H1, lcd_preheat_m2_e0_only);
MENU_ITEM(function, MSG_PREHEAT_2_N MSG_H2, lcd_preheat_m2_e1_only);
#endif
2016-06-11 23:12:00 +02:00
#if HOTENDS > 2
2017-03-06 05:10:19 +01:00
#if TEMP_SENSOR_BED != 0
MENU_ITEM(function, MSG_PREHEAT_2_N MSG_H3, lcd_preheat_m2_e2);
2017-03-06 09:06:51 +01:00
MENU_ITEM(function, MSG_PREHEAT_2_END " " MSG_E3, lcd_preheat_m2_e2_only);
2017-03-06 05:10:19 +01:00
#else
MENU_ITEM(function, MSG_PREHEAT_2_N MSG_H3, lcd_preheat_m2_e2_only);
#endif
2016-06-11 23:12:00 +02:00
#if HOTENDS > 3
2017-03-06 05:10:19 +01:00
#if TEMP_SENSOR_BED != 0
MENU_ITEM(function, MSG_PREHEAT_2_N MSG_H4, lcd_preheat_m2_e3);
2017-03-06 09:06:51 +01:00
MENU_ITEM(function, MSG_PREHEAT_2_END " " MSG_E4, lcd_preheat_m2_e3_only);
2017-03-06 05:10:19 +01:00
#else
MENU_ITEM(function, MSG_PREHEAT_2_N MSG_H4, lcd_preheat_m2_e3_only);
#endif
#if HOTENDS > 4
#if TEMP_SENSOR_BED != 0
MENU_ITEM(function, MSG_PREHEAT_2_N MSG_H5, lcd_preheat_m2_e4);
MENU_ITEM(function, MSG_PREHEAT_2_END " " MSG_E5, lcd_preheat_m2_e4_only);
#else
MENU_ITEM(function, MSG_PREHEAT_2_N MSG_H5, lcd_preheat_m2_e4_only);
#endif
#endif // HOTENDS > 4
#endif // HOTENDS > 3
#endif // HOTENDS > 2
2017-03-06 05:10:19 +01:00
MENU_ITEM(function, MSG_PREHEAT_2_ALL, lcd_preheat_m2_all);
#endif // HOTENDS > 1
2016-06-11 23:12:00 +02:00
#if TEMP_SENSOR_BED != 0
2017-03-06 05:10:19 +01:00
MENU_ITEM(function, MSG_PREHEAT_2_BEDONLY, lcd_preheat_m2_bedonly);
2016-06-11 23:12:00 +02:00
#endif
END_MENU();
}
#endif // TEMP_SENSOR_0 && (TEMP_SENSOR_1 || TEMP_SENSOR_2 || TEMP_SENSOR_3 || TEMP_SENSOR_4 || TEMP_SENSOR_BED)
2016-06-11 23:12:00 +02:00
void lcd_cooldown() {
#if FAN_COUNT > 0
for (uint8_t i = 0; i < FAN_COUNT; i++) fanSpeeds[i] = 0;
2016-04-13 11:37:41 +02:00
#endif
2016-06-11 23:12:00 +02:00
thermalManager.disable_all_heaters();
lcd_return_to_status();
}
2016-06-11 23:12:00 +02:00
#if ENABLED(SDSUPPORT) && ENABLED(MENU_ADDAUTOSTART)
void lcd_autostart_sd() {
2016-06-11 23:12:00 +02:00
card.autostart_index = 0;
card.setroot();
card.checkautostart(true);
}
2016-04-03 07:46:15 +02:00
2016-06-11 23:12:00 +02:00
#endif
2016-04-03 07:46:15 +02:00
#if ENABLED(EEPROM_SETTINGS)
static void lcd_store_settings() { lcd_completion_feedback(settings.save()); }
static void lcd_load_settings() { lcd_completion_feedback(settings.load()); }
#endif
2017-08-16 09:27:50 +02:00
#if ENABLED(LEVEL_BED_CORNERS)
/**
* Level corners, starting in the front-left corner.
*/
static int8_t bed_corner;
void _lcd_goto_next_corner() {
2017-11-03 02:17:51 +01:00
line_to_z(4.0);
2017-08-16 09:27:50 +02:00
switch (bed_corner) {
case 0:
current_position[X_AXIS] = X_MIN_BED + 10;
current_position[Y_AXIS] = Y_MIN_BED + 10;
break;
case 1:
current_position[X_AXIS] = X_MAX_BED - 10;
break;
case 2:
current_position[Y_AXIS] = Y_MAX_BED - 10;
break;
case 3:
current_position[X_AXIS] = X_MIN_BED + 10;
break;
}
planner.buffer_line_kinematic(current_position, MMM_TO_MMS(manual_feedrate_mm_m[X_AXIS]), active_extruder);
2017-11-03 02:17:51 +01:00
line_to_z(0.0);
2017-08-16 09:27:50 +02:00
if (++bed_corner > 3) bed_corner = 0;
}
void _lcd_corner_submenu() {
START_MENU();
MENU_ITEM(function, MSG_NEXT_CORNER, _lcd_goto_next_corner);
MENU_ITEM(function, MSG_BACK, lcd_goto_previous_menu_no_defer);
END_MENU();
}
void _lcd_level_bed_corners() {
defer_return_to_status = true;
lcd_goto_screen(_lcd_corner_submenu);
bed_corner = 0;
_lcd_goto_next_corner();
}
#endif // LEVEL_BED_CORNERS
#if ENABLED(LCD_BED_LEVELING)
2016-06-11 23:12:00 +02:00
/**
*
* "Prepare" > "Level Bed" handlers
2016-06-11 23:12:00 +02:00
*
*/
static uint8_t manual_probe_index;
2016-06-11 23:12:00 +02:00
// LCD probed points are from defaults
2017-05-12 06:22:35 +02:00
constexpr uint8_t total_probe_points = (
#if ENABLED(AUTO_BED_LEVELING_3POINT)
3
2017-05-25 22:13:57 +02:00
#elif ABL_GRID || ENABLED(MESH_BED_LEVELING)
2017-05-12 06:22:35 +02:00
GRID_MAX_POINTS
2016-06-11 23:12:00 +02:00
#endif
2017-05-12 06:22:35 +02:00
);
2017-05-29 23:01:17 +02:00
//
// Raise Z to the "manual probe height"
// Don't return until done.
// ** This blocks the command queue! **
//
void _lcd_after_probing() {
#if MANUAL_PROBE_HEIGHT > 0
2017-11-03 02:17:51 +01:00
line_to_z(Z_MIN_POS + MANUAL_PROBE_HEIGHT);
2017-05-29 23:01:17 +02:00
#endif
// Display "Done" screen and wait for moves to complete
#if MANUAL_PROBE_HEIGHT > 0 || ENABLED(MESH_BED_LEVELING)
lcd_synchronize(PSTR(MSG_LEVEL_BED_DONE));
#endif
lcd_goto_previous_menu();
lcd_completion_feedback();
defer_return_to_status = false;
//LCD_MESSAGEPGM(MSG_LEVEL_BED_DONE);
}
#if ENABLED(MESH_BED_LEVELING)
2016-06-11 23:12:00 +02:00
// Utility to go to the next mesh point
2017-11-03 02:17:51 +01:00
inline void _manual_probe_goto_xy(const float rx, const float ry) {
#if MANUAL_PROBE_HEIGHT > 0
const float prev_z = current_position[Z_AXIS];
2017-11-03 02:17:51 +01:00
line_to_z(Z_MIN_POS + MANUAL_PROBE_HEIGHT);
#endif
2017-11-03 02:17:51 +01:00
current_position[X_AXIS] = rx;
current_position[Y_AXIS] = ry;
planner.buffer_line_kinematic(current_position, MMM_TO_MMS(XY_PROBE_SPEED), active_extruder);
#if MANUAL_PROBE_HEIGHT > 0
line_to_z(prev_z);
#endif
lcd_synchronize();
}
2017-05-29 23:01:17 +02:00
#elif ENABLED(PROBE_MANUALLY)
2017-05-29 23:01:17 +02:00
bool lcd_wait_for_move;
//
// Bed leveling is done. Wait for G29 to complete.
// A flag is used so that this can release control
// and allow the command queue to be processed.
//
void _lcd_level_bed_done() {
if (!lcd_wait_for_move) _lcd_after_probing();
if (lcdDrawUpdate) lcd_implementation_drawedit(PSTR(MSG_LEVEL_BED_DONE));
lcdDrawUpdate = LCDVIEW_CALL_REDRAW_NEXT;
}
#endif
2016-04-03 07:46:15 +02:00
2017-05-25 22:13:57 +02:00
void _lcd_level_goto_next_point();
/**
* Step 7: Get the Z coordinate, click goes to the next point or exits
2016-06-11 23:12:00 +02:00
*/
void _lcd_level_bed_get_z() {
2016-06-11 23:12:00 +02:00
ENCODER_DIRECTION_NORMAL();
if (lcd_clicked) {
2017-05-29 23:01:17 +02:00
//
// Save the current Z position
//
2017-05-25 22:13:57 +02:00
#if ENABLED(MESH_BED_LEVELING)
2017-05-29 23:01:17 +02:00
//
2017-05-25 22:13:57 +02:00
// MBL records the position but doesn't move to the next one
2017-05-29 23:01:17 +02:00
//
2017-05-29 23:01:17 +02:00
mbl.set_zigzag_z(manual_probe_index, current_position[Z_AXIS]);
#endif
// If done...
2017-05-25 22:13:57 +02:00
if (++manual_probe_index >= total_probe_points) {
2017-05-29 23:01:17 +02:00
#if ENABLED(PROBE_MANUALLY)
2016-06-11 23:12:00 +02:00
2017-05-29 23:01:17 +02:00
//
// The last G29 will record and enable but not move.
//
lcd_wait_for_move = true;
enqueue_and_echo_commands_P(PSTR("G29 V1"));
lcd_goto_screen(_lcd_level_bed_done);
2017-05-29 23:01:17 +02:00
#elif ENABLED(MESH_BED_LEVELING)
2016-06-11 23:12:00 +02:00
2017-05-29 23:01:17 +02:00
_lcd_after_probing();
mbl.has_mesh = true;
mesh_probing_done();
#endif
2017-03-15 09:20:41 +01:00
}
2017-05-29 23:01:17 +02:00
else {
// MESH_BED_LEVELING: Z already stored, just move
// PROBE_MANUALLY: Send G29 to record Z, then move
2017-05-25 22:13:57 +02:00
_lcd_level_goto_next_point();
2017-05-29 23:01:17 +02:00
}
2017-05-25 22:13:57 +02:00
return;
}
2017-05-29 23:01:17 +02:00
//
2017-05-25 22:13:57 +02:00
// Encoder knob or keypad buttons adjust the Z position
2017-05-29 23:01:17 +02:00
//
2017-05-25 22:13:57 +02:00
if (encoderPosition) {
refresh_cmd_timeout();
const float z = current_position[Z_AXIS] + float((int32_t)encoderPosition) * (MBL_Z_STEP);
line_to_z(constrain(z, -(LCD_PROBE_Z_RANGE) * 0.5, (LCD_PROBE_Z_RANGE) * 0.5));
2017-05-25 22:13:57 +02:00
lcdDrawUpdate = LCDVIEW_CALL_REDRAW_NEXT;
encoderPosition = 0;
2016-06-11 23:12:00 +02:00
}
2017-05-29 23:01:17 +02:00
//
// Draw on first display, then only on Z change
//
2016-06-11 23:12:00 +02:00
if (lcdDrawUpdate) {
2017-03-15 09:20:41 +01:00
const float v = current_position[Z_AXIS];
2016-06-11 23:12:00 +02:00
lcd_implementation_drawedit(PSTR(MSG_MOVE_Z), ftostr43sign(v + (v < 0 ? -0.0001 : 0.0001), '+'));
}
}
2017-05-25 22:13:57 +02:00
/**
* Step 6: Display "Next point: 1 / 9" while waiting for move to finish
*/
2017-05-25 22:13:57 +02:00
void _lcd_level_bed_moving() {
if (lcdDrawUpdate) {
char msg[10];
sprintf_P(msg, PSTR("%i / %u"), (int)(manual_probe_index + 1), total_probe_points);
lcd_implementation_drawedit(PSTR(MSG_LEVEL_BED_NEXT_POINT), msg);
}
lcdDrawUpdate = LCDVIEW_CALL_NO_REDRAW;
#if ENABLED(PROBE_MANUALLY)
if (!lcd_wait_for_move) lcd_goto_screen(_lcd_level_bed_get_z);
#endif
}
2017-05-25 22:13:57 +02:00
/**
* Step 5: Initiate a move to the next point
*/
void _lcd_level_goto_next_point() {
2017-05-25 22:13:57 +02:00
// Set the menu to display ahead of blocking call
lcd_goto_screen(_lcd_level_bed_moving);
2017-05-25 22:13:57 +02:00
#if ENABLED(MESH_BED_LEVELING)
2016-04-03 07:46:15 +02:00
2017-05-25 22:13:57 +02:00
int8_t px, py;
mbl.zigzag(manual_probe_index, px, py);
2017-05-25 22:13:57 +02:00
// Controls the loop until the move is done
_manual_probe_goto_xy(
2017-11-03 02:17:51 +01:00
mbl.index_to_xpos[px],
mbl.index_to_ypos[py]
2017-05-25 22:13:57 +02:00
);
// After the blocking function returns, change menus
lcd_goto_screen(_lcd_level_bed_get_z);
2017-05-25 22:13:57 +02:00
#elif ENABLED(PROBE_MANUALLY)
2017-05-29 23:01:17 +02:00
// G29 Records Z, moves, and signals when it pauses
2017-05-25 22:13:57 +02:00
lcd_wait_for_move = true;
enqueue_and_echo_commands_P(PSTR("G29 V1"));
#endif
}
2016-06-11 23:12:00 +02:00
/**
* Step 4: Display "Click to Begin", wait for click
* Move to the first probe position
*/
void _lcd_level_bed_homing_done() {
2016-06-11 23:12:00 +02:00
if (lcdDrawUpdate) lcd_implementation_drawedit(PSTR(MSG_LEVEL_BED_WAITING));
if (lcd_clicked) {
manual_probe_index = 0;
2017-05-25 22:13:57 +02:00
_lcd_level_goto_next_point();
2016-06-11 23:12:00 +02:00
}
}
2016-06-11 23:12:00 +02:00
/**
* Step 3: Display "Homing XYZ" - Wait for homing to finish
*/
void _lcd_level_bed_homing() {
2016-06-11 23:12:00 +02:00
if (lcdDrawUpdate) lcd_implementation_drawedit(PSTR(MSG_LEVEL_BED_HOMING), NULL);
2017-05-25 22:13:57 +02:00
lcdDrawUpdate = LCDVIEW_CALL_NO_REDRAW;
if (axis_homed[X_AXIS] && axis_homed[Y_AXIS] && axis_homed[Z_AXIS])
lcd_goto_screen(_lcd_level_bed_homing_done);
2016-04-03 07:46:15 +02:00
}
#if ENABLED(PROBE_MANUALLY)
extern bool g29_in_progress;
#endif
2016-06-11 23:12:00 +02:00
/**
* Step 2: Continue Bed Leveling...
*/
void _lcd_level_bed_continue() {
defer_return_to_status = true;
axis_homed[X_AXIS] = axis_homed[Y_AXIS] = axis_homed[Z_AXIS] = false;
lcd_goto_screen(_lcd_level_bed_homing);
enqueue_and_echo_commands_P(PSTR("G28"));
2016-06-11 23:12:00 +02:00
}
2016-04-03 07:46:15 +02:00
2017-10-14 04:35:25 +02:00
static bool new_level_state;
void _lcd_toggle_bed_leveling() { set_bed_leveling_enabled(new_level_state); }
#if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
2017-10-14 04:35:25 +02:00
static float new_z_fade_height;
void _lcd_set_z_fade_height() { set_z_fade_height(new_z_fade_height); }
#endif
2016-06-11 23:12:00 +02:00
/**
* Step 1: Bed Level entry-point
*
* << Prepare
* Auto Home (if homing needed)
* Leveling On/Off (if data exists, and homed)
* Fade Height: --- (Req: ENABLE_LEVELING_FADE_HEIGHT)
* Mesh Z Offset: --- (Req: MESH_BED_LEVELING)
* Z Probe Offset: --- (Req: HAS_BED_PROBE, Opt: BABYSTEP_ZPROBE_OFFSET)
2017-08-16 09:27:50 +02:00
* Level Bed >
* Level Corners > (if homed)
* Load Settings (Req: EEPROM_SETTINGS)
* Save Settings (Req: EEPROM_SETTINGS)
2016-06-11 23:12:00 +02:00
*/
2017-05-29 19:47:35 +02:00
void lcd_bed_leveling() {
2016-06-11 23:12:00 +02:00
START_MENU();
MENU_BACK(MSG_PREPARE);
2017-05-29 19:19:41 +02:00
2017-05-29 19:47:35 +02:00
if (!(axis_known_position[X_AXIS] && axis_known_position[Y_AXIS] && axis_known_position[Z_AXIS]))
MENU_ITEM(gcode, MSG_AUTO_HOME, PSTR("G28"));
2017-10-14 04:35:25 +02:00
else if (leveling_is_valid())
MENU_ITEM_EDIT_CALLBACK(bool, MSG_BED_LEVELING, &new_level_state, _lcd_toggle_bed_leveling);
#if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
2017-10-14 04:35:25 +02:00
MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(float62, MSG_Z_FADE_HEIGHT, &new_z_fade_height, 0.0, 100.0, _lcd_set_z_fade_height);
#endif
2017-05-29 19:47:35 +02:00
//
// MBL Z Offset
//
#if ENABLED(MESH_BED_LEVELING)
MENU_ITEM_EDIT(float43, MSG_BED_Z, &mbl.z_offset, -1, 1);
#endif
#if ENABLED(BABYSTEP_ZPROBE_OFFSET)
MENU_ITEM(submenu, MSG_ZPROBE_ZOFFSET, lcd_babystep_zoffset);
#elif HAS_BED_PROBE
2017-11-17 00:35:14 +01:00
MENU_ITEM_EDIT(float32, MSG_ZPROBE_ZOFFSET, &zprobe_zoffset, Z_PROBE_OFFSET_RANGE_MIN, Z_PROBE_OFFSET_RANGE_MAX);
#endif
2017-05-29 19:19:41 +02:00
MENU_ITEM(submenu, MSG_LEVEL_BED, _lcd_level_bed_continue);
2017-08-16 09:27:50 +02:00
#if ENABLED(LEVEL_BED_CORNERS)
// Move to the next corner for leveling
if (axis_homed[X_AXIS] && axis_homed[Y_AXIS] && axis_homed[Z_AXIS])
MENU_ITEM(function, MSG_LEVEL_CORNERS, _lcd_level_bed_corners);
#endif
#if ENABLED(EEPROM_SETTINGS)
MENU_ITEM(function, MSG_LOAD_EEPROM, lcd_load_settings);
MENU_ITEM(function, MSG_STORE_EEPROM, lcd_store_settings);
#endif
2016-06-11 23:12:00 +02:00
END_MENU();
}
2017-10-14 04:35:25 +02:00
void _lcd_goto_bed_leveling() {
currentScreen = lcd_bed_leveling;
#if ENABLED(LCD_BED_LEVELING)
new_level_state = planner.leveling_active;
#endif
#if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
new_z_fade_height = planner.z_fade_height;
#endif
}
2017-05-25 22:13:57 +02:00
#elif ENABLED(AUTO_BED_LEVELING_UBL)
2017-05-25 22:13:57 +02:00
void _lcd_ubl_level_bed();
static int16_t ubl_storage_slot = 0,
2017-05-25 22:13:57 +02:00
custom_hotend_temp = 190,
side_points = 3,
ubl_fillin_amount = 5,
ubl_height_amount = 1,
n_edit_pts = 1,
x_plot = 0,
y_plot = 0;
2017-07-28 09:19:50 +02:00
#if HAS_TEMP_BED
static int16_t custom_bed_temp = 50;
#endif
2017-05-25 22:13:57 +02:00
/**
* UBL Build Custom Mesh Command
*/
void _lcd_ubl_build_custom_mesh() {
char UBL_LCD_GCODE[20];
enqueue_and_echo_commands_P(PSTR("G28"));
#if HAS_TEMP_BED
2017-05-25 22:13:57 +02:00
sprintf_P(UBL_LCD_GCODE, PSTR("M190 S%i"), custom_bed_temp);
enqueue_and_echo_command(UBL_LCD_GCODE);
2017-05-25 22:13:57 +02:00
#endif
sprintf_P(UBL_LCD_GCODE, PSTR("M109 S%i"), custom_hotend_temp);
enqueue_and_echo_command(UBL_LCD_GCODE);
enqueue_and_echo_commands_P(PSTR("G29 P1"));
}
2017-05-25 22:13:57 +02:00
/**
* UBL Custom Mesh submenu
*
* << Build Mesh
* Hotend Temp: ---
* Bed Temp: ---
* Build Custom Mesh
2017-05-25 22:13:57 +02:00
*/
void _lcd_ubl_custom_mesh() {
START_MENU();
MENU_BACK(MSG_UBL_BUILD_MESH_MENU);
MENU_ITEM_EDIT(int3, MSG_UBL_CUSTOM_HOTEND_TEMP, &custom_hotend_temp, EXTRUDE_MINTEMP, (HEATER_0_MAXTEMP - 10));
#if HAS_TEMP_BED
2017-05-25 22:13:57 +02:00
MENU_ITEM_EDIT(int3, MSG_UBL_CUSTOM_BED_TEMP, &custom_bed_temp, BED_MINTEMP, (BED_MAXTEMP - 5));
#endif
MENU_ITEM(function, MSG_UBL_BUILD_CUSTOM_MESH, _lcd_ubl_build_custom_mesh);
END_MENU();
}
2017-05-25 22:13:57 +02:00
/**
* UBL Adjust Mesh Height Command
*/
void _lcd_ubl_adjust_height_cmd() {
char UBL_LCD_GCODE[16];
2017-09-01 23:59:06 +02:00
const int ind = ubl_height_amount > 0 ? 9 : 10;
strcpy_P(UBL_LCD_GCODE, PSTR("G29 P6 C -"));
2017-05-25 22:13:57 +02:00
sprintf_P(&UBL_LCD_GCODE[ind], PSTR(".%i"), abs(ubl_height_amount));
enqueue_and_echo_command(UBL_LCD_GCODE);
}
2017-05-25 22:13:57 +02:00
/**
* UBL Adjust Mesh Height submenu
*
* << Edit Mesh
* Height Amount: ---
* Adjust Mesh Height
* << Info Screen
2017-05-25 22:13:57 +02:00
*/
void _lcd_ubl_height_adjust_menu() {
START_MENU();
MENU_BACK(MSG_UBL_EDIT_MESH_MENU);
2017-09-01 23:59:06 +02:00
MENU_ITEM_EDIT_CALLBACK(int3, MSG_UBL_MESH_HEIGHT_AMOUNT, &ubl_height_amount, -9, 9, _lcd_ubl_adjust_height_cmd);
2017-05-30 02:55:26 +02:00
MENU_ITEM(function, MSG_WATCH, lcd_return_to_status);
2017-05-25 22:13:57 +02:00
END_MENU();
}
2017-05-25 22:13:57 +02:00
/**
* UBL Edit Mesh submenu
*
* << UBL Tools
* Fine Tune All
* Fine Tune Closest
* - Adjust Mesh Height >>
* << Info Screen
2017-05-25 22:13:57 +02:00
*/
void _lcd_ubl_edit_mesh() {
START_MENU();
MENU_BACK(MSG_UBL_TOOLS);
MENU_ITEM(gcode, MSG_UBL_FINE_TUNE_ALL, PSTR("G29 P4 R999 T"));
2017-05-25 22:13:57 +02:00
MENU_ITEM(gcode, MSG_UBL_FINE_TUNE_CLOSEST, PSTR("G29 P4 T"));
MENU_ITEM(submenu, MSG_UBL_MESH_HEIGHT_ADJUST, _lcd_ubl_height_adjust_menu);
2017-05-30 02:55:26 +02:00
MENU_ITEM(function, MSG_WATCH, lcd_return_to_status);
2017-05-25 22:13:57 +02:00
END_MENU();
}
2017-05-25 22:13:57 +02:00
/**
* UBL Validate Custom Mesh Command
*/
void _lcd_ubl_validate_custom_mesh() {
char UBL_LCD_GCODE[24];
const int temp =
#if HAS_TEMP_BED
2017-05-25 22:13:57 +02:00
custom_bed_temp
#else
2017-05-25 22:13:57 +02:00
0
#endif
2017-05-25 22:13:57 +02:00
;
sprintf_P(UBL_LCD_GCODE, PSTR("G28\nG26 C B%i H%i P"), temp, custom_hotend_temp);
enqueue_and_echo_command(UBL_LCD_GCODE);
}
2017-05-25 22:13:57 +02:00
/**
* UBL Validate Mesh submenu
*
* << UBL Tools
* PLA Mesh Validation
* ABS Mesh Validation
* Validate Custom Mesh
* << Info Screen
2017-05-25 22:13:57 +02:00
*/
void _lcd_ubl_validate_mesh() {
START_MENU();
MENU_BACK(MSG_UBL_TOOLS);
#if HAS_TEMP_BED
2017-05-25 22:13:57 +02:00
MENU_ITEM(gcode, MSG_UBL_VALIDATE_PLA_MESH, PSTR("G28\nG26 C B" STRINGIFY(PREHEAT_1_TEMP_BED) " H" STRINGIFY(PREHEAT_1_TEMP_HOTEND) " P"));
MENU_ITEM(gcode, MSG_UBL_VALIDATE_ABS_MESH, PSTR("G28\nG26 C B" STRINGIFY(PREHEAT_2_TEMP_BED) " H" STRINGIFY(PREHEAT_2_TEMP_HOTEND) " P"));
#else
MENU_ITEM(gcode, MSG_UBL_VALIDATE_PLA_MESH, PSTR("G28\nG26 C B0 H" STRINGIFY(PREHEAT_1_TEMP_HOTEND) " P"));
MENU_ITEM(gcode, MSG_UBL_VALIDATE_ABS_MESH, PSTR("G28\nG26 C B0 H" STRINGIFY(PREHEAT_2_TEMP_HOTEND) " P"));
#endif
MENU_ITEM(function, MSG_UBL_VALIDATE_CUSTOM_MESH, _lcd_ubl_validate_custom_mesh);
2017-05-30 02:55:26 +02:00
MENU_ITEM(function, MSG_WATCH, lcd_return_to_status);
2017-05-25 22:13:57 +02:00
END_MENU();
}
2017-05-25 22:13:57 +02:00
/**
* UBL Grid Leveling Command
*/
void _lcd_ubl_grid_level_cmd() {
char UBL_LCD_GCODE[10];
sprintf_P(UBL_LCD_GCODE, PSTR("G29 J%i"), side_points);
enqueue_and_echo_command(UBL_LCD_GCODE);
}
2017-05-25 22:13:57 +02:00
/**
* UBL Grid Leveling submenu
*
* << UBL Tools
* Side points: ---
* Level Mesh
2017-05-25 22:13:57 +02:00
*/
void _lcd_ubl_grid_level() {
START_MENU();
MENU_BACK(MSG_UBL_TOOLS);
MENU_ITEM_EDIT(int3, MSG_UBL_SIDE_POINTS, &side_points, 2, 6);
MENU_ITEM(function, MSG_UBL_MESH_LEVEL, _lcd_ubl_grid_level_cmd);
END_MENU();
}
2017-05-25 22:13:57 +02:00
/**
* UBL Mesh Leveling submenu
*
* << UBL Tools
* 3-Point Mesh Leveling
* - Grid Mesh Leveling >>
* << Info Screen
2017-05-25 22:13:57 +02:00
*/
void _lcd_ubl_mesh_leveling() {
START_MENU();
MENU_BACK(MSG_UBL_TOOLS);
MENU_ITEM(gcode, MSG_UBL_3POINT_MESH_LEVELING, PSTR("G29 J0"));
MENU_ITEM(submenu, MSG_UBL_GRID_MESH_LEVELING, _lcd_ubl_grid_level);
2017-05-30 02:55:26 +02:00
MENU_ITEM(function, MSG_WATCH, lcd_return_to_status);
2017-05-25 22:13:57 +02:00
END_MENU();
}
2017-05-25 22:13:57 +02:00
/**
* UBL Fill-in Amount Mesh Command
*/
void _lcd_ubl_fillin_amount_cmd() {
char UBL_LCD_GCODE[16];
sprintf_P(UBL_LCD_GCODE, PSTR("G29 P3 R C.%i"), ubl_fillin_amount);
enqueue_and_echo_command(UBL_LCD_GCODE);
}
2017-05-25 22:13:57 +02:00
/**
* UBL Smart Fill-in Command
*/
void _lcd_ubl_smart_fillin_cmd() {
char UBL_LCD_GCODE[12];
sprintf_P(UBL_LCD_GCODE, PSTR("G29 P3 T0"));
2017-05-25 22:13:57 +02:00
enqueue_and_echo_command(UBL_LCD_GCODE);
}
2017-05-25 22:13:57 +02:00
/**
* UBL Fill-in Mesh submenu
*
* << Build Mesh
* Fill-in Amount: ---
* Fill-in Mesh
* Smart Fill-in
* Manual Fill-in
* << Info Screen
2017-05-25 22:13:57 +02:00
*/
void _lcd_ubl_fillin_menu() {
START_MENU();
MENU_BACK(MSG_UBL_BUILD_MESH_MENU);
2017-09-01 23:59:06 +02:00
MENU_ITEM_EDIT_CALLBACK(int3, MSG_UBL_FILLIN_AMOUNT, &ubl_fillin_amount, 0, 9, _lcd_ubl_fillin_amount_cmd);
2017-05-25 22:13:57 +02:00
MENU_ITEM(function, MSG_UBL_SMART_FILLIN, _lcd_ubl_smart_fillin_cmd);
MENU_ITEM(gcode, MSG_UBL_MANUAL_FILLIN, PSTR("G29 P2 B T0"));
2017-05-30 02:55:26 +02:00
MENU_ITEM(function, MSG_WATCH, lcd_return_to_status);
2017-05-25 22:13:57 +02:00
END_MENU();
}
2017-05-25 22:13:57 +02:00
void _lcd_ubl_invalidate() {
ubl.invalidate();
SERIAL_PROTOCOLLNPGM("Mesh invalidated.");
}
2017-05-25 22:13:57 +02:00
/**
* UBL Build Mesh submenu
*
* << UBL Tools
* Build PLA Mesh
* Build ABS Mesh
* - Build Custom Mesh >>
* Build Cold Mesh
* - Fill-in Mesh >>
* Continue Bed Mesh
* Invalidate All
* Invalidate Closest
* << Info Screen
2017-05-25 22:13:57 +02:00
*/
void _lcd_ubl_build_mesh() {
START_MENU();
MENU_BACK(MSG_UBL_TOOLS);
#if HAS_TEMP_BED
2017-05-25 22:13:57 +02:00
MENU_ITEM(gcode, MSG_UBL_BUILD_PLA_MESH, PSTR(
"G28\n"
"M190 S" STRINGIFY(PREHEAT_1_TEMP_BED) "\n"
"M109 S" STRINGIFY(PREHEAT_1_TEMP_HOTEND) "\n"
"G29 P1\n"
"M104 S0\n"
"M140 S0"
));
MENU_ITEM(gcode, MSG_UBL_BUILD_ABS_MESH, PSTR(
"G28\n"
"M190 S" STRINGIFY(PREHEAT_2_TEMP_BED) "\n"
"M109 S" STRINGIFY(PREHEAT_2_TEMP_HOTEND) "\n"
"G29 P1\n"
"M104 S0\n"
"M140 S0"
));
#else
MENU_ITEM(gcode, MSG_UBL_BUILD_PLA_MESH, PSTR(
"G28\n"
"M109 S" STRINGIFY(PREHEAT_1_TEMP_HOTEND) "\n"
"G29 P1\n"
"M104 S0"
));
MENU_ITEM(gcode, MSG_UBL_BUILD_ABS_MESH, PSTR(
"G28\n"
"M109 S" STRINGIFY(PREHEAT_2_TEMP_HOTEND) "\n"
"G29 P1\n"
"M104 S0"
));
#endif
MENU_ITEM(submenu, MSG_UBL_BUILD_CUSTOM_MESH, _lcd_ubl_custom_mesh);
MENU_ITEM(gcode, MSG_UBL_BUILD_COLD_MESH, PSTR("G28\nG29 P1"));
MENU_ITEM(submenu, MSG_UBL_FILLIN_MESH, _lcd_ubl_fillin_menu);
MENU_ITEM(gcode, MSG_UBL_CONTINUE_MESH, PSTR("G29 P1 C"));
MENU_ITEM(function, MSG_UBL_INVALIDATE_ALL, _lcd_ubl_invalidate);
MENU_ITEM(gcode, MSG_UBL_INVALIDATE_CLOSEST, PSTR("G29 I"));
2017-05-30 02:55:26 +02:00
MENU_ITEM(function, MSG_WATCH, lcd_return_to_status);
2017-05-25 22:13:57 +02:00
END_MENU();
}
2017-05-25 22:13:57 +02:00
/**
* UBL Load Mesh Command
*/
void _lcd_ubl_load_mesh_cmd() {
char UBL_LCD_GCODE[25];
2017-05-25 22:13:57 +02:00
sprintf_P(UBL_LCD_GCODE, PSTR("G29 L%i"), ubl_storage_slot);
enqueue_and_echo_command(UBL_LCD_GCODE);
sprintf_P(UBL_LCD_GCODE, PSTR("M117 " MSG_MESH_LOADED "."), ubl_storage_slot);
enqueue_and_echo_command(UBL_LCD_GCODE);
2017-05-25 22:13:57 +02:00
}
2017-05-25 22:13:57 +02:00
/**
* UBL Save Mesh Command
*/
void _lcd_ubl_save_mesh_cmd() {
char UBL_LCD_GCODE[25];
2017-05-25 22:13:57 +02:00
sprintf_P(UBL_LCD_GCODE, PSTR("G29 S%i"), ubl_storage_slot);
enqueue_and_echo_command(UBL_LCD_GCODE);
sprintf_P(UBL_LCD_GCODE, PSTR("M117 " MSG_MESH_SAVED "."), ubl_storage_slot);
enqueue_and_echo_command(UBL_LCD_GCODE);
2017-05-25 22:13:57 +02:00
}
2017-05-25 22:13:57 +02:00
/**
* UBL Mesh Storage submenu
*
* << Unified Bed Leveling
* Memory Slot: ---
* Load Bed Mesh
* Save Bed Mesh
2017-05-25 22:13:57 +02:00
*/
void _lcd_ubl_storage_mesh() {
int16_t a = settings.calc_num_meshes();
2017-05-25 22:13:57 +02:00
START_MENU();
MENU_BACK(MSG_UBL_LEVEL_BED);
if (!WITHIN(ubl_storage_slot, 0, a - 1)) {
STATIC_ITEM(MSG_NO_STORAGE);
STATIC_ITEM(MSG_INIT_EEPROM);
}
else {
MENU_ITEM_EDIT(int3, MSG_UBL_STORAGE_SLOT, &ubl_storage_slot, 0, a - 1);
MENU_ITEM(function, MSG_UBL_LOAD_MESH, _lcd_ubl_load_mesh_cmd);
MENU_ITEM(function, MSG_UBL_SAVE_MESH, _lcd_ubl_save_mesh_cmd);
}
2017-05-25 22:13:57 +02:00
END_MENU();
}
2017-05-25 22:13:57 +02:00
/**
* UBL LCD "radar" map homing
2017-05-25 22:13:57 +02:00
*/
void _lcd_ubl_output_map_lcd();
void _lcd_ubl_map_homing() {
2017-07-02 01:33:54 +02:00
defer_return_to_status = true;
ubl.lcd_map_control = true; // Return to the map screen
if (lcdDrawUpdate) lcd_implementation_drawmenu_static(LCD_HEIGHT < 3 ? 0 : (LCD_HEIGHT > 4 ? 2 : 1), PSTR(MSG_LEVEL_BED_HOMING));
lcdDrawUpdate = LCDVIEW_CALL_NO_REDRAW;
if (axis_homed[X_AXIS] && axis_homed[Y_AXIS] && axis_homed[Z_AXIS])
lcd_goto_screen(_lcd_ubl_output_map_lcd);
}
/**
* UBL LCD "radar" map point editing
*/
void _lcd_ubl_map_lcd_edit_cmd() {
char ubl_lcd_gcode [50], str[10], str2[10];
dtostrf(pgm_read_float(&ubl._mesh_index_to_xpos[x_plot]), 0, 2, str);
dtostrf(pgm_read_float(&ubl._mesh_index_to_ypos[y_plot]), 0, 2, str2);
snprintf_P(ubl_lcd_gcode, sizeof(ubl_lcd_gcode), PSTR("G29 P4 X%s Y%s R%i"), str, str2, n_edit_pts);
enqueue_and_echo_command(ubl_lcd_gcode);
}
/**
* UBL LCD Map Movement
*/
void ubl_map_move_to_xy() {
2017-11-03 02:17:51 +01:00
current_position[X_AXIS] = pgm_read_float(&ubl._mesh_index_to_xpos[x_plot]);
current_position[Y_AXIS] = pgm_read_float(&ubl._mesh_index_to_ypos[y_plot]);
planner.buffer_line_kinematic(current_position, MMM_TO_MMS(XY_PROBE_SPEED), active_extruder);
}
/**
* UBL LCD "radar" map
*/
void set_current_from_steppers_for_axis(const AxisEnum axis);
void sync_plan_position();
void _lcd_ubl_output_map_lcd() {
2017-06-16 20:01:52 +02:00
static int16_t step_scaler = 0;
2017-07-02 01:34:52 +02:00
if (!(axis_known_position[X_AXIS] && axis_known_position[Y_AXIS] && axis_known_position[Z_AXIS]))
return lcd_goto_screen(_lcd_ubl_map_homing);
2017-07-02 01:37:33 +02:00
if (lcd_clicked) return _lcd_ubl_map_lcd_edit_cmd();
ENCODER_DIRECTION_NORMAL();
2017-07-02 01:37:33 +02:00
if (encoderPosition) {
step_scaler += (int32_t)encoderPosition;
x_plot += step_scaler / (ENCODER_STEPS_PER_MENU_ITEM);
if (abs(step_scaler) >= ENCODER_STEPS_PER_MENU_ITEM)
step_scaler = 0;
refresh_cmd_timeout();
2017-07-02 01:37:33 +02:00
encoderPosition = 0;
lcdDrawUpdate = LCDVIEW_REDRAW_NOW;
}
2017-07-02 01:37:33 +02:00
// Encoder to the right (++)
if (x_plot >= GRID_MAX_POINTS_X) { x_plot = 0; y_plot++; }
if (y_plot >= GRID_MAX_POINTS_Y) y_plot = 0;
2017-07-02 01:37:33 +02:00
// Encoder to the left (--)
if (x_plot <= GRID_MAX_POINTS_X - (GRID_MAX_POINTS_X + 1)) { x_plot = GRID_MAX_POINTS_X - 1; y_plot--; }
if (y_plot <= GRID_MAX_POINTS_Y - (GRID_MAX_POINTS_Y + 1)) y_plot = GRID_MAX_POINTS_Y - 1;
2017-07-02 01:37:33 +02:00
// Prevent underrun/overrun of plot numbers
x_plot = constrain(x_plot, GRID_MAX_POINTS_X - (GRID_MAX_POINTS_X + 1), GRID_MAX_POINTS_X + 1);
y_plot = constrain(y_plot, GRID_MAX_POINTS_Y - (GRID_MAX_POINTS_Y + 1), GRID_MAX_POINTS_Y + 1);
2017-07-02 01:37:33 +02:00
// Determine number of points to edit
#if IS_KINEMATIC
n_edit_pts = 9; //TODO: Delta accessible edit points
#else
const bool xc = WITHIN(x_plot, 1, GRID_MAX_POINTS_X - 2),
yc = WITHIN(y_plot, 1, GRID_MAX_POINTS_Y - 2);
n_edit_pts = yc ? (xc ? 9 : 6) : (xc ? 6 : 4); // Corners
#endif
2017-07-02 01:37:33 +02:00
if (lcdDrawUpdate) {
lcd_implementation_ubl_plot(x_plot, y_plot);
2017-07-02 01:37:33 +02:00
ubl_map_move_to_xy(); // Move to current location
if (planner.movesplanned() > 1) { // if the nozzle is moving, cancel the move. There is a new location
stepper.quick_stop();
set_current_from_steppers_for_axis(ALL_AXES);
sync_plan_position();
2017-07-02 01:37:33 +02:00
ubl_map_move_to_xy(); // Move to new location
refresh_cmd_timeout();
}
2017-07-02 01:37:33 +02:00
}
}
/**
* UBL Homing before LCD map
*/
void _lcd_ubl_output_map_lcd_cmd() {
if (!(axis_known_position[X_AXIS] && axis_known_position[Y_AXIS] && axis_known_position[Z_AXIS])) {
axis_homed[X_AXIS] = axis_homed[Y_AXIS] = axis_homed[Z_AXIS] = false;
enqueue_and_echo_commands_P(PSTR("G28"));
}
2017-06-15 22:10:45 +02:00
lcd_goto_screen(_lcd_ubl_map_homing);
2017-05-25 22:13:57 +02:00
}
2017-05-25 22:13:57 +02:00
/**
* UBL Output map submenu
*
* << Unified Bed Leveling
* Output for Host
* Output for CSV
* Off Printer Backup
* Output Mesh Map
2017-05-25 22:13:57 +02:00
*/
void _lcd_ubl_output_map() {
START_MENU();
MENU_BACK(MSG_UBL_LEVEL_BED);
MENU_ITEM(gcode, MSG_UBL_OUTPUT_MAP_HOST, PSTR("G29 T0"));
MENU_ITEM(gcode, MSG_UBL_OUTPUT_MAP_CSV, PSTR("G29 T1"));
MENU_ITEM(gcode, MSG_UBL_OUTPUT_MAP_BACKUP, PSTR("G29 S-1"));
MENU_ITEM(function, MSG_UBL_OUTPUT_MAP, _lcd_ubl_output_map_lcd_cmd);
2017-05-25 22:13:57 +02:00
END_MENU();
}
2017-05-25 22:13:57 +02:00
/**
* UBL Tools submenu
*
* << Unified Bed Leveling
* - Build Mesh >>
* - Validate Mesh >>
* - Edit Mesh >>
* - Mesh Leveling >>
2017-05-25 22:13:57 +02:00
*/
void _lcd_ubl_tools_menu() {
START_MENU();
MENU_BACK(MSG_UBL_LEVEL_BED);
MENU_ITEM(submenu, MSG_UBL_BUILD_MESH_MENU, _lcd_ubl_build_mesh);
MENU_ITEM(gcode, MSG_UBL_MANUAL_MESH, PSTR("G29 I999\nG29 P2 B T0"));
2017-05-25 22:13:57 +02:00
MENU_ITEM(submenu, MSG_UBL_VALIDATE_MESH_MENU, _lcd_ubl_validate_mesh);
MENU_ITEM(submenu, MSG_UBL_EDIT_MESH_MENU, _lcd_ubl_edit_mesh);
MENU_ITEM(submenu, MSG_UBL_MESH_LEVELING, _lcd_ubl_mesh_leveling);
END_MENU();
}
2017-06-06 06:03:22 +02:00
/**
* UBL Step-By-Step submenu
*
* << Unified Bed Leveling
* 1 Build Cold Mesh
* 2 Smart Fill-in
* - 3 Validate Mesh >>
* 4 Fine Tune All
* - 5 Validate Mesh >>
* 6 Fine Tune All
* 7 Save Bed Mesh
2017-06-06 06:03:22 +02:00
*/
void _lcd_ubl_step_by_step() {
START_MENU();
MENU_BACK(MSG_UBL_LEVEL_BED);
MENU_ITEM(gcode, "1 " MSG_UBL_BUILD_COLD_MESH, PSTR("G28\nG29 P1"));
MENU_ITEM(function, "2 " MSG_UBL_SMART_FILLIN, _lcd_ubl_smart_fillin_cmd);
MENU_ITEM(submenu, "3 " MSG_UBL_VALIDATE_MESH_MENU, _lcd_ubl_validate_mesh);
MENU_ITEM(gcode, "4 " MSG_UBL_FINE_TUNE_ALL, PSTR("G29 P4 R999 T"));
MENU_ITEM(submenu, "5 " MSG_UBL_VALIDATE_MESH_MENU, _lcd_ubl_validate_mesh);
MENU_ITEM(gcode, "6 " MSG_UBL_FINE_TUNE_ALL, PSTR("G29 P4 R999 T"));
MENU_ITEM(function, "7 " MSG_UBL_SAVE_MESH, _lcd_ubl_save_mesh_cmd);
END_MENU();
}
2017-05-25 22:13:57 +02:00
/**
* UBL System submenu
*
* << Prepare
* - Manually Build Mesh >>
* - Activate UBL >>
* - Deactivate UBL >>
* - Step-By-Step UBL >>
* - Mesh Storage >>
* - Output Map >>
* - UBL Tools >>
* - Output UBL Info >>
2017-05-25 22:13:57 +02:00
*/
2017-05-25 22:13:57 +02:00
void _lcd_ubl_level_bed() {
START_MENU();
MENU_BACK(MSG_PREPARE);
MENU_ITEM(gcode, MSG_UBL_ACTIVATE_MESH, PSTR("G29 A"));
MENU_ITEM(gcode, MSG_UBL_DEACTIVATE_MESH, PSTR("G29 D"));
2017-06-06 06:03:22 +02:00
MENU_ITEM(submenu, MSG_UBL_STEP_BY_STEP_MENU, _lcd_ubl_step_by_step);
MENU_ITEM(function, MSG_UBL_MESH_EDIT, _lcd_ubl_output_map_lcd_cmd);
2017-05-25 22:13:57 +02:00
MENU_ITEM(submenu, MSG_UBL_STORAGE_MESH_MENU, _lcd_ubl_storage_mesh);
MENU_ITEM(submenu, MSG_UBL_OUTPUT_MAP, _lcd_ubl_output_map);
MENU_ITEM(submenu, MSG_UBL_TOOLS, _lcd_ubl_tools_menu);
MENU_ITEM(gcode, MSG_UBL_INFO_UBL, PSTR("G29 W"));
END_MENU();
}
#endif // AUTO_BED_LEVELING_UBL
2016-04-03 07:46:15 +02:00
/**
2016-06-11 23:12:00 +02:00
*
* "Prepare" submenu
*
2016-04-03 07:46:15 +02:00
*/
2016-06-11 23:12:00 +02:00
void lcd_prepare_menu() {
2016-04-03 07:46:15 +02:00
START_MENU();
2016-06-11 23:12:00 +02:00
//
// ^ Main
//
MENU_BACK(MSG_MAIN);
2016-04-03 07:46:15 +02:00
//
// Move Axis
//
#if ENABLED(DELTA)
2017-11-08 09:43:29 +01:00
if (axis_homed[X_AXIS] && axis_homed[Y_AXIS] && axis_homed[Z_AXIS])
#endif
MENU_ITEM(submenu, MSG_MOVE_AXIS, lcd_move_menu);
2016-06-11 23:12:00 +02:00
//
// Auto Home
//
MENU_ITEM(gcode, MSG_AUTO_HOME, PSTR("G28"));
#if ENABLED(INDIVIDUAL_AXIS_HOMING_MENU)
MENU_ITEM(gcode, MSG_AUTO_HOME_X, PSTR("G28 X"));
MENU_ITEM(gcode, MSG_AUTO_HOME_Y, PSTR("G28 Y"));
MENU_ITEM(gcode, MSG_AUTO_HOME_Z, PSTR("G28 Z"));
#endif
2016-06-11 23:12:00 +02:00
//
// Level Bed
//
2017-05-25 22:13:57 +02:00
#if ENABLED(AUTO_BED_LEVELING_UBL)
MENU_ITEM(submenu, MSG_UBL_LEVEL_BED, _lcd_ubl_level_bed);
#elif ENABLED(LCD_BED_LEVELING)
#if ENABLED(PROBE_MANUALLY)
if (!g29_in_progress)
#endif
2017-10-14 04:35:25 +02:00
MENU_ITEM(submenu, MSG_BED_LEVELING,
#if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
_lcd_goto_bed_leveling
#else
lcd_bed_leveling
#endif
);
2017-08-16 09:27:50 +02:00
#else
#if PLANNER_LEVELING
MENU_ITEM(gcode, MSG_BED_LEVELING, PSTR("G28\nG29"));
#endif
#if ENABLED(LEVEL_BED_CORNERS)
if (axis_homed[X_AXIS] && axis_homed[Y_AXIS] && axis_homed[Z_AXIS])
MENU_ITEM(function, MSG_LEVEL_CORNERS, _lcd_level_bed_corners);
#endif
2017-05-25 22:13:57 +02:00
#endif
#if HAS_M206_COMMAND
2017-03-06 09:20:31 +01:00
//
// Set Home Offsets
//
MENU_ITEM(function, MSG_SET_HOME_OFFSETS, lcd_set_home_offsets);
//MENU_ITEM(gcode, MSG_SET_ORIGIN, PSTR("G92 X0 Y0 Z0"));
#endif
2016-06-11 23:12:00 +02:00
//
// Disable Steppers
//
MENU_ITEM(gcode, MSG_DISABLE_STEPPERS, PSTR("M84"));
2016-06-11 23:12:00 +02:00
//
// Change filament
2016-06-11 23:12:00 +02:00
//
#if ENABLED(ADVANCED_PAUSE_FEATURE)
if (!thermalManager.tooColdToExtrude(active_extruder) && !IS_SD_FILE_OPEN)
MENU_ITEM(function, MSG_FILAMENTCHANGE, lcd_enqueue_filament_change);
#endif
2017-02-18 06:57:13 +01:00
#if TEMP_SENSOR_0 != 0
2017-03-06 05:08:26 +01:00
2017-03-06 05:06:44 +01:00
//
// Cooldown
//
bool has_heat = false;
HOTEND_LOOP() if (thermalManager.target_temperature[HOTEND_INDEX]) { has_heat = true; break; }
#if HAS_TEMP_BED
if (thermalManager.target_temperature_bed) has_heat = true;
#endif
if (has_heat) MENU_ITEM(function, MSG_COOLDOWN, lcd_cooldown);
//
// Preheat for Material 1 and 2
//
#if TEMP_SENSOR_1 != 0 || TEMP_SENSOR_2 != 0 || TEMP_SENSOR_3 != 0 || TEMP_SENSOR_4 != 0 || TEMP_SENSOR_BED != 0
2017-03-06 05:10:19 +01:00
MENU_ITEM(submenu, MSG_PREHEAT_1, lcd_preheat_m1_menu);
MENU_ITEM(submenu, MSG_PREHEAT_2, lcd_preheat_m2_menu);
2016-06-11 23:12:00 +02:00
#else
2017-03-06 05:10:19 +01:00
MENU_ITEM(function, MSG_PREHEAT_1, lcd_preheat_m1_e0_only);
MENU_ITEM(function, MSG_PREHEAT_2, lcd_preheat_m2_e0_only);
2016-06-11 23:12:00 +02:00
#endif
2017-02-18 06:57:13 +01:00
#endif // TEMP_SENSOR_0 != 0
2016-09-20 20:56:23 +02:00
//
// BLTouch Self-Test and Reset
//
#if ENABLED(BLTOUCH)
2016-09-21 08:33:30 +02:00
MENU_ITEM(gcode, MSG_BLTOUCH_SELFTEST, PSTR("M280 P" STRINGIFY(Z_ENDSTOP_SERVO_NR) " S" STRINGIFY(BLTOUCH_SELFTEST)));
2016-09-20 20:56:23 +02:00
if (!endstops.z_probe_enabled && TEST_BLTOUCH())
MENU_ITEM(gcode, MSG_BLTOUCH_RESET, PSTR("M280 P" STRINGIFY(Z_ENDSTOP_SERVO_NR) " S" STRINGIFY(BLTOUCH_RESET)));
#endif
2016-06-11 23:12:00 +02:00
//
// Switch power on/off
//
#if HAS_POWER_SWITCH
if (powersupply_on)
2016-06-11 23:12:00 +02:00
MENU_ITEM(gcode, MSG_SWITCH_PS_OFF, PSTR("M81"));
else
MENU_ITEM(gcode, MSG_SWITCH_PS_ON, PSTR("M80"));
#endif
2016-06-11 23:12:00 +02:00
//
// Autostart
//
#if ENABLED(SDSUPPORT) && ENABLED(MENU_ADDAUTOSTART)
MENU_ITEM(function, MSG_AUTOSTART, lcd_autostart_sd);
#endif
//
// Delta Calibration
//
2017-11-08 09:43:29 +01:00
#if ENABLED(DELTA_CALIBRATION_MENU) || ENABLED(DELTA_AUTO_CALIBRATION)
MENU_ITEM(submenu, MSG_DELTA_CALIBRATE, lcd_delta_calibrate_menu);
#endif
2016-06-11 23:12:00 +02:00
END_MENU();
}
2016-12-13 07:03:54 +01:00
float move_menu_scale;
2017-11-08 02:47:45 +01:00
#if ENABLED(DELTA_CALIBRATION_MENU) || (ENABLED(DELTA_AUTO_CALIBRATION) && !HAS_BED_PROBE)
2016-12-13 07:03:54 +01:00
void lcd_move_z();
2017-11-03 02:17:51 +01:00
void _man_probe_pt(const float rx, const float ry) {
2017-05-21 02:23:39 +02:00
#if HAS_LEVELING
reset_bed_level(); // After calibration bed-level data is no longer valid
#endif
2017-11-03 02:17:51 +01:00
line_to_z((Z_CLEARANCE_BETWEEN_PROBES) + (DELTA_PRINTABLE_RADIUS) / 5);
current_position[X_AXIS] = rx;
current_position[Y_AXIS] = ry;
line_to_current_z();
2017-11-03 02:17:51 +01:00
line_to_z(Z_CLEARANCE_BETWEEN_PROBES);
2016-12-13 07:03:54 +01:00
lcd_synchronize();
2017-07-07 09:43:33 +02:00
move_menu_scale = PROBE_MANUALLY_STEP;
2016-12-13 07:03:54 +01:00
lcd_goto_screen(lcd_move_z);
}
2017-11-08 02:47:45 +01:00
#endif // DELTA_CALIBRATION_MENU || (DELTA_AUTO_CALIBRATION && !HAS_BED_PROBE)
#if ENABLED(DELTA_AUTO_CALIBRATION) && !HAS_BED_PROBE
2017-11-03 02:17:51 +01:00
float lcd_probe_pt(const float &rx, const float &ry) {
_man_probe_pt(rx, ry);
2017-07-03 17:06:23 +02:00
KEEPALIVE_STATE(PAUSED_FOR_USER);
2017-07-07 09:43:33 +02:00
defer_return_to_status = true;
2017-07-03 17:06:23 +02:00
wait_for_user = true;
while (wait_for_user) idle();
KEEPALIVE_STATE(IN_HANDLER);
2017-08-16 09:27:50 +02:00
lcd_goto_previous_menu_no_defer();
2017-07-03 17:06:23 +02:00
return current_position[Z_AXIS];
}
2017-11-08 02:47:45 +01:00
#endif // DELTA_AUTO_CALIBRATION && !HAS_BED_PROBE
#if ENABLED(DELTA_CALIBRATION_MENU)
void _lcd_calibrate_homing() {
if (lcdDrawUpdate) lcd_implementation_drawmenu_static(LCD_HEIGHT >= 4 ? 1 : 0, PSTR(MSG_LEVEL_BED_HOMING));
lcdDrawUpdate = LCDVIEW_CALL_REDRAW_NEXT;
if (axis_homed[X_AXIS] && axis_homed[Y_AXIS] && axis_homed[Z_AXIS])
lcd_goto_previous_menu();
}
void _lcd_delta_calibrate_home() {
#if HAS_LEVELING
reset_bed_level(); // After calibration bed-level data is no longer valid
#endif
enqueue_and_echo_commands_P(PSTR("G28"));
lcd_goto_screen(_lcd_calibrate_homing);
}
2017-07-03 17:06:23 +02:00
void _goto_tower_x() { _man_probe_pt(cos(RADIANS(210)) * delta_calibration_radius, sin(RADIANS(210)) * delta_calibration_radius); }
void _goto_tower_y() { _man_probe_pt(cos(RADIANS(330)) * delta_calibration_radius, sin(RADIANS(330)) * delta_calibration_radius); }
void _goto_tower_z() { _man_probe_pt(cos(RADIANS( 90)) * delta_calibration_radius, sin(RADIANS( 90)) * delta_calibration_radius); }
void _goto_center() { _man_probe_pt(0,0); }
2017-11-08 09:43:29 +01:00
#endif // DELTA_CALIBRATION_MENU
#if ENABLED(DELTA_CALIBRATION_MENU) || ENABLED(DELTA_AUTO_CALIBRATION)
void lcd_delta_settings() {
2017-07-07 09:43:33 +02:00
START_MENU();
MENU_BACK(MSG_DELTA_CALIBRATE);
2017-11-08 09:43:29 +01:00
MENU_ITEM_EDIT_CALLBACK(float52, MSG_DELTA_DIAG_ROG, &delta_diagonal_rod, delta_diagonal_rod - 5.0, delta_diagonal_rod + 5.0, recalc_delta_settings);
MENU_ITEM_EDIT_CALLBACK(float52, MSG_DELTA_HEIGHT, &delta_height, delta_height - 10.0, delta_height + 10.0, recalc_delta_settings);
MENU_ITEM_EDIT_CALLBACK(float43, "Ex", &delta_endstop_adj[A_AXIS], -5.0, 5.0, recalc_delta_settings);
MENU_ITEM_EDIT_CALLBACK(float43, "Ey", &delta_endstop_adj[B_AXIS], -5.0, 5.0, recalc_delta_settings);
MENU_ITEM_EDIT_CALLBACK(float43, "Ez", &delta_endstop_adj[C_AXIS], -5.0, 5.0, recalc_delta_settings);
MENU_ITEM_EDIT_CALLBACK(float52, MSG_DELTA_RADIUS, &delta_radius, delta_radius - 5.0, delta_radius + 5.0, recalc_delta_settings);
MENU_ITEM_EDIT_CALLBACK(float43, "Tx", &delta_tower_angle_trim[A_AXIS], -5.0, 5.0, recalc_delta_settings);
MENU_ITEM_EDIT_CALLBACK(float43, "Ty", &delta_tower_angle_trim[B_AXIS], -5.0, 5.0, recalc_delta_settings);
MENU_ITEM_EDIT_CALLBACK(float43, "Tz", &delta_tower_angle_trim[C_AXIS], -5.0, 5.0, recalc_delta_settings);
2017-07-07 09:43:33 +02:00
END_MENU();
}
void lcd_delta_calibrate_menu() {
2016-06-11 23:12:00 +02:00
START_MENU();
MENU_BACK(MSG_MAIN);
#if ENABLED(DELTA_AUTO_CALIBRATION)
2017-04-29 00:17:01 +02:00
MENU_ITEM(gcode, MSG_DELTA_AUTO_CALIBRATE, PSTR("G33"));
MENU_ITEM(gcode, MSG_DELTA_HEIGHT_CALIBRATE, PSTR("G33 P1"));
2017-07-07 09:43:33 +02:00
#if ENABLED(EEPROM_SETTINGS)
MENU_ITEM(function, MSG_STORE_EEPROM, lcd_store_settings);
MENU_ITEM(function, MSG_LOAD_EEPROM, lcd_load_settings);
#endif
#endif
2017-11-08 09:43:29 +01:00
MENU_ITEM(submenu, MSG_DELTA_SETTINGS, lcd_delta_settings);
#if ENABLED(DELTA_CALIBRATION_MENU)
MENU_ITEM(submenu, MSG_AUTO_HOME, _lcd_delta_calibrate_home);
if (axis_homed[X_AXIS] && axis_homed[Y_AXIS] && axis_homed[Z_AXIS]) {
MENU_ITEM(submenu, MSG_DELTA_CALIBRATE_X, _goto_tower_x);
MENU_ITEM(submenu, MSG_DELTA_CALIBRATE_Y, _goto_tower_y);
MENU_ITEM(submenu, MSG_DELTA_CALIBRATE_Z, _goto_tower_z);
MENU_ITEM(submenu, MSG_DELTA_CALIBRATE_CENTER, _goto_center);
}
#endif
2016-06-11 23:12:00 +02:00
END_MENU();
}
2017-11-08 09:43:29 +01:00
#endif // DELTA_CALIBRATION_MENU || DELTA_AUTO_CALIBRATION
2017-10-10 02:54:15 +02:00
#if IS_KINEMATIC
extern float feedrate_mm_s;
extern float destination[XYZE];
void set_destination_from_current();
2017-10-10 02:54:15 +02:00
void prepare_move_to_destination();
#endif
2016-06-11 23:12:00 +02:00
/**
* If the most recent manual move hasn't been fed to the planner yet,
* and the planner can accept one, send immediately
*/
inline void manage_manual_move() {
2017-10-10 02:54:15 +02:00
if (processing_manual_move) return;
2016-07-13 02:13:56 +02:00
if (manual_move_axis != (int8_t)NO_AXIS && ELAPSED(millis(), manual_move_start_time) && !planner.is_full()) {
2017-10-10 02:54:15 +02:00
#if IS_KINEMATIC
const float old_feedrate = feedrate_mm_s;
feedrate_mm_s = MMM_TO_MMS(manual_feedrate_mm_m[manual_move_axis]);
#if EXTRUDERS > 1
const int8_t old_extruder = active_extruder;
active_extruder = manual_move_e_index;
#endif
// Set movement on a single axis
set_destination_from_current();
2017-10-10 02:54:15 +02:00
destination[manual_move_axis] += manual_move_offset;
// Reset for the next move
manual_move_offset = 0.0;
manual_move_axis = (int8_t)NO_AXIS;
// DELTA and SCARA machines use segmented moves, which could fill the planner during the call to
// move_to_destination. This will cause idle() to be called, which can then call this function while the
// previous invocation is being blocked. Modifications to manual_move_offset shouldn't be made while
// processing_manual_move is true or the planner will get out of sync.
processing_manual_move = true;
prepare_move_to_destination(); // will call set_current_from_destination()
2017-10-10 02:54:15 +02:00
processing_manual_move = false;
feedrate_mm_s = old_feedrate;
#if EXTRUDERS > 1
active_extruder = old_extruder;
#endif
#else
planner.buffer_line_kinematic(current_position, MMM_TO_MMS(manual_feedrate_mm_m[manual_move_axis]), manual_move_e_index);
manual_move_axis = (int8_t)NO_AXIS;
#endif
2016-06-11 23:12:00 +02:00
}
}
2016-06-11 23:12:00 +02:00
/**
* Set a flag that lcd_update() should start a move
* to "current_position" after a short delay.
*/
inline void manual_move_to_current(AxisEnum axis
#if E_MANUAL > 1
, int8_t eindex=-1
#endif
) {
#if ENABLED(DUAL_X_CARRIAGE) || E_MANUAL > 1
#if E_MANUAL > 1
if (axis == E_AXIS)
#endif
manual_move_e_index = eindex >= 0 ? eindex : active_extruder;
#endif
2016-07-13 02:13:56 +02:00
manual_move_start_time = millis() + (move_menu_scale < 0.99 ? 0UL : 250UL); // delay for bigger moves
2016-06-11 23:12:00 +02:00
manual_move_axis = (int8_t)axis;
}
2016-06-11 23:12:00 +02:00
/**
*
* "Prepare" > "Move Axis" submenu
*
*/
void _lcd_move_xyz(const char* name, AxisEnum axis) {
if (lcd_clicked) { return lcd_goto_previous_menu(); }
2016-06-11 23:12:00 +02:00
ENCODER_DIRECTION_NORMAL();
2017-10-10 02:54:15 +02:00
if (encoderPosition && !processing_manual_move) {
2016-06-11 23:12:00 +02:00
refresh_cmd_timeout();
2017-10-10 02:54:15 +02:00
// Start with no limits to movement
float min = current_position[axis] - 1000,
max = current_position[axis] + 1000;
// Limit to software endstops, if enabled
#if ENABLED(MIN_SOFTWARE_ENDSTOPS) || ENABLED(MAX_SOFTWARE_ENDSTOPS)
if (soft_endstops_enabled) switch (axis) {
case X_AXIS:
#if ENABLED(MIN_SOFTWARE_ENDSTOP_X)
min = soft_endstop_min[X_AXIS];
#endif
#if ENABLED(MAX_SOFTWARE_ENDSTOP_X)
max = soft_endstop_max[X_AXIS];
#endif
break;
case Y_AXIS:
#if ENABLED(MIN_SOFTWARE_ENDSTOP_Y)
min = soft_endstop_min[Y_AXIS];
#endif
#if ENABLED(MAX_SOFTWARE_ENDSTOP_Y)
max = soft_endstop_max[Y_AXIS];
#endif
break;
case Z_AXIS:
#if ENABLED(MIN_SOFTWARE_ENDSTOP_Z)
min = soft_endstop_min[Z_AXIS];
#endif
#if ENABLED(MAX_SOFTWARE_ENDSTOP_Z)
max = soft_endstop_max[Z_AXIS];
#endif
break;
2017-10-30 02:02:54 +01:00
default: break;
}
#endif // MIN_SOFTWARE_ENDSTOPS || MAX_SOFTWARE_ENDSTOPS
// Delta limits XY based on the current offset from center
// This assumes the center is 0,0
#if ENABLED(DELTA)
if (axis != Z_AXIS) {
2017-10-10 02:54:15 +02:00
max = SQRT(sq((float)(DELTA_PRINTABLE_RADIUS)) - sq(current_position[Y_AXIS - axis])); // (Y_AXIS - axis) == the other axis
min = -max;
}
#endif
2017-10-10 02:54:15 +02:00
// Get the new position
const float diff = float((int32_t)encoderPosition) * move_menu_scale;
#if IS_KINEMATIC
manual_move_offset += diff;
// Limit only when trying to move towards the limit
if ((int32_t)encoderPosition < 0) NOLESS(manual_move_offset, min - current_position[axis]);
if ((int32_t)encoderPosition > 0) NOMORE(manual_move_offset, max - current_position[axis]);
#else
current_position[axis] += diff;
// Limit only when trying to move towards the limit
if ((int32_t)encoderPosition < 0) NOLESS(current_position[axis], min);
if ((int32_t)encoderPosition > 0) NOMORE(current_position[axis], max);
#endif
encoderPosition = 0;
2016-06-11 23:12:00 +02:00
manual_move_to_current(axis);
2017-05-25 22:13:57 +02:00
lcdDrawUpdate = LCDVIEW_REDRAW_NOW;
2016-06-11 23:12:00 +02:00
}
2017-10-10 02:54:15 +02:00
if (lcdDrawUpdate) {
const float pos = current_position[axis]
#if IS_KINEMATIC
+ manual_move_offset
#endif
;
lcd_implementation_drawedit(name, move_menu_scale >= 0.1 ? ftostr41sign(pos) : ftostr43sign(pos));
}
2014-12-18 16:30:05 +01:00
}
void lcd_move_x() { _lcd_move_xyz(PSTR(MSG_MOVE_X), X_AXIS); }
void lcd_move_y() { _lcd_move_xyz(PSTR(MSG_MOVE_Y), Y_AXIS); }
void lcd_move_z() { _lcd_move_xyz(PSTR(MSG_MOVE_Z), Z_AXIS); }
void _lcd_move_e(
#if E_MANUAL > 1
2016-08-01 09:12:20 +02:00
int8_t eindex=-1
2016-06-11 23:12:00 +02:00
#endif
) {
if (lcd_clicked) { return lcd_goto_previous_menu(); }
2016-06-11 23:12:00 +02:00
ENCODER_DIRECTION_NORMAL();
if (encoderPosition) {
2017-10-10 02:54:15 +02:00
if (!processing_manual_move) {
const float diff = float((int32_t)encoderPosition) * move_menu_scale;
#if IS_KINEMATIC
manual_move_offset += diff;
#else
current_position[E_AXIS] += diff;
#endif
2017-10-10 02:54:15 +02:00
manual_move_to_current(E_AXIS
#if E_MANUAL > 1
, eindex
#endif
);
lcdDrawUpdate = LCDVIEW_REDRAW_NOW;
}
encoderPosition = 0;
2016-06-11 23:12:00 +02:00
}
2017-10-10 02:54:15 +02:00
if (lcdDrawUpdate && !processing_manual_move) {
2016-06-11 23:12:00 +02:00
PGM_P pos_label;
#if E_MANUAL == 1
2016-06-11 23:12:00 +02:00
pos_label = PSTR(MSG_MOVE_E);
#else
switch (eindex) {
2016-07-17 02:59:01 +02:00
default: pos_label = PSTR(MSG_MOVE_E MSG_MOVE_E1); break;
2016-06-11 23:12:00 +02:00
case 1: pos_label = PSTR(MSG_MOVE_E MSG_MOVE_E2); break;
#if E_MANUAL > 2
2016-06-11 23:12:00 +02:00
case 2: pos_label = PSTR(MSG_MOVE_E MSG_MOVE_E3); break;
#if E_MANUAL > 3
2016-06-11 23:12:00 +02:00
case 3: pos_label = PSTR(MSG_MOVE_E MSG_MOVE_E4); break;
2017-04-09 10:23:05 +02:00
#if E_MANUAL > 4
case 4: pos_label = PSTR(MSG_MOVE_E MSG_MOVE_E5); break;
#endif // E_MANUAL > 4
#endif // E_MANUAL > 3
#endif // E_MANUAL > 2
2016-06-11 23:12:00 +02:00
}
2017-04-09 10:23:05 +02:00
#endif // E_MANUAL > 1
2017-10-10 02:54:15 +02:00
lcd_implementation_drawedit(pos_label, ftostr41sign(current_position[E_AXIS]
#if IS_KINEMATIC
+ manual_move_offset
#endif
));
2016-06-11 23:12:00 +02:00
}
2015-09-11 09:37:32 +02:00
}
2014-12-18 16:30:05 +01:00
void lcd_move_e() { _lcd_move_e(); }
#if E_MANUAL > 1
void lcd_move_e0() { _lcd_move_e(0); }
void lcd_move_e1() { _lcd_move_e(1); }
#if E_MANUAL > 2
void lcd_move_e2() { _lcd_move_e(2); }
#if E_MANUAL > 3
void lcd_move_e3() { _lcd_move_e(3); }
2017-04-09 10:23:05 +02:00
#if E_MANUAL > 4
void lcd_move_e4() { _lcd_move_e(4); }
#endif // E_MANUAL > 4
#endif // E_MANUAL > 3
#endif // E_MANUAL > 2
#endif // E_MANUAL > 1
2016-06-11 23:12:00 +02:00
/**
*
* "Prepare" > "Move Xmm" > "Move XYZ" submenu
*
*/
screenFunc_t _manual_move_func_ptr;
2017-08-15 02:49:14 +02:00
void _goto_manual_move(const float scale) {
defer_return_to_status = true;
move_menu_scale = scale;
lcd_goto_screen(_manual_move_func_ptr);
}
void lcd_move_menu_10mm() { _goto_manual_move(10.0); }
void lcd_move_menu_1mm() { _goto_manual_move( 1.0); }
void lcd_move_menu_01mm() { _goto_manual_move( 0.1); }
2017-08-15 02:49:14 +02:00
void _lcd_move_distance_menu(const AxisEnum axis, const screenFunc_t func) {
_manual_move_func_ptr = func;
START_MENU();
if (LCD_HEIGHT >= 4) {
switch(axis) {
case X_AXIS:
STATIC_ITEM(MSG_MOVE_X, true, true); break;
case Y_AXIS:
STATIC_ITEM(MSG_MOVE_Y, true, true); break;
case Z_AXIS:
STATIC_ITEM(MSG_MOVE_Z, true, true); break;
default:
STATIC_ITEM(MSG_MOVE_E, true, true); break;
}
2016-06-11 23:12:00 +02:00
}
MENU_BACK(MSG_MOVE_AXIS);
MENU_ITEM(submenu, MSG_MOVE_10MM, lcd_move_menu_10mm);
MENU_ITEM(submenu, MSG_MOVE_1MM, lcd_move_menu_1mm);
MENU_ITEM(submenu, MSG_MOVE_01MM, lcd_move_menu_01mm);
2016-06-11 23:12:00 +02:00
END_MENU();
}
void lcd_move_get_x_amount() { _lcd_move_distance_menu(X_AXIS, lcd_move_x); }
void lcd_move_get_y_amount() { _lcd_move_distance_menu(Y_AXIS, lcd_move_y); }
void lcd_move_get_z_amount() { _lcd_move_distance_menu(Z_AXIS, lcd_move_z); }
void lcd_move_get_e_amount() { _lcd_move_distance_menu(E_AXIS, lcd_move_e); }
#if E_MANUAL > 1
void lcd_move_get_e0_amount() { _lcd_move_distance_menu(E_AXIS, lcd_move_e0); }
void lcd_move_get_e1_amount() { _lcd_move_distance_menu(E_AXIS, lcd_move_e1); }
#if E_MANUAL > 2
void lcd_move_get_e2_amount() { _lcd_move_distance_menu(E_AXIS, lcd_move_e2); }
#if E_MANUAL > 3
void lcd_move_get_e3_amount() { _lcd_move_distance_menu(E_AXIS, lcd_move_e3); }
2017-04-09 10:23:05 +02:00
#if E_MANUAL > 4
void lcd_move_get_e4_amount() { _lcd_move_distance_menu(E_AXIS, lcd_move_e4); }
#endif // E_MANUAL > 4
#endif // E_MANUAL > 3
#endif // E_MANUAL > 2
#endif // E_MANUAL > 1
2016-06-11 23:12:00 +02:00
/**
*
* "Prepare" > "Move Axis" submenu
*
*/
#if IS_KINEMATIC || ENABLED(NO_MOTION_BEFORE_HOMING)
#define _MOVE_XYZ_ALLOWED (axis_homed[X_AXIS] && axis_homed[Y_AXIS] && axis_homed[Z_AXIS])
#else
#define _MOVE_XYZ_ALLOWED true
#endif
#if ENABLED(DELTA)
#define _MOVE_XY_ALLOWED (current_position[Z_AXIS] <= delta_clip_start_height)
void lcd_lower_z_to_clip_height() {
line_to_z(delta_clip_start_height);
lcd_synchronize();
}
#else
#define _MOVE_XY_ALLOWED true
#endif
void lcd_move_menu() {
2016-06-11 23:12:00 +02:00
START_MENU();
MENU_BACK(MSG_PREPARE);
if (_MOVE_XYZ_ALLOWED) {
if (_MOVE_XY_ALLOWED) {
MENU_ITEM(submenu, MSG_MOVE_X, lcd_move_get_x_amount);
MENU_ITEM(submenu, MSG_MOVE_Y, lcd_move_get_y_amount);
}
#if ENABLED(DELTA)
else
MENU_ITEM(function, MSG_FREE_XY, lcd_lower_z_to_clip_height);
#endif
MENU_ITEM(submenu, MSG_MOVE_Z, lcd_move_get_z_amount);
}
else
MENU_ITEM(gcode, MSG_AUTO_HOME, PSTR("G28"));
#if ENABLED(SWITCHING_EXTRUDER) || ENABLED(DUAL_X_CARRIAGE)
if (active_extruder)
MENU_ITEM(gcode, MSG_SELECT " " MSG_E1, PSTR("T0"));
else
MENU_ITEM(gcode, MSG_SELECT " " MSG_E2, PSTR("T1"));
#endif
MENU_ITEM(submenu, MSG_MOVE_E, lcd_move_get_e_amount);
#if E_MANUAL > 1
MENU_ITEM(submenu, MSG_MOVE_E MSG_MOVE_E1, lcd_move_get_e0_amount);
MENU_ITEM(submenu, MSG_MOVE_E MSG_MOVE_E2, lcd_move_get_e1_amount);
#if E_MANUAL > 2
MENU_ITEM(submenu, MSG_MOVE_E MSG_MOVE_E3, lcd_move_get_e2_amount);
#if E_MANUAL > 3
MENU_ITEM(submenu, MSG_MOVE_E MSG_MOVE_E4, lcd_move_get_e3_amount);
2017-04-09 10:23:05 +02:00
#if E_MANUAL > 4
MENU_ITEM(submenu, MSG_MOVE_E MSG_MOVE_E5, lcd_move_get_e4_amount);
#endif // E_MANUAL > 4
#endif // E_MANUAL > 3
#endif // E_MANUAL > 2
#endif // E_MANUAL > 1
2016-06-11 23:12:00 +02:00
END_MENU();
}
2016-06-11 23:12:00 +02:00
/**
*
* "Control" submenu
*
*/
2017-05-21 02:54:23 +02:00
#if HAS_LCD_CONTRAST
void lcd_callback_set_contrast() { set_lcd_contrast(lcd_contrast); }
2017-06-03 05:05:44 +02:00
#endif
2017-05-21 02:54:23 +02:00
static void lcd_factory_settings() {
2017-04-10 04:47:49 +02:00
settings.reset();
lcd_completion_feedback();
}
#if ENABLED(EEPROM_SETTINGS)
static void lcd_init_eeprom() {
lcd_factory_settings();
settings.save();
lcd_goto_previous_menu();
}
static void lcd_init_eeprom_confirm() {
START_MENU();
MENU_BACK(MSG_CONTROL);
MENU_ITEM(function, MSG_INIT_EEPROM, lcd_init_eeprom);
END_MENU();
}
#endif
void lcd_control_menu() {
2016-06-11 23:12:00 +02:00
START_MENU();
MENU_BACK(MSG_MAIN);
2016-06-11 23:12:00 +02:00
MENU_ITEM(submenu, MSG_TEMPERATURE, lcd_control_temperature_menu);
MENU_ITEM(submenu, MSG_MOTION, lcd_control_motion_menu);
2017-04-17 06:00:08 +02:00
MENU_ITEM(submenu, MSG_FILAMENT, lcd_control_filament_menu);
2016-06-11 23:12:00 +02:00
#if HAS_LCD_CONTRAST
2017-06-03 05:05:44 +02:00
MENU_ITEM_EDIT_CALLBACK(int3, MSG_CONTRAST, (int*)&lcd_contrast, LCD_CONTRAST_MIN, LCD_CONTRAST_MAX, lcd_callback_set_contrast, true);
2016-04-02 23:28:17 +02:00
#endif
2016-06-11 23:12:00 +02:00
#if ENABLED(FWRETRACT)
MENU_ITEM(submenu, MSG_RETRACT, lcd_control_retract_menu);
#endif
2016-10-04 00:15:29 +02:00
#if ENABLED(DAC_STEPPER_CURRENT)
2016-11-19 11:17:39 +01:00
MENU_ITEM(submenu, MSG_DRIVE_STRENGTH, lcd_dac_menu);
2016-10-04 00:15:29 +02:00
#endif
#if HAS_MOTOR_CURRENT_PWM
MENU_ITEM(submenu, MSG_DRIVE_STRENGTH, lcd_pwm_menu);
#endif
2016-10-04 00:15:29 +02:00
#if ENABLED(BLTOUCH)
MENU_ITEM(submenu, MSG_BLTOUCH, bltouch_menu);
#endif
2016-06-11 23:12:00 +02:00
#if ENABLED(EEPROM_SETTINGS)
MENU_ITEM(function, MSG_STORE_EEPROM, lcd_store_settings);
MENU_ITEM(function, MSG_LOAD_EEPROM, lcd_load_settings);
#endif
MENU_ITEM(function, MSG_RESTORE_FAILSAFE, lcd_factory_settings);
#if ENABLED(EEPROM_SETTINGS)
MENU_ITEM(submenu, MSG_INIT_EEPROM, lcd_init_eeprom_confirm);
2016-04-02 23:28:17 +02:00
#endif
END_MENU();
}
2016-06-11 23:12:00 +02:00
/**
*
* "Temperature" submenu
*
*/
2016-06-11 23:12:00 +02:00
#if ENABLED(PID_AUTOTUNE_MENU)
2016-06-11 23:12:00 +02:00
#if ENABLED(PIDTEMP)
int16_t autotune_temp[HOTENDS] = ARRAY_BY_HOTENDS1(150);
#endif
2016-06-11 23:12:00 +02:00
#if ENABLED(PIDTEMPBED)
int16_t autotune_temp_bed = 70;
#endif
void _lcd_autotune(int16_t e) {
2016-06-11 23:12:00 +02:00
char cmd[30];
sprintf_P(cmd, PSTR("M303 U1 E%i S%i"), e,
#if HAS_PID_FOR_BOTH
e < 0 ? autotune_temp_bed : autotune_temp[e]
#elif ENABLED(PIDTEMPBED)
autotune_temp_bed
#else
autotune_temp[e]
#endif
);
enqueue_and_echo_command(cmd);
}
2017-05-09 19:35:43 +02:00
#endif // PID_AUTOTUNE_MENU
#if ENABLED(PIDTEMP)
2016-06-11 23:12:00 +02:00
// Helpers for editing PID Ki & Kd values
// grab the PID value out of the temp variable; scale it; then update the PID driver
void copy_and_scalePID_i(int16_t e) {
2016-07-17 02:59:01 +02:00
#if DISABLED(PID_PARAMS_PER_HOTEND) || HOTENDS == 1
2016-06-11 23:12:00 +02:00
UNUSED(e);
#endif
PID_PARAM(Ki, e) = scalePID_i(raw_Ki);
thermalManager.updatePID();
}
void copy_and_scalePID_d(int16_t e) {
2016-07-17 02:59:01 +02:00
#if DISABLED(PID_PARAMS_PER_HOTEND) || HOTENDS == 1
2016-06-11 23:12:00 +02:00
UNUSED(e);
#endif
PID_PARAM(Kd, e) = scalePID_d(raw_Kd);
thermalManager.updatePID();
}
2017-04-17 04:32:52 +02:00
#define _DEFINE_PIDTEMP_BASE_FUNCS(N) \
void copy_and_scalePID_i_E ## N() { copy_and_scalePID_i(N); } \
void copy_and_scalePID_d_E ## N() { copy_and_scalePID_d(N); }
#if ENABLED(PID_AUTOTUNE_MENU)
2017-04-17 04:32:52 +02:00
#define DEFINE_PIDTEMP_FUNCS(N) \
_DEFINE_PIDTEMP_BASE_FUNCS(N); \
void lcd_autotune_callback_E ## N() { _lcd_autotune(N); } typedef void _pid_##N##_void
#else
2017-04-17 04:32:52 +02:00
#define DEFINE_PIDTEMP_FUNCS(N) _DEFINE_PIDTEMP_BASE_FUNCS(N) typedef void _pid_##N##_void
#endif
2017-04-17 04:32:52 +02:00
DEFINE_PIDTEMP_FUNCS(0);
2016-06-11 23:12:00 +02:00
#if ENABLED(PID_PARAMS_PER_HOTEND)
#if HOTENDS > 1
2017-04-17 04:32:52 +02:00
DEFINE_PIDTEMP_FUNCS(1);
2016-06-11 23:12:00 +02:00
#if HOTENDS > 2
2017-04-17 04:32:52 +02:00
DEFINE_PIDTEMP_FUNCS(2);
2016-06-11 23:12:00 +02:00
#if HOTENDS > 3
2017-04-17 04:32:52 +02:00
DEFINE_PIDTEMP_FUNCS(3);
#if HOTENDS > 4
2017-04-17 04:32:52 +02:00
DEFINE_PIDTEMP_FUNCS(4);
#endif // HOTENDS > 4
#endif // HOTENDS > 3
#endif // HOTENDS > 2
#endif // HOTENDS > 1
#endif // PID_PARAMS_PER_HOTEND
#endif // PIDTEMP
2016-06-11 23:12:00 +02:00
/**
*
* "Control" > "Temperature" submenu
*
*/
void lcd_control_temperature_menu() {
2016-06-11 23:12:00 +02:00
START_MENU();
2016-06-11 23:12:00 +02:00
//
// ^ Control
//
MENU_BACK(MSG_CONTROL);
2016-06-11 23:12:00 +02:00
//
// Nozzle:
// Nozzle [1-5]:
2016-06-11 23:12:00 +02:00
//
#if HOTENDS == 1
MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(int3, MSG_NOZZLE, &thermalManager.target_temperature[0], 0, HEATER_0_MAXTEMP - 15, watch_temp_callback_E0);
#else // HOTENDS > 1
MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(int3, MSG_NOZZLE MSG_N1, &thermalManager.target_temperature[0], 0, HEATER_0_MAXTEMP - 15, watch_temp_callback_E0);
MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(int3, MSG_NOZZLE MSG_N2, &thermalManager.target_temperature[1], 0, HEATER_1_MAXTEMP - 15, watch_temp_callback_E1);
2016-06-11 23:12:00 +02:00
#if HOTENDS > 2
MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(int3, MSG_NOZZLE MSG_N3, &thermalManager.target_temperature[2], 0, HEATER_2_MAXTEMP - 15, watch_temp_callback_E2);
2016-06-11 23:12:00 +02:00
#if HOTENDS > 3
MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(int3, MSG_NOZZLE MSG_N4, &thermalManager.target_temperature[3], 0, HEATER_3_MAXTEMP - 15, watch_temp_callback_E3);
#if HOTENDS > 4
MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(int3, MSG_NOZZLE MSG_N5, &thermalManager.target_temperature[4], 0, HEATER_4_MAXTEMP - 15, watch_temp_callback_E4);
#endif // HOTENDS > 4
2016-06-11 23:12:00 +02:00
#endif // HOTENDS > 3
#endif // HOTENDS > 2
#endif // HOTENDS > 1
2016-06-11 23:12:00 +02:00
//
// Bed:
//
#if HAS_TEMP_BED
MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(int3, MSG_BED, &thermalManager.target_temperature_bed, 0, BED_MAXTEMP - 15, watch_temp_callback_bed);
2016-06-11 23:12:00 +02:00
#endif
2016-04-28 03:06:32 +02:00
2016-06-11 23:12:00 +02:00
//
// Fan Speed:
//
#if FAN_COUNT > 0
#if HAS_FAN0
2017-10-07 16:29:22 +02:00
MENU_MULTIPLIER_ITEM_EDIT(int3, MSG_FAN_SPEED FAN_SPEED_1_SUFFIX, &fanSpeeds[0], 0, 255);
#if ENABLED(EXTRA_FAN_SPEED)
MENU_MULTIPLIER_ITEM_EDIT(int3, MSG_EXTRA_FAN_SPEED FAN_SPEED_1_SUFFIX, &new_fanSpeeds[0], 3, 255);
2016-06-11 23:12:00 +02:00
#endif
#endif
#if HAS_FAN1
MENU_MULTIPLIER_ITEM_EDIT(int3, MSG_FAN_SPEED " 2", &fanSpeeds[1], 0, 255);
2017-10-07 16:29:22 +02:00
#if ENABLED(EXTRA_FAN_SPEED)
MENU_MULTIPLIER_ITEM_EDIT(int3, MSG_EXTRA_FAN_SPEED " 2", &new_fanSpeeds[1], 3, 255);
#endif
2016-06-11 23:12:00 +02:00
#endif
#if HAS_FAN2
MENU_MULTIPLIER_ITEM_EDIT(int3, MSG_FAN_SPEED " 3", &fanSpeeds[2], 0, 255);
2017-10-07 16:29:22 +02:00
#if ENABLED(EXTRA_FAN_SPEED)
MENU_MULTIPLIER_ITEM_EDIT(int3, MSG_EXTRA_FAN_SPEED " 3", &new_fanSpeeds[2], 3, 255);
#endif
2016-06-11 23:12:00 +02:00
#endif
#endif // FAN_COUNT > 0
//
// Autotemp, Min, Max, Fact
//
#if ENABLED(AUTOTEMP) && (TEMP_SENSOR_0 != 0)
MENU_ITEM_EDIT(bool, MSG_AUTOTEMP, &planner.autotemp_enabled);
MENU_ITEM_EDIT(float3, MSG_MIN, &planner.autotemp_min, 0, HEATER_0_MAXTEMP - 15);
MENU_ITEM_EDIT(float3, MSG_MAX, &planner.autotemp_max, 0, HEATER_0_MAXTEMP - 15);
MENU_ITEM_EDIT(float32, MSG_FACTOR, &planner.autotemp_factor, 0.0, 1.0);
#endif
2016-06-11 23:12:00 +02:00
//
// PID-P, PID-I, PID-D, PID-C, PID Autotune
// PID-P E1, PID-I E1, PID-D E1, PID-C E1, PID Autotune E1
// PID-P E2, PID-I E2, PID-D E2, PID-C E2, PID Autotune E2
// PID-P E3, PID-I E3, PID-D E3, PID-C E3, PID Autotune E3
// PID-P E4, PID-I E4, PID-D E4, PID-C E4, PID Autotune E4
2017-04-09 10:23:05 +02:00
// PID-P E5, PID-I E5, PID-D E5, PID-C E5, PID Autotune E5
2016-06-11 23:12:00 +02:00
//
#if ENABLED(PIDTEMP)
#define _PID_BASE_MENU_ITEMS(ELABEL, eindex) \
raw_Ki = unscalePID_i(PID_PARAM(Ki, eindex)); \
raw_Kd = unscalePID_d(PID_PARAM(Kd, eindex)); \
MENU_ITEM_EDIT(float52, MSG_PID_P ELABEL, &PID_PARAM(Kp, eindex), 1, 9990); \
MENU_ITEM_EDIT_CALLBACK(float52, MSG_PID_I ELABEL, &raw_Ki, 0.01, 9990, copy_and_scalePID_i_E ## eindex); \
MENU_ITEM_EDIT_CALLBACK(float52, MSG_PID_D ELABEL, &raw_Kd, 1, 9990, copy_and_scalePID_d_E ## eindex)
#if ENABLED(PID_EXTRUSION_SCALING)
2016-06-11 23:12:00 +02:00
#define _PID_MENU_ITEMS(ELABEL, eindex) \
_PID_BASE_MENU_ITEMS(ELABEL, eindex); \
MENU_ITEM_EDIT(float3, MSG_PID_C ELABEL, &PID_PARAM(Kc, eindex), 1, 9990)
#else
#define _PID_MENU_ITEMS(ELABEL, eindex) _PID_BASE_MENU_ITEMS(ELABEL, eindex)
#endif
2016-06-11 23:12:00 +02:00
#if ENABLED(PID_AUTOTUNE_MENU)
#define PID_MENU_ITEMS(ELABEL, eindex) \
_PID_MENU_ITEMS(ELABEL, eindex); \
MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(int3, MSG_PID_AUTOTUNE ELABEL, &autotune_temp[eindex], 150, heater_maxtemp[eindex] - 15, lcd_autotune_callback_E ## eindex)
#else
#define PID_MENU_ITEMS(ELABEL, eindex) _PID_MENU_ITEMS(ELABEL, eindex)
#endif
2016-06-11 23:12:00 +02:00
#if ENABLED(PID_PARAMS_PER_HOTEND) && HOTENDS > 1
2016-12-08 11:57:41 +01:00
PID_MENU_ITEMS(" " MSG_E1, 0);
PID_MENU_ITEMS(" " MSG_E2, 1);
2016-06-11 23:12:00 +02:00
#if HOTENDS > 2
2016-12-08 11:57:41 +01:00
PID_MENU_ITEMS(" " MSG_E3, 2);
2016-06-11 23:12:00 +02:00
#if HOTENDS > 3
2016-12-08 11:57:41 +01:00
PID_MENU_ITEMS(" " MSG_E4, 3);
#if HOTENDS > 4
PID_MENU_ITEMS(" " MSG_E5, 4);
#endif // HOTENDS > 4
#endif // HOTENDS > 3
#endif // HOTENDS > 2
#else // !PID_PARAMS_PER_HOTEND || HOTENDS == 1
2016-06-11 23:12:00 +02:00
PID_MENU_ITEMS("", 0);
#endif // !PID_PARAMS_PER_HOTEND || HOTENDS == 1
2016-06-11 23:12:00 +02:00
2017-05-09 19:35:43 +02:00
#endif // PIDTEMP
2016-06-11 23:12:00 +02:00
//
2016-11-28 07:39:06 +01:00
// Preheat Material 1 conf
2016-06-11 23:12:00 +02:00
//
2016-11-28 07:39:06 +01:00
MENU_ITEM(submenu, MSG_PREHEAT_1_SETTINGS, lcd_control_temperature_preheat_material1_settings_menu);
2016-06-11 23:12:00 +02:00
//
2016-11-28 07:39:06 +01:00
// Preheat Material 2 conf
2016-06-11 23:12:00 +02:00
//
2016-11-28 07:39:06 +01:00
MENU_ITEM(submenu, MSG_PREHEAT_2_SETTINGS, lcd_control_temperature_preheat_material2_settings_menu);
2016-06-11 23:12:00 +02:00
END_MENU();
}
void _lcd_control_temperature_preheat_settings_menu(uint8_t material) {
#if HOTENDS > 4
#define MINTEMP_ALL MIN5(HEATER_0_MINTEMP, HEATER_1_MINTEMP, HEATER_2_MINTEMP, HEATER_3_MINTEMP, HEATER_4_MINTEMP)
#define MAXTEMP_ALL MAX5(HEATER_0_MAXTEMP, HEATER_1_MAXTEMP, HEATER_2_MAXTEMP, HEATER_3_MAXTEMP, HEATER_4_MAXTEMP)
#elif HOTENDS > 3
#define MINTEMP_ALL MIN4(HEATER_0_MINTEMP, HEATER_1_MINTEMP, HEATER_2_MINTEMP, HEATER_3_MINTEMP)
#define MAXTEMP_ALL MAX4(HEATER_0_MAXTEMP, HEATER_1_MAXTEMP, HEATER_2_MAXTEMP, HEATER_3_MAXTEMP)
#elif HOTENDS > 2
#define MINTEMP_ALL MIN3(HEATER_0_MINTEMP, HEATER_1_MINTEMP, HEATER_2_MINTEMP)
#define MAXTEMP_ALL MAX3(HEATER_0_MAXTEMP, HEATER_1_MAXTEMP, HEATER_2_MAXTEMP)
#elif HOTENDS > 1
#define MINTEMP_ALL min(HEATER_0_MINTEMP, HEATER_1_MINTEMP)
#define MAXTEMP_ALL max(HEATER_0_MAXTEMP, HEATER_1_MAXTEMP)
#else
#define MINTEMP_ALL HEATER_0_MINTEMP
#define MAXTEMP_ALL HEATER_0_MAXTEMP
#endif
2016-06-11 23:12:00 +02:00
START_MENU();
MENU_BACK(MSG_TEMPERATURE);
MENU_ITEM_EDIT(int3, MSG_FAN_SPEED, &lcd_preheat_fan_speed[material], 0, 255);
2016-06-11 23:12:00 +02:00
#if TEMP_SENSOR_0 != 0
MENU_ITEM_EDIT(int3, MSG_NOZZLE, &lcd_preheat_hotend_temp[material], MINTEMP_ALL, MAXTEMP_ALL - 15);
2016-06-11 23:12:00 +02:00
#endif
#if TEMP_SENSOR_BED != 0
MENU_ITEM_EDIT(int3, MSG_BED, &lcd_preheat_bed_temp[material], BED_MINTEMP, BED_MAXTEMP - 15);
2016-06-11 23:12:00 +02:00
#endif
#if ENABLED(EEPROM_SETTINGS)
MENU_ITEM(function, MSG_STORE_EEPROM, lcd_store_settings);
2016-06-11 23:12:00 +02:00
#endif
END_MENU();
}
/**
*
2016-11-28 07:39:06 +01:00
* "Temperature" > "Preheat Material 1 conf" submenu
*
*/
2016-11-28 07:39:06 +01:00
void lcd_control_temperature_preheat_material1_settings_menu() { _lcd_control_temperature_preheat_settings_menu(0); }
2016-06-11 23:12:00 +02:00
/**
*
2016-11-28 07:39:06 +01:00
* "Temperature" > "Preheat Material 2 conf" submenu
2016-06-11 23:12:00 +02:00
*
*/
2016-11-28 07:39:06 +01:00
void lcd_control_temperature_preheat_material2_settings_menu() { _lcd_control_temperature_preheat_settings_menu(1); }
2017-05-28 19:13:27 +02:00
/**
*
* "Control" > "Motion" submenu
*
*/
void _reset_acceleration_rates() { planner.reset_acceleration_rates(); }
#if ENABLED(DISTINCT_E_FACTORS)
void _reset_e_acceleration_rate(const uint8_t e) { if (e == active_extruder) _reset_acceleration_rates(); }
void _reset_e0_acceleration_rate() { _reset_e_acceleration_rate(0); }
void _reset_e1_acceleration_rate() { _reset_e_acceleration_rate(1); }
#if E_STEPPERS > 2
void _reset_e2_acceleration_rate() { _reset_e_acceleration_rate(2); }
#if E_STEPPERS > 3
void _reset_e3_acceleration_rate() { _reset_e_acceleration_rate(3); }
2017-04-09 10:23:05 +02:00
#if E_STEPPERS > 4
void _reset_e4_acceleration_rate() { _reset_e_acceleration_rate(4); }
#endif // E_STEPPERS > 4
#endif // E_STEPPERS > 3
#endif // E_STEPPERS > 2
#endif
void _planner_refresh_positioning() { planner.refresh_positioning(); }
#if ENABLED(DISTINCT_E_FACTORS)
void _planner_refresh_e_positioning(const uint8_t e) {
if (e == active_extruder)
_planner_refresh_positioning();
else
planner.steps_to_mm[E_AXIS + e] = 1.0 / planner.axis_steps_per_mm[E_AXIS + e];
}
void _planner_refresh_e0_positioning() { _planner_refresh_e_positioning(0); }
void _planner_refresh_e1_positioning() { _planner_refresh_e_positioning(1); }
#if E_STEPPERS > 2
void _planner_refresh_e2_positioning() { _planner_refresh_e_positioning(2); }
#if E_STEPPERS > 3
void _planner_refresh_e3_positioning() { _planner_refresh_e_positioning(3); }
2017-04-09 10:23:05 +02:00
#if E_STEPPERS > 4
void _planner_refresh_e4_positioning() { _planner_refresh_e_positioning(4); }
2017-04-09 10:23:05 +02:00
#endif // E_STEPPERS > 4
#endif // E_STEPPERS > 3
#endif // E_STEPPERS > 2
#endif
2016-06-11 23:12:00 +02:00
// M203 / M205 Velocity options
void lcd_control_motion_velocity_menu() {
2015-04-08 06:11:03 +02:00
START_MENU();
2017-05-28 19:13:27 +02:00
MENU_BACK(MSG_MOTION);
2017-05-28 19:13:27 +02:00
// M203 Max Feedrate
2016-07-16 03:49:34 +02:00
MENU_ITEM_EDIT(float3, MSG_VMAX MSG_X, &planner.max_feedrate_mm_s[X_AXIS], 1, 999);
MENU_ITEM_EDIT(float3, MSG_VMAX MSG_Y, &planner.max_feedrate_mm_s[Y_AXIS], 1, 999);
MENU_ITEM_EDIT(float3, MSG_VMAX MSG_Z, &planner.max_feedrate_mm_s[Z_AXIS], 1, 999);
#if ENABLED(DISTINCT_E_FACTORS)
MENU_ITEM_EDIT(float3, MSG_VMAX MSG_E, &planner.max_feedrate_mm_s[E_AXIS + active_extruder], 1, 999);
MENU_ITEM_EDIT(float3, MSG_VMAX MSG_E1, &planner.max_feedrate_mm_s[E_AXIS], 1, 999);
MENU_ITEM_EDIT(float3, MSG_VMAX MSG_E2, &planner.max_feedrate_mm_s[E_AXIS + 1], 1, 999);
#if E_STEPPERS > 2
MENU_ITEM_EDIT(float3, MSG_VMAX MSG_E3, &planner.max_feedrate_mm_s[E_AXIS + 2], 1, 999);
#if E_STEPPERS > 3
2017-04-09 10:23:05 +02:00
MENU_ITEM_EDIT(float3, MSG_VMAX MSG_E4, &planner.max_feedrate_mm_s[E_AXIS + 3], 1, 999);
#if E_STEPPERS > 4
MENU_ITEM_EDIT(float3, MSG_VMAX MSG_E5, &planner.max_feedrate_mm_s[E_AXIS + 4], 1, 999);
#endif // E_STEPPERS > 4
#endif // E_STEPPERS > 3
#endif // E_STEPPERS > 2
#else
MENU_ITEM_EDIT(float3, MSG_VMAX MSG_E, &planner.max_feedrate_mm_s[E_AXIS], 1, 999);
#endif
2017-05-28 19:13:27 +02:00
// M205 S Min Feedrate
2016-07-16 03:49:34 +02:00
MENU_ITEM_EDIT(float3, MSG_VMIN, &planner.min_feedrate_mm_s, 0, 999);
2017-05-28 19:13:27 +02:00
// M205 T Min Travel Feedrate
2016-07-16 03:49:34 +02:00
MENU_ITEM_EDIT(float3, MSG_VTRAV_MIN, &planner.min_travel_feedrate_mm_s, 0, 999);
2017-05-28 19:13:27 +02:00
END_MENU();
}
// M201 / M204 Accelerations
void lcd_control_motion_acceleration_menu() {
START_MENU();
MENU_BACK(MSG_MOTION);
// M204 P Acceleration
MENU_ITEM_EDIT(float5, MSG_ACC, &planner.acceleration, 10, 99000);
// M204 R Retract Acceleration
MENU_ITEM_EDIT(float5, MSG_A_RETRACT, &planner.retract_acceleration, 100, 99000);
// M204 T Travel Acceleration
MENU_ITEM_EDIT(float5, MSG_A_TRAVEL, &planner.travel_acceleration, 100, 99000);
// M201 settings
2016-06-11 23:12:00 +02:00
MENU_ITEM_EDIT_CALLBACK(long5, MSG_AMAX MSG_X, &planner.max_acceleration_mm_per_s2[X_AXIS], 100, 99000, _reset_acceleration_rates);
MENU_ITEM_EDIT_CALLBACK(long5, MSG_AMAX MSG_Y, &planner.max_acceleration_mm_per_s2[Y_AXIS], 100, 99000, _reset_acceleration_rates);
MENU_ITEM_EDIT_CALLBACK(long5, MSG_AMAX MSG_Z, &planner.max_acceleration_mm_per_s2[Z_AXIS], 10, 99000, _reset_acceleration_rates);
#if ENABLED(DISTINCT_E_FACTORS)
MENU_ITEM_EDIT_CALLBACK(long5, MSG_AMAX MSG_E, &planner.max_acceleration_mm_per_s2[E_AXIS + active_extruder], 100, 99000, _reset_acceleration_rates);
MENU_ITEM_EDIT_CALLBACK(long5, MSG_AMAX MSG_E1, &planner.max_acceleration_mm_per_s2[E_AXIS], 100, 99000, _reset_e0_acceleration_rate);
MENU_ITEM_EDIT_CALLBACK(long5, MSG_AMAX MSG_E2, &planner.max_acceleration_mm_per_s2[E_AXIS + 1], 100, 99000, _reset_e1_acceleration_rate);
#if E_STEPPERS > 2
MENU_ITEM_EDIT_CALLBACK(long5, MSG_AMAX MSG_E3, &planner.max_acceleration_mm_per_s2[E_AXIS + 2], 100, 99000, _reset_e2_acceleration_rate);
#if E_STEPPERS > 3
MENU_ITEM_EDIT_CALLBACK(long5, MSG_AMAX MSG_E4, &planner.max_acceleration_mm_per_s2[E_AXIS + 3], 100, 99000, _reset_e3_acceleration_rate);
2017-04-09 10:23:05 +02:00
#if E_STEPPERS > 4
MENU_ITEM_EDIT_CALLBACK(long5, MSG_AMAX MSG_E5, &planner.max_acceleration_mm_per_s2[E_AXIS + 4], 100, 99000, _reset_e4_acceleration_rate);
#endif // E_STEPPERS > 4
#endif // E_STEPPERS > 3
#endif // E_STEPPERS > 2
#else
MENU_ITEM_EDIT_CALLBACK(long5, MSG_AMAX MSG_E, &planner.max_acceleration_mm_per_s2[E_AXIS], 100, 99000, _reset_acceleration_rates);
#endif
2017-05-28 19:13:27 +02:00
END_MENU();
}
// M205 Jerk
void lcd_control_motion_jerk_menu() {
START_MENU();
MENU_BACK(MSG_MOTION);
MENU_ITEM_EDIT(float3, MSG_VX_JERK, &planner.max_jerk[X_AXIS], 1, 990);
MENU_ITEM_EDIT(float3, MSG_VY_JERK, &planner.max_jerk[Y_AXIS], 1, 990);
#if ENABLED(DELTA)
MENU_ITEM_EDIT(float3, MSG_VZ_JERK, &planner.max_jerk[Z_AXIS], 1, 990);
#else
MENU_ITEM_EDIT(float52, MSG_VZ_JERK, &planner.max_jerk[Z_AXIS], 0.1, 990);
#endif
MENU_ITEM_EDIT(float3, MSG_VE_JERK, &planner.max_jerk[E_AXIS], 1, 990);
END_MENU();
}
// M92 Steps-per-mm
void lcd_control_motion_steps_per_mm_menu() {
START_MENU();
MENU_BACK(MSG_MOTION);
MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(float62, MSG_XSTEPS, &planner.axis_steps_per_mm[X_AXIS], 5, 9999, _planner_refresh_positioning);
MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(float62, MSG_YSTEPS, &planner.axis_steps_per_mm[Y_AXIS], 5, 9999, _planner_refresh_positioning);
MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(float62, MSG_ZSTEPS, &planner.axis_steps_per_mm[Z_AXIS], 5, 9999, _planner_refresh_positioning);
#if ENABLED(DISTINCT_E_FACTORS)
MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(float62, MSG_ESTEPS, &planner.axis_steps_per_mm[E_AXIS + active_extruder], 5, 9999, _planner_refresh_positioning);
MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(float62, MSG_E1STEPS, &planner.axis_steps_per_mm[E_AXIS], 5, 9999, _planner_refresh_e0_positioning);
MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(float62, MSG_E2STEPS, &planner.axis_steps_per_mm[E_AXIS + 1], 5, 9999, _planner_refresh_e1_positioning);
#if E_STEPPERS > 2
MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(float62, MSG_E3STEPS, &planner.axis_steps_per_mm[E_AXIS + 2], 5, 9999, _planner_refresh_e2_positioning);
#if E_STEPPERS > 3
MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(float62, MSG_E4STEPS, &planner.axis_steps_per_mm[E_AXIS + 3], 5, 9999, _planner_refresh_e3_positioning);
2017-04-09 10:23:05 +02:00
#if E_STEPPERS > 4
MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(float62, MSG_E5STEPS, &planner.axis_steps_per_mm[E_AXIS + 4], 5, 9999, _planner_refresh_e4_positioning);
2017-04-09 10:23:05 +02:00
#endif // E_STEPPERS > 4
#endif // E_STEPPERS > 3
#endif // E_STEPPERS > 2
#else
MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(float62, MSG_ESTEPS, &planner.axis_steps_per_mm[E_AXIS], 5, 9999, _planner_refresh_positioning);
#endif
2017-05-28 19:13:27 +02:00
END_MENU();
}
void lcd_control_motion_menu() {
START_MENU();
MENU_BACK(MSG_CONTROL);
#if ENABLED(BABYSTEP_ZPROBE_OFFSET)
MENU_ITEM(submenu, MSG_ZPROBE_ZOFFSET, lcd_babystep_zoffset);
#elif HAS_BED_PROBE
2017-11-17 00:35:14 +01:00
MENU_ITEM_EDIT(float32, MSG_ZPROBE_ZOFFSET, &zprobe_zoffset, Z_PROBE_OFFSET_RANGE_MIN, Z_PROBE_OFFSET_RANGE_MAX);
2017-05-28 19:13:27 +02:00
#endif
// M203 / M205 - Feedrate items
MENU_ITEM(submenu, MSG_VELOCITY, lcd_control_motion_velocity_menu);
2017-05-28 19:13:27 +02:00
// M201 - Acceleration items
2017-05-28 19:13:27 +02:00
MENU_ITEM(submenu, MSG_ACCELERATION, lcd_control_motion_acceleration_menu);
// M205 - Max Jerk
2017-05-28 19:13:27 +02:00
MENU_ITEM(submenu, MSG_JERK, lcd_control_motion_jerk_menu);
// M92 - Steps Per mm
2017-05-28 19:13:27 +02:00
MENU_ITEM(submenu, MSG_STEPS_PER_MM, lcd_control_motion_steps_per_mm_menu);
// M540 S - Abort on endstop hit when SD printing
2016-06-11 23:12:00 +02:00
#if ENABLED(ABORT_ON_ENDSTOP_HIT_FEATURE_ENABLED)
MENU_ITEM_EDIT(bool, MSG_ENDSTOP_ABORT, &stepper.abort_on_endstop_hit);
#endif
2017-05-28 19:13:27 +02:00
2015-04-08 06:11:03 +02:00
END_MENU();
}
2016-06-11 23:12:00 +02:00
/**
*
* "Control" > "Filament" submenu
*
*/
void lcd_control_filament_menu() {
2016-06-11 23:12:00 +02:00
START_MENU();
MENU_BACK(MSG_CONTROL);
#if ENABLED(LIN_ADVANCE)
MENU_ITEM_EDIT(float3, MSG_ADVANCE_K, &planner.extruder_advance_k, 0, 999);
#endif
2017-11-10 09:38:53 +01:00
MENU_ITEM_EDIT_CALLBACK(bool, MSG_VOLUMETRIC_ENABLED, &parser.volumetric_enabled, planner.calculate_volumetric_multipliers);
2016-06-11 23:12:00 +02:00
2017-11-10 09:38:53 +01:00
if (parser.volumetric_enabled) {
2016-06-11 23:12:00 +02:00
#if EXTRUDERS == 1
2017-11-10 09:38:53 +01:00
MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(float43, MSG_FILAMENT_DIAM, &planner.filament_size[0], 1.5, 3.25, planner.calculate_volumetric_multipliers);
#else // EXTRUDERS > 1
2017-11-18 12:14:31 +01:00
MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(float43, MSG_FILAMENT_DIAM, &planner.filament_size[active_extruder], 1.5, 3.25, planner.calculate_volumetric_multipliers);
2017-11-10 09:38:53 +01:00
MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(float43, MSG_FILAMENT_DIAM MSG_DIAM_E1, &planner.filament_size[0], 1.5, 3.25, planner.calculate_volumetric_multipliers);
MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(float43, MSG_FILAMENT_DIAM MSG_DIAM_E2, &planner.filament_size[1], 1.5, 3.25, planner.calculate_volumetric_multipliers);
2016-06-11 23:12:00 +02:00
#if EXTRUDERS > 2
2017-11-10 09:38:53 +01:00
MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(float43, MSG_FILAMENT_DIAM MSG_DIAM_E3, &planner.filament_size[2], 1.5, 3.25, planner.calculate_volumetric_multipliers);
2016-06-11 23:12:00 +02:00
#if EXTRUDERS > 3
2017-11-10 09:38:53 +01:00
MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(float43, MSG_FILAMENT_DIAM MSG_DIAM_E4, &planner.filament_size[3], 1.5, 3.25, planner.calculate_volumetric_multipliers);
#if EXTRUDERS > 4
2017-11-10 09:38:53 +01:00
MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(float43, MSG_FILAMENT_DIAM MSG_DIAM_E5, &planner.filament_size[4], 1.5, 3.25, planner.calculate_volumetric_multipliers);
#endif // EXTRUDERS > 4
#endif // EXTRUDERS > 3
#endif // EXTRUDERS > 2
#endif // EXTRUDERS > 1
}
2016-06-11 23:12:00 +02:00
END_MENU();
}
2016-06-11 23:12:00 +02:00
/**
*
* "Control" > "Retract" submenu
*
*/
#if ENABLED(FWRETRACT)
void lcd_control_retract_menu() {
2016-06-11 23:12:00 +02:00
START_MENU();
MENU_BACK(MSG_CONTROL);
2016-06-11 23:12:00 +02:00
MENU_ITEM_EDIT(bool, MSG_AUTORETRACT, &autoretract_enabled);
MENU_ITEM_EDIT(float52, MSG_CONTROL_RETRACT, &retract_length, 0, 100);
#if EXTRUDERS > 1
2017-07-27 05:11:22 +02:00
MENU_ITEM_EDIT(float52, MSG_CONTROL_RETRACT_SWAP, &swap_retract_length, 0, 100);
2016-06-11 23:12:00 +02:00
#endif
2016-06-22 12:27:31 +02:00
MENU_ITEM_EDIT(float3, MSG_CONTROL_RETRACTF, &retract_feedrate_mm_s, 1, 999);
2016-06-11 23:12:00 +02:00
MENU_ITEM_EDIT(float52, MSG_CONTROL_RETRACT_ZLIFT, &retract_zlift, 0, 999);
MENU_ITEM_EDIT(float52, MSG_CONTROL_RETRACT_RECOVER, &retract_recover_length, -100, 100);
2016-06-11 23:12:00 +02:00
#if EXTRUDERS > 1
2017-07-27 05:11:22 +02:00
MENU_ITEM_EDIT(float52, MSG_CONTROL_RETRACT_RECOVER_SWAP, &swap_retract_recover_length, -100, 100);
2016-06-11 23:12:00 +02:00
#endif
2016-07-16 03:49:34 +02:00
MENU_ITEM_EDIT(float3, MSG_CONTROL_RETRACT_RECOVERF, &retract_recover_feedrate_mm_s, 1, 999);
#if EXTRUDERS > 1
MENU_ITEM_EDIT(float3, MSG_CONTROL_RETRACT_RECOVER_SWAPF, &swap_retract_recover_feedrate_mm_s, 1, 999);
#endif
2016-06-11 23:12:00 +02:00
END_MENU();
}
2016-06-11 23:12:00 +02:00
#endif // FWRETRACT
2016-06-11 23:12:00 +02:00
#if ENABLED(SDSUPPORT)
2016-06-11 23:12:00 +02:00
#if !PIN_EXISTS(SD_DETECT)
void lcd_sd_refresh() {
2016-06-11 23:12:00 +02:00
card.initsd();
2016-07-09 00:08:56 +02:00
encoderTopLine = 0;
2016-06-11 23:12:00 +02:00
}
#endif
void lcd_sd_updir() {
2016-06-11 23:12:00 +02:00
card.updir();
2016-07-09 00:08:56 +02:00
encoderTopLine = 0;
2016-12-02 01:15:58 +01:00
screen_changed = true;
lcdDrawUpdate = LCDVIEW_CLEAR_CALL_REDRAW;
2016-06-11 23:12:00 +02:00
}
/**
*
* "Print from SD" submenu
*
*/
#if ENABLED(SD_REPRINT_LAST_SELECTED_FILE)
uint32_t last_sdfile_encoderPosition = 0xFFFF;
void lcd_reselect_last_file() {
if (last_sdfile_encoderPosition == 0xFFFF) return;
#if ENABLED(DOGLCD)
// Some of this is a hack to force the screen update to work.
// TODO: Fix the real issue that causes this!
lcdDrawUpdate = LCDVIEW_CALL_REDRAW_NEXT;
_lcd_synchronize();
safe_delay(50);
_lcd_synchronize();
lcdDrawUpdate = LCDVIEW_CALL_REDRAW_NEXT;
drawing_screen = screen_changed = true;
#endif
lcd_goto_screen(lcd_sdcard_menu, last_sdfile_encoderPosition);
defer_return_to_status = true;
last_sdfile_encoderPosition = 0xFFFF;
#if ENABLED(DOGLCD)
lcd_update();
#endif
}
#endif
2016-06-11 23:12:00 +02:00
void lcd_sdcard_menu() {
ENCODER_DIRECTION_MENUS();
const uint16_t fileCnt = card.get_num_Files();
2016-06-11 23:12:00 +02:00
START_MENU();
MENU_BACK(MSG_MAIN);
2016-06-11 23:12:00 +02:00
card.getWorkDirName();
if (card.filename[0] == '/') {
#if !PIN_EXISTS(SD_DETECT)
MENU_ITEM(function, LCD_STR_REFRESH MSG_REFRESH, lcd_sd_refresh);
#endif
}
else {
2016-06-11 23:12:00 +02:00
MENU_ITEM(function, LCD_STR_FOLDER "..", lcd_sd_updir);
}
2016-06-11 23:12:00 +02:00
for (uint16_t i = 0; i < fileCnt; i++) {
if (_menuLineNr == _thisItemNr) {
2017-04-17 04:32:52 +02:00
const uint16_t nr =
#if ENABLED(SDCARD_RATHERRECENTFIRST) && DISABLED(SDCARD_SORT_ALPHA)
fileCnt - 1 -
#endif
i;
2017-02-09 14:02:25 +01:00
#if ENABLED(SDCARD_SORT_ALPHA)
card.getfilename_sorted(nr);
#else
card.getfilename(nr);
#endif
2016-06-11 23:12:00 +02:00
if (card.filenameIsDir)
MENU_ITEM(sddirectory, MSG_CARD_MENU, card.filename, card.longFilename);
else
MENU_ITEM(sdfile, MSG_CARD_MENU, card.filename, card.longFilename);
}
else {
MENU_ITEM_DUMMY();
}
}
END_MENU();
}
2017-05-09 19:35:43 +02:00
#endif // SDSUPPORT
#if ENABLED(LCD_INFO_MENU)
2016-07-02 23:04:18 +02:00
#if ENABLED(PRINTCOUNTER)
/**
*
* About Printer > Statistics submenu
*
*/
void lcd_info_stats_menu() {
if (lcd_clicked) { return lcd_goto_previous_menu(); }
char buffer[21];
2016-07-23 02:42:21 +02:00
printStatistics stats = print_job_timer.getStats();
START_SCREEN(); // 12345678901234567890
STATIC_ITEM(MSG_INFO_PRINT_COUNT ": ", false, false, itostr3left(stats.totalPrints)); // Print Count: 999
2017-04-26 09:43:11 +02:00
STATIC_ITEM(MSG_INFO_COMPLETED_PRINTS": ", false, false, itostr3left(stats.finishedPrints)); // Completed : 666
2016-07-24 04:13:35 +02:00
duration_t elapsed = stats.printTime;
elapsed.toString(buffer);
STATIC_ITEM(MSG_INFO_PRINT_TIME ": ", false, false); // Total print Time:
STATIC_ITEM("", false, false, buffer); // 99y 364d 23h 59m 59s
2016-07-24 04:13:35 +02:00
elapsed = stats.longestPrint;
elapsed.toString(buffer);
STATIC_ITEM(MSG_INFO_PRINT_LONGEST ": ", false, false); // Longest job time:
STATIC_ITEM("", false, false, buffer); // 99y 364d 23h 59m 59s
sprintf_P(buffer, PSTR("%ld.%im"), long(stats.filamentUsed / 1000), int16_t(stats.filamentUsed / 100) % 10);
STATIC_ITEM(MSG_INFO_PRINT_FILAMENT ": ", false, false); // Extruded total:
STATIC_ITEM("", false, false, buffer); // 125m
END_SCREEN();
}
2016-07-02 23:04:18 +02:00
#endif // PRINTCOUNTER
/**
*
2016-07-02 23:04:18 +02:00
* About Printer > Thermistors
*
*/
void lcd_info_thermistors_menu() {
if (lcd_clicked) { return lcd_goto_previous_menu(); }
START_SCREEN();
#define THERMISTOR_ID TEMP_SENSOR_0
#include "thermistornames.h"
2016-07-09 03:20:15 +02:00
STATIC_ITEM("T0: " THERMISTOR_NAME, false, true);
STATIC_ITEM(MSG_INFO_MIN_TEMP ": " STRINGIFY(HEATER_0_MINTEMP), false);
STATIC_ITEM(MSG_INFO_MAX_TEMP ": " STRINGIFY(HEATER_0_MAXTEMP), false);
#if TEMP_SENSOR_1 != 0
#undef THERMISTOR_ID
#define THERMISTOR_ID TEMP_SENSOR_1
#include "thermistornames.h"
2016-07-09 03:20:15 +02:00
STATIC_ITEM("T1: " THERMISTOR_NAME, false, true);
STATIC_ITEM(MSG_INFO_MIN_TEMP ": " STRINGIFY(HEATER_1_MINTEMP), false);
STATIC_ITEM(MSG_INFO_MAX_TEMP ": " STRINGIFY(HEATER_1_MAXTEMP), false);
#endif
#if TEMP_SENSOR_2 != 0
#undef THERMISTOR_ID
#define THERMISTOR_ID TEMP_SENSOR_2
#include "thermistornames.h"
2016-07-09 03:20:15 +02:00
STATIC_ITEM("T2: " THERMISTOR_NAME, false, true);
STATIC_ITEM(MSG_INFO_MIN_TEMP ": " STRINGIFY(HEATER_2_MINTEMP), false);
STATIC_ITEM(MSG_INFO_MAX_TEMP ": " STRINGIFY(HEATER_2_MAXTEMP), false);
#endif
#if TEMP_SENSOR_3 != 0
#undef THERMISTOR_ID
#define THERMISTOR_ID TEMP_SENSOR_3
#include "thermistornames.h"
2016-07-09 03:20:15 +02:00
STATIC_ITEM("T3: " THERMISTOR_NAME, false, true);
STATIC_ITEM(MSG_INFO_MIN_TEMP ": " STRINGIFY(HEATER_3_MINTEMP), false);
STATIC_ITEM(MSG_INFO_MAX_TEMP ": " STRINGIFY(HEATER_3_MAXTEMP), false);
#endif
2016-07-02 23:04:18 +02:00
#if TEMP_SENSOR_4 != 0
#undef THERMISTOR_ID
#define THERMISTOR_ID TEMP_SENSOR_4
#include "thermistornames.h"
STATIC_ITEM("T4: " THERMISTOR_NAME, false, true);
STATIC_ITEM(MSG_INFO_MIN_TEMP ": " STRINGIFY(HEATER_4_MINTEMP), false);
STATIC_ITEM(MSG_INFO_MAX_TEMP ": " STRINGIFY(HEATER_4_MAXTEMP), false);
#endif
#if TEMP_SENSOR_BED != 0
#undef THERMISTOR_ID
#define THERMISTOR_ID TEMP_SENSOR_BED
#include "thermistornames.h"
2016-07-09 03:20:15 +02:00
STATIC_ITEM("TBed:" THERMISTOR_NAME, false, true);
STATIC_ITEM(MSG_INFO_MIN_TEMP ": " STRINGIFY(BED_MINTEMP), false);
STATIC_ITEM(MSG_INFO_MAX_TEMP ": " STRINGIFY(BED_MAXTEMP), false);
#endif
END_SCREEN();
}
/**
*
2016-07-02 23:04:18 +02:00
* About Printer > Board Info
*
*/
void lcd_info_board_menu() {
if (lcd_clicked) { return lcd_goto_previous_menu(); }
START_SCREEN();
STATIC_ITEM(BOARD_NAME, true, true); // MyPrinterController
STATIC_ITEM(MSG_INFO_BAUDRATE ": " STRINGIFY(BAUDRATE), true); // Baud: 250000
STATIC_ITEM(MSG_INFO_PROTOCOL ": " PROTOCOL_VERSION, true); // Protocol: 1.0
2017-04-02 08:33:41 +02:00
#if POWER_SUPPLY == 0
STATIC_ITEM(MSG_INFO_PSU ": Generic", true);
#elif POWER_SUPPLY == 1
STATIC_ITEM(MSG_INFO_PSU ": ATX", true); // Power Supply: ATX
#elif POWER_SUPPLY == 2
STATIC_ITEM(MSG_INFO_PSU ": XBox", true); // Power Supply: XBox
#endif
END_SCREEN();
}
/**
*
2016-07-02 23:04:18 +02:00
* About Printer > Printer Info
*
*/
void lcd_info_printer_menu() {
if (lcd_clicked) { return lcd_goto_previous_menu(); }
START_SCREEN();
STATIC_ITEM(MSG_MARLIN, true, true); // Marlin
STATIC_ITEM(SHORT_BUILD_VERSION, true); // x.x.x-Branch
STATIC_ITEM(STRING_DISTRIBUTION_DATE, true); // YYYY-MM-DD HH:MM
STATIC_ITEM(MACHINE_NAME, true); // My3DPrinter
STATIC_ITEM(WEBSITE_URL, true); // www.my3dprinter.com
STATIC_ITEM(MSG_INFO_EXTRUDERS ": " STRINGIFY(EXTRUDERS), true); // Extruders: 2
#if ENABLED(AUTO_BED_LEVELING_3POINT)
STATIC_ITEM(MSG_3POINT_LEVELING, true); // 3-Point Leveling
#elif ENABLED(AUTO_BED_LEVELING_LINEAR)
STATIC_ITEM(MSG_LINEAR_LEVELING, true); // Linear Leveling
#elif ENABLED(AUTO_BED_LEVELING_BILINEAR)
STATIC_ITEM(MSG_BILINEAR_LEVELING, true); // Bi-linear Leveling
#elif ENABLED(AUTO_BED_LEVELING_UBL)
STATIC_ITEM(MSG_UBL_LEVELING, true); // Unified Bed Leveling
#elif ENABLED(MESH_BED_LEVELING)
STATIC_ITEM(MSG_MESH_LEVELING, true); // Mesh Leveling
#endif
END_SCREEN();
2016-07-02 23:04:18 +02:00
}
2016-07-02 23:04:18 +02:00
/**
*
* "About Printer" submenu
*
*/
void lcd_info_menu() {
2016-07-02 23:04:18 +02:00
START_MENU();
MENU_BACK(MSG_MAIN);
2016-07-02 23:04:18 +02:00
MENU_ITEM(submenu, MSG_INFO_PRINTER_MENU, lcd_info_printer_menu); // Printer Info >
MENU_ITEM(submenu, MSG_INFO_BOARD_MENU, lcd_info_board_menu); // Board Info >
MENU_ITEM(submenu, MSG_INFO_THERMISTOR_MENU, lcd_info_thermistors_menu); // Thermistors >
#if ENABLED(PRINTCOUNTER)
2016-07-02 23:04:18 +02:00
MENU_ITEM(submenu, MSG_INFO_STATS_MENU, lcd_info_stats_menu); // Printer Statistics >
#endif
END_MENU();
}
#endif // LCD_INFO_MENU
2017-02-10 07:13:58 +01:00
/**
*
* Filament Change Feature Screens
*
*/
#if ENABLED(ADVANCED_PAUSE_FEATURE)
2017-02-18 06:57:13 +01:00
// Portions from STATIC_ITEM...
#define HOTEND_STATUS_ITEM() do { \
if (_menuLineNr == _thisItemNr) { \
if (lcdDrawUpdate) { \
2017-02-18 06:57:13 +01:00
lcd_implementation_drawmenu_static(_lcdLineNr, PSTR(MSG_FILAMENT_CHANGE_NOZZLE), false, true); \
lcd_implementation_hotend_status(_lcdLineNr); \
} \
2017-02-18 06:57:13 +01:00
if (_skipStatic && encoderLine <= _thisItemNr) { \
encoderPosition += ENCODER_STEPS_PER_MENU_ITEM; \
++encoderLine; \
2017-02-18 06:57:13 +01:00
} \
2017-05-25 22:13:57 +02:00
lcdDrawUpdate = LCDVIEW_CALL_REDRAW_NEXT; \
2017-02-18 06:57:13 +01:00
} \
++_thisItemNr; \
2017-06-15 22:10:45 +02:00
}while(0)
2017-02-18 06:57:13 +01:00
void lcd_advanced_pause_toocold_menu() {
2016-12-20 08:47:46 +01:00
START_MENU();
STATIC_ITEM(MSG_HEATING_FAILED_LCD, true, true);
2017-02-10 07:13:58 +01:00
STATIC_ITEM(MSG_FILAMENT_CHANGE_MINTEMP STRINGIFY(EXTRUDE_MINTEMP) ".", false, false);
MENU_BACK(MSG_BACK);
2017-02-18 06:57:13 +01:00
#if LCD_HEIGHT > 4
STATIC_ITEM(" ");
#endif
HOTEND_STATUS_ITEM();
2016-12-20 08:47:46 +01:00
END_MENU();
}
void lcd_advanced_pause_resume_print() {
advanced_pause_menu_response = ADVANCED_PAUSE_RESPONSE_RESUME_PRINT;
}
void lcd_advanced_pause_extrude_more() {
advanced_pause_menu_response = ADVANCED_PAUSE_RESPONSE_EXTRUDE_MORE;
}
void lcd_advanced_pause_option_menu() {
START_MENU();
#if LCD_HEIGHT > 2
2016-07-09 03:18:40 +02:00
STATIC_ITEM(MSG_FILAMENT_CHANGE_OPTION_HEADER, true, false);
#endif
MENU_ITEM(function, MSG_FILAMENT_CHANGE_OPTION_RESUME, lcd_advanced_pause_resume_print);
MENU_ITEM(function, MSG_FILAMENT_CHANGE_OPTION_EXTRUDE, lcd_advanced_pause_extrude_more);
END_MENU();
}
void lcd_advanced_pause_init_message() {
START_SCREEN();
2016-07-09 03:18:40 +02:00
STATIC_ITEM(MSG_FILAMENT_CHANGE_HEADER, true, true);
STATIC_ITEM(MSG_FILAMENT_CHANGE_INIT_1);
#ifdef MSG_FILAMENT_CHANGE_INIT_2
STATIC_ITEM(MSG_FILAMENT_CHANGE_INIT_2);
2017-02-18 06:57:13 +01:00
#define __FC_LINES_A 3
#else
#define __FC_LINES_A 2
#endif
#ifdef MSG_FILAMENT_CHANGE_INIT_3
STATIC_ITEM(MSG_FILAMENT_CHANGE_INIT_3);
2017-02-18 06:57:13 +01:00
#define _FC_LINES_A (__FC_LINES_A + 1)
#else
#define _FC_LINES_A __FC_LINES_A
#endif
#if LCD_HEIGHT > _FC_LINES_A + 1
STATIC_ITEM(" ");
#endif
2017-02-18 06:57:13 +01:00
HOTEND_STATUS_ITEM();
END_SCREEN();
}
void lcd_advanced_pause_unload_message() {
START_SCREEN();
2016-07-09 03:18:40 +02:00
STATIC_ITEM(MSG_FILAMENT_CHANGE_HEADER, true, true);
STATIC_ITEM(MSG_FILAMENT_CHANGE_UNLOAD_1);
#ifdef MSG_FILAMENT_CHANGE_UNLOAD_2
STATIC_ITEM(MSG_FILAMENT_CHANGE_UNLOAD_2);
2017-02-18 06:57:13 +01:00
#define __FC_LINES_B 3
#else
#define __FC_LINES_B 2
#endif
#ifdef MSG_FILAMENT_CHANGE_UNLOAD_3
STATIC_ITEM(MSG_FILAMENT_CHANGE_UNLOAD_3);
2017-02-18 06:57:13 +01:00
#define _FC_LINES_B (__FC_LINES_B + 1)
#else
#define _FC_LINES_B __FC_LINES_B
#endif
#if LCD_HEIGHT > _FC_LINES_B + 1
STATIC_ITEM(" ");
#endif
2017-02-18 06:57:13 +01:00
HOTEND_STATUS_ITEM();
END_SCREEN();
}
void lcd_advanced_pause_wait_for_nozzles_to_heat() {
START_SCREEN();
STATIC_ITEM(MSG_FILAMENT_CHANGE_HEADER, true, true);
STATIC_ITEM(MSG_FILAMENT_CHANGE_HEATING_1);
#ifdef MSG_FILAMENT_CHANGE_HEATING_2
STATIC_ITEM(MSG_FILAMENT_CHANGE_HEATING_2);
2017-02-18 06:57:13 +01:00
#define _FC_LINES_C 3
#else
#define _FC_LINES_C 2
#endif
2017-02-18 06:57:13 +01:00
#if LCD_HEIGHT > _FC_LINES_C + 1
STATIC_ITEM(" ");
#endif
HOTEND_STATUS_ITEM();
END_SCREEN();
}
void lcd_advanced_pause_heat_nozzle() {
START_SCREEN();
STATIC_ITEM(MSG_FILAMENT_CHANGE_HEADER, true, true);
STATIC_ITEM(MSG_FILAMENT_CHANGE_HEAT_1);
#ifdef MSG_FILAMENT_CHANGE_INSERT_2
STATIC_ITEM(MSG_FILAMENT_CHANGE_HEAT_2);
2017-02-18 06:57:13 +01:00
#define _FC_LINES_D 3
#else
#define _FC_LINES_D 2
#endif
#if LCD_HEIGHT > _FC_LINES_D + 1
STATIC_ITEM(" ");
#endif
2017-02-18 06:57:13 +01:00
HOTEND_STATUS_ITEM();
END_SCREEN();
}
void lcd_advanced_pause_insert_message() {
START_SCREEN();
2016-07-09 03:18:40 +02:00
STATIC_ITEM(MSG_FILAMENT_CHANGE_HEADER, true, true);
STATIC_ITEM(MSG_FILAMENT_CHANGE_INSERT_1);
#ifdef MSG_FILAMENT_CHANGE_INSERT_2
STATIC_ITEM(MSG_FILAMENT_CHANGE_INSERT_2);
2017-02-18 06:57:13 +01:00
#define __FC_LINES_E 3
#else
#define __FC_LINES_E 2
#endif
#ifdef MSG_FILAMENT_CHANGE_INSERT_3
STATIC_ITEM(MSG_FILAMENT_CHANGE_INSERT_3);
2017-02-18 06:57:13 +01:00
#define _FC_LINES_E (__FC_LINES_E + 1)
#else
#define _FC_LINES_E __FC_LINES_E
#endif
#if LCD_HEIGHT > _FC_LINES_E + 1
STATIC_ITEM(" ");
#endif
2017-02-18 06:57:13 +01:00
HOTEND_STATUS_ITEM();
END_SCREEN();
}
void lcd_advanced_pause_load_message() {
START_SCREEN();
2016-07-09 03:18:40 +02:00
STATIC_ITEM(MSG_FILAMENT_CHANGE_HEADER, true, true);
STATIC_ITEM(MSG_FILAMENT_CHANGE_LOAD_1);
#ifdef MSG_FILAMENT_CHANGE_LOAD_2
STATIC_ITEM(MSG_FILAMENT_CHANGE_LOAD_2);
2017-02-18 06:57:13 +01:00
#define __FC_LINES_F 3
#else
#define __FC_LINES_F 2
#endif
#ifdef MSG_FILAMENT_CHANGE_LOAD_3
STATIC_ITEM(MSG_FILAMENT_CHANGE_LOAD_3);
2017-02-18 06:57:13 +01:00
#define _FC_LINES_F (__FC_LINES_F + 1)
#else
#define _FC_LINES_F __FC_LINES_F
#endif
#if LCD_HEIGHT > _FC_LINES_F + 1
STATIC_ITEM(" ");
#endif
2017-02-18 06:57:13 +01:00
HOTEND_STATUS_ITEM();
END_SCREEN();
}
void lcd_advanced_pause_extrude_message() {
START_SCREEN();
2016-07-09 03:18:40 +02:00
STATIC_ITEM(MSG_FILAMENT_CHANGE_HEADER, true, true);
STATIC_ITEM(MSG_FILAMENT_CHANGE_EXTRUDE_1);
#ifdef MSG_FILAMENT_CHANGE_EXTRUDE_2
STATIC_ITEM(MSG_FILAMENT_CHANGE_EXTRUDE_2);
2017-02-18 06:57:13 +01:00
#define __FC_LINES_G 3
#else
#define __FC_LINES_G 2
#endif
#ifdef MSG_FILAMENT_CHANGE_EXTRUDE_3
STATIC_ITEM(MSG_FILAMENT_CHANGE_EXTRUDE_3);
2017-02-18 06:57:13 +01:00
#define _FC_LINES_G (__FC_LINES_G + 1)
#else
#define _FC_LINES_G __FC_LINES_G
#endif
#if LCD_HEIGHT > _FC_LINES_G + 1
STATIC_ITEM(" ");
#endif
2017-02-18 06:57:13 +01:00
HOTEND_STATUS_ITEM();
END_SCREEN();
}
void lcd_advanced_pause_resume_message() {
START_SCREEN();
2016-07-09 03:18:40 +02:00
STATIC_ITEM(MSG_FILAMENT_CHANGE_HEADER, true, true);
STATIC_ITEM(MSG_FILAMENT_CHANGE_RESUME_1);
#ifdef MSG_FILAMENT_CHANGE_RESUME_2
STATIC_ITEM(MSG_FILAMENT_CHANGE_RESUME_2);
#endif
#ifdef MSG_FILAMENT_CHANGE_RESUME_3
STATIC_ITEM(MSG_FILAMENT_CHANGE_RESUME_3);
#endif
END_SCREEN();
}
void lcd_advanced_pause_show_message(const AdvancedPauseMessage message) {
switch (message) {
case ADVANCED_PAUSE_MESSAGE_INIT:
defer_return_to_status = true;
lcd_goto_screen(lcd_advanced_pause_init_message);
break;
case ADVANCED_PAUSE_MESSAGE_UNLOAD:
defer_return_to_status = true;
lcd_goto_screen(lcd_advanced_pause_unload_message);
break;
case ADVANCED_PAUSE_MESSAGE_INSERT:
defer_return_to_status = true;
lcd_goto_screen(lcd_advanced_pause_insert_message);
break;
case ADVANCED_PAUSE_MESSAGE_LOAD:
defer_return_to_status = true;
lcd_goto_screen(lcd_advanced_pause_load_message);
break;
case ADVANCED_PAUSE_MESSAGE_EXTRUDE:
defer_return_to_status = true;
lcd_goto_screen(lcd_advanced_pause_extrude_message);
break;
case ADVANCED_PAUSE_MESSAGE_CLICK_TO_HEAT_NOZZLE:
defer_return_to_status = true;
lcd_goto_screen(lcd_advanced_pause_heat_nozzle);
break;
case ADVANCED_PAUSE_MESSAGE_WAIT_FOR_NOZZLES_TO_HEAT:
defer_return_to_status = true;
lcd_goto_screen(lcd_advanced_pause_wait_for_nozzles_to_heat);
break;
case ADVANCED_PAUSE_MESSAGE_OPTION:
defer_return_to_status = true;
advanced_pause_menu_response = ADVANCED_PAUSE_RESPONSE_WAIT_FOR;
lcd_goto_screen(lcd_advanced_pause_option_menu);
break;
case ADVANCED_PAUSE_MESSAGE_RESUME:
defer_return_to_status = true;
lcd_goto_screen(lcd_advanced_pause_resume_message);
break;
case ADVANCED_PAUSE_MESSAGE_STATUS:
lcd_return_to_status();
break;
}
}
#endif // ADVANCED_PAUSE_FEATURE
2016-06-11 23:12:00 +02:00
/**
*
* Functions for editing single values
*
2017-04-17 04:32:52 +02:00
* The "DEFINE_MENU_EDIT_TYPE" macro generates the functions needed to edit a numerical value.
2016-06-11 23:12:00 +02:00
*
* For example, DEFINE_MENU_EDIT_TYPE(int16_t, int3, itostr3, 1) expands into these functions:
2016-06-11 23:12:00 +02:00
*
* bool _menu_edit_int3();
* void menu_edit_int3(); // edit int16_t (interactively)
* void menu_edit_callback_int3(); // edit int16_t (interactively) with callback on completion
* void _menu_action_setting_edit_int3(const char * const pstr, int16_t * const ptr, const int16_t minValue, const int16_t maxValue);
* void menu_action_setting_edit_int3(const char * const pstr, int16_t * const ptr, const int16_t minValue, const int16_t maxValue);
* void menu_action_setting_edit_callback_int3(const char * const pstr, int16_t * const ptr, const int16_t minValue, const int16_t maxValue, const screenFunc_t callback, const bool live); // edit int16_t with callback
2016-06-11 23:12:00 +02:00
*
* You can then use one of the menu macros to present the edit interface:
2016-07-16 03:49:34 +02:00
* MENU_ITEM_EDIT(int3, MSG_SPEED, &feedrate_percentage, 10, 999)
2016-06-11 23:12:00 +02:00
*
* This expands into a more primitive menu item:
2016-07-16 03:49:34 +02:00
* MENU_ITEM(setting_edit_int3, MSG_SPEED, PSTR(MSG_SPEED), &feedrate_percentage, 10, 999)
2016-06-11 23:12:00 +02:00
*
2017-05-21 02:54:23 +02:00
* ...which calls:
2016-07-16 03:49:34 +02:00
* menu_action_setting_edit_int3(PSTR(MSG_SPEED), &feedrate_percentage, 10, 999)
2016-06-11 23:12:00 +02:00
*/
2017-04-17 04:32:52 +02:00
#define DEFINE_MENU_EDIT_TYPE(_type, _name, _strFunc, _scale) \
2017-05-21 02:54:23 +02:00
bool _menu_edit_ ## _name() { \
2016-06-11 23:12:00 +02:00
ENCODER_DIRECTION_NORMAL(); \
if ((int32_t)encoderPosition < 0) encoderPosition = 0; \
if ((int32_t)encoderPosition > maxEditValue) encoderPosition = maxEditValue; \
if (lcdDrawUpdate) \
2016-12-04 10:51:10 +01:00
lcd_implementation_drawedit(editLabel, _strFunc(((_type)((int32_t)encoderPosition + minEditValue)) * (1.0 / _scale))); \
2017-05-21 02:54:23 +02:00
if (lcd_clicked || (liveEdit && lcdDrawUpdate)) { \
_type value = ((_type)((int32_t)encoderPosition + minEditValue)) * (1.0 / _scale); \
2017-05-21 02:54:23 +02:00
if (editValue != NULL) *((_type*)editValue) = value; \
if (liveEdit) (*callbackFunc)(); \
if (lcd_clicked) lcd_goto_previous_menu(); \
2016-06-11 23:12:00 +02:00
} \
return lcd_clicked; \
} \
2017-05-21 02:54:23 +02:00
void menu_edit_ ## _name() { _menu_edit_ ## _name(); } \
void menu_edit_callback_ ## _name() { if (_menu_edit_ ## _name()) (*callbackFunc)(); } \
void _menu_action_setting_edit_ ## _name(const char * const pstr, _type* const ptr, const _type minValue, const _type maxValue) { \
lcd_save_previous_screen(); \
2016-06-11 23:12:00 +02:00
\
lcdDrawUpdate = LCDVIEW_CLEAR_CALL_REDRAW; \
\
editLabel = pstr; \
editValue = ptr; \
2016-12-04 10:51:10 +01:00
minEditValue = minValue * _scale; \
maxEditValue = maxValue * _scale - minEditValue; \
encoderPosition = (*ptr) * _scale - minEditValue; \
2016-06-11 23:12:00 +02:00
} \
2017-05-21 02:54:23 +02:00
void menu_action_setting_edit_ ## _name(const char * const pstr, _type * const ptr, const _type minValue, const _type maxValue) { \
2016-06-11 23:12:00 +02:00
_menu_action_setting_edit_ ## _name(pstr, ptr, minValue, maxValue); \
2016-06-11 23:19:17 +02:00
currentScreen = menu_edit_ ## _name; \
} \
2017-05-21 02:54:23 +02:00
void menu_action_setting_edit_callback_ ## _name(const char * const pstr, _type * const ptr, const _type minValue, const _type maxValue, const screenFunc_t callback, const bool live) { \
2016-06-11 23:12:00 +02:00
_menu_action_setting_edit_ ## _name(pstr, ptr, minValue, maxValue); \
2016-06-11 23:19:17 +02:00
currentScreen = menu_edit_callback_ ## _name; \
2016-06-11 23:12:00 +02:00
callbackFunc = callback; \
2017-05-21 02:54:23 +02:00
liveEdit = live; \
2016-12-04 10:51:10 +01:00
} \
typedef void _name
DEFINE_MENU_EDIT_TYPE(int16_t, int3, itostr3, 1);
DEFINE_MENU_EDIT_TYPE(uint8_t, int8, i8tostr3, 1);
2017-04-17 04:32:52 +02:00
DEFINE_MENU_EDIT_TYPE(float, float3, ftostr3, 1.0);
DEFINE_MENU_EDIT_TYPE(float, float32, ftostr32, 100.0);
DEFINE_MENU_EDIT_TYPE(float, float43, ftostr43sign, 1000.0);
DEFINE_MENU_EDIT_TYPE(float, float5, ftostr5rj, 0.01);
DEFINE_MENU_EDIT_TYPE(float, float51, ftostr51sign, 10.0);
DEFINE_MENU_EDIT_TYPE(float, float52, ftostr52sign, 100.0);
DEFINE_MENU_EDIT_TYPE(float, float62, ftostr62rj, 100.0);
DEFINE_MENU_EDIT_TYPE(uint32_t, long5, ftostr5rj, 0.01);
2016-06-11 23:12:00 +02:00
/**
*
2017-06-10 07:12:18 +02:00
* Handlers for Keypad input
2016-06-11 23:12:00 +02:00
*
*/
2017-06-10 07:12:18 +02:00
#if ENABLED(ADC_KEYPAD)
2017-06-26 23:01:27 +02:00
inline bool handle_adc_keypad() {
#define ADC_MIN_KEY_DELAY 100
2017-06-10 07:12:18 +02:00
if (buttons_reprapworld_keypad) {
lcdDrawUpdate = LCDVIEW_REDRAW_NOW;
if (encoderDirection == -1) { // side effect which signals we are inside a menu
2017-06-26 23:01:27 +02:00
if (buttons_reprapworld_keypad & EN_REPRAPWORLD_KEYPAD_DOWN) encoderPosition -= ENCODER_STEPS_PER_MENU_ITEM;
else if (buttons_reprapworld_keypad & EN_REPRAPWORLD_KEYPAD_UP) encoderPosition += ENCODER_STEPS_PER_MENU_ITEM;
else if (buttons_reprapworld_keypad & EN_REPRAPWORLD_KEYPAD_LEFT) { menu_action_back(); lcd_quick_feedback(); }
else if (buttons_reprapworld_keypad & EN_REPRAPWORLD_KEYPAD_RIGHT) { lcd_return_to_status(); lcd_quick_feedback(); }
2017-06-10 07:12:18 +02:00
}
else {
if (buttons_reprapworld_keypad & (EN_REPRAPWORLD_KEYPAD_DOWN|EN_REPRAPWORLD_KEYPAD_UP|EN_REPRAPWORLD_KEYPAD_RIGHT)) {
2017-11-03 09:42:52 +01:00
if (buttons_reprapworld_keypad & EN_REPRAPWORLD_KEYPAD_DOWN) encoderPosition += ENCODER_PULSES_PER_STEP;
else if (buttons_reprapworld_keypad & EN_REPRAPWORLD_KEYPAD_UP) encoderPosition -= ENCODER_PULSES_PER_STEP;
else if (buttons_reprapworld_keypad & EN_REPRAPWORLD_KEYPAD_RIGHT) encoderPosition = 0;
}
2017-06-10 07:12:18 +02:00
}
#if ENABLED(ADC_KEYPAD_DEBUG)
SERIAL_PROTOCOLLNPAIR("buttons_reprapworld_keypad = ", (uint32_t)buttons_reprapworld_keypad);
SERIAL_PROTOCOLLNPAIR("encoderPosition = ", (uint32_t)encoderPosition);
#endif
next_button_update_ms = millis() + ADC_MIN_KEY_DELAY;
2017-06-26 23:01:27 +02:00
return true;
2017-06-10 07:12:18 +02:00
}
2017-06-26 23:01:27 +02:00
return false;
2017-06-10 07:12:18 +02:00
}
#elif ENABLED(REPRAPWORLD_KEYPAD)
2017-06-22 16:44:39 +02:00
void _reprapworld_keypad_move(const AxisEnum axis, const int16_t dir) {
2016-06-11 23:12:00 +02:00
move_menu_scale = REPRAPWORLD_KEYPAD_MOVE_STEP;
encoderPosition = dir;
switch (axis) {
case X_AXIS: lcd_move_x(); break;
case Y_AXIS: lcd_move_y(); break;
case Z_AXIS: lcd_move_z();
2016-10-23 03:08:29 +02:00
default: break;
}
2016-06-11 23:12:00 +02:00
}
void reprapworld_keypad_move_z_up() { _reprapworld_keypad_move(Z_AXIS, 1); }
void reprapworld_keypad_move_z_down() { _reprapworld_keypad_move(Z_AXIS, -1); }
void reprapworld_keypad_move_x_left() { _reprapworld_keypad_move(X_AXIS, -1); }
void reprapworld_keypad_move_x_right() { _reprapworld_keypad_move(X_AXIS, 1); }
void reprapworld_keypad_move_y_up() { _reprapworld_keypad_move(Y_AXIS, -1); }
void reprapworld_keypad_move_y_down() { _reprapworld_keypad_move(Y_AXIS, 1); }
void reprapworld_keypad_move_home() { enqueue_and_echo_commands_P(PSTR("G28")); } // move all axes home and wait
void reprapworld_keypad_move_menu() { lcd_goto_screen(lcd_move_menu); }
inline void handle_reprapworld_keypad() {
static uint8_t keypad_debounce = 0;
if (!REPRAPWORLD_KEYPAD_PRESSED) {
if (keypad_debounce > 0) keypad_debounce--;
}
else if (!keypad_debounce) {
keypad_debounce = 2;
if (REPRAPWORLD_KEYPAD_MOVE_MENU) reprapworld_keypad_move_menu();
#if DISABLED(DELTA) && Z_HOME_DIR == -1
if (REPRAPWORLD_KEYPAD_MOVE_Z_UP) reprapworld_keypad_move_z_up();
#endif
if (axis_homed[X_AXIS] && axis_homed[Y_AXIS] && axis_homed[Z_AXIS]) {
#if ENABLED(DELTA) || Z_HOME_DIR != -1
if (REPRAPWORLD_KEYPAD_MOVE_Z_UP) reprapworld_keypad_move_z_up();
#endif
if (REPRAPWORLD_KEYPAD_MOVE_Z_DOWN) reprapworld_keypad_move_z_down();
if (REPRAPWORLD_KEYPAD_MOVE_X_LEFT) reprapworld_keypad_move_x_left();
if (REPRAPWORLD_KEYPAD_MOVE_X_RIGHT) reprapworld_keypad_move_x_right();
if (REPRAPWORLD_KEYPAD_MOVE_Y_DOWN) reprapworld_keypad_move_y_down();
if (REPRAPWORLD_KEYPAD_MOVE_Y_UP) reprapworld_keypad_move_y_up();
}
else {
if (REPRAPWORLD_KEYPAD_MOVE_HOME) reprapworld_keypad_move_home();
}
}
}
2016-06-11 23:12:00 +02:00
#endif // REPRAPWORLD_KEYPAD
2016-06-11 23:12:00 +02:00
/**
*
* Menu actions
*
*/
void _menu_action_back() { lcd_goto_previous_menu(); }
void menu_action_submenu(screenFunc_t func) { lcd_save_previous_screen(); lcd_goto_screen(func); }
void menu_action_gcode(const char* pgcode) { enqueue_and_echo_commands_P(pgcode); }
void menu_action_function(screenFunc_t func) { (*func)(); }
2016-06-11 23:12:00 +02:00
#if ENABLED(SDSUPPORT)
void menu_action_sdfile(const char* filename, char* longFilename) {
#if ENABLED(SD_REPRINT_LAST_SELECTED_FILE)
last_sdfile_encoderPosition = encoderPosition; // Save which file was selected for later use
#endif
2016-06-11 23:12:00 +02:00
UNUSED(longFilename);
card.openAndPrintFile(filename);
lcd_return_to_status();
}
void menu_action_sddirectory(const char* filename, char* longFilename) {
2016-06-11 23:12:00 +02:00
UNUSED(longFilename);
card.chdir(filename);
encoderPosition = 0;
2016-12-02 01:15:58 +01:00
screen_changed = true;
lcdDrawUpdate = LCDVIEW_CLEAR_CALL_REDRAW;
2016-06-11 23:12:00 +02:00
}
2017-05-09 19:35:43 +02:00
#endif // SDSUPPORT
2016-06-11 23:12:00 +02:00
2017-05-21 02:54:23 +02:00
void menu_action_setting_edit_bool(const char* pstr, bool* ptr) { UNUSED(pstr); *ptr ^= true; lcdDrawUpdate = LCDVIEW_CLEAR_CALL_REDRAW; }
void menu_action_setting_edit_callback_bool(const char* pstr, bool* ptr, screenFunc_t callback) {
2016-06-11 23:12:00 +02:00
menu_action_setting_edit_bool(pstr, ptr);
(*callback)();
}
#endif // ULTIPANEL
void lcd_init() {
2017-11-23 00:44:56 +01:00
lcd_implementation_init();
#if ENABLED(NEWPANEL)
#if BUTTON_EXISTS(EN1)
2017-03-08 06:43:33 +01:00
SET_INPUT_PULLUP(BTN_EN1);
2015-12-13 02:57:36 +01:00
#endif
#if BUTTON_EXISTS(EN2)
2017-03-08 06:43:33 +01:00
SET_INPUT_PULLUP(BTN_EN2);
2015-12-13 02:57:36 +01:00
#endif
#if BUTTON_EXISTS(ENC)
2017-03-08 06:43:33 +01:00
SET_INPUT_PULLUP(BTN_ENC);
#endif
2017-06-10 07:12:18 +02:00
#if ENABLED(REPRAPWORLD_KEYPAD) && DISABLED(ADC_KEYPAD)
2016-10-24 12:26:30 +02:00
SET_OUTPUT(SHIFT_CLK);
OUT_WRITE(SHIFT_LD, HIGH);
SET_INPUT_PULLUP(SHIFT_OUT);
#endif
2016-05-03 21:50:49 +02:00
#if BUTTON_EXISTS(UP)
2015-12-24 18:12:25 +01:00
SET_INPUT(BTN_UP);
2016-05-03 21:50:49 +02:00
#endif
#if BUTTON_EXISTS(DWN)
2015-12-24 18:12:25 +01:00
SET_INPUT(BTN_DWN);
2016-05-03 21:50:49 +02:00
#endif
#if BUTTON_EXISTS(LFT)
2015-12-24 18:12:25 +01:00
SET_INPUT(BTN_LFT);
2016-05-03 21:50:49 +02:00
#endif
#if BUTTON_EXISTS(RT)
2015-12-24 18:12:25 +01:00
SET_INPUT(BTN_RT);
2015-12-13 02:57:36 +01:00
#endif
#else // !NEWPANEL
#if ENABLED(SR_LCD_2W_NL) // Non latching 2 wire shift register
2016-10-24 12:26:30 +02:00
SET_OUTPUT(SR_DATA_PIN);
SET_OUTPUT(SR_CLK_PIN);
#elif defined(SHIFT_CLK)
2016-10-24 12:26:30 +02:00
SET_OUTPUT(SHIFT_CLK);
OUT_WRITE(SHIFT_LD, HIGH);
OUT_WRITE(SHIFT_EN, LOW);
SET_INPUT_PULLUP(SHIFT_OUT);
#endif // SR_LCD_2W_NL
#endif // !NEWPANEL
#if ENABLED(SDSUPPORT) && PIN_EXISTS(SD_DETECT)
2017-03-08 06:43:33 +01:00
SET_INPUT_PULLUP(SD_DETECT_PIN);
lcd_sd_status = 2; // UNKNOWN
#endif
#if ENABLED(LCD_HAS_SLOW_BUTTONS)
2013-11-17 17:41:30 +01:00
slow_buttons = 0;
#endif
lcd_buttons_update();
#if ENABLED(ULTIPANEL)
encoderDiff = 0;
#endif
}
int16_t lcd_strlen(const char* s) {
int16_t i = 0, j = 0;
while (s[i]) {
if (PRINTABLE(s[i])) j++;
i++;
}
return j;
}
int16_t lcd_strlen_P(const char* s) {
int16_t j = 0;
while (pgm_read_byte(s)) {
if (PRINTABLE(pgm_read_byte(s))) j++;
s++;
}
return j;
}
bool lcd_blink() {
static uint8_t blink = 0;
static millis_t next_blink_ms = 0;
millis_t ms = millis();
2016-04-11 00:55:12 +02:00
if (ELAPSED(ms, next_blink_ms)) {
blink ^= 0xFF;
next_blink_ms = ms + 1000 - LCD_UPDATE_INTERVAL / 2;
}
return blink != 0;
}
/**
* Update the LCD, read encoder buttons, etc.
* - Read button states
* - Check the SD Card slot state
* - Act on RepRap World keypad input
* - Update the encoder position
* - Apply acceleration to the encoder position
* - Set lcdDrawUpdate = LCDVIEW_CALL_REDRAW_NOW on controller events
* - Reset the Info Screen timeout if there's any input
* - Update status indicators, if any
*
2016-04-03 01:09:56 +02:00
* Run the current LCD menu handler callback function:
* - Call the handler only if lcdDrawUpdate != LCDVIEW_NONE
* - Before calling the handler, LCDVIEW_CALL_NO_REDRAW => LCDVIEW_NONE
2016-04-03 01:09:56 +02:00
* - Call the menu handler. Menu handlers should do the following:
* - If a value changes, set lcdDrawUpdate to LCDVIEW_REDRAW_NOW and draw the value
* (Encoder events automatically set lcdDrawUpdate for you.)
2016-04-03 01:09:56 +02:00
* - if (lcdDrawUpdate) { redraw }
* - Before exiting the handler set lcdDrawUpdate to:
* - LCDVIEW_CLEAR_CALL_REDRAW to clear screen and set LCDVIEW_CALL_REDRAW_NEXT.
2017-05-25 22:13:57 +02:00
* - LCDVIEW_REDRAW_NOW to draw now (including remaining stripes).
* - LCDVIEW_CALL_REDRAW_NEXT to draw now and get LCDVIEW_REDRAW_NOW on the next loop.
* - LCDVIEW_CALL_NO_REDRAW to draw now and get LCDVIEW_NONE on the next loop.
* - NOTE: For graphical displays menu handlers may be called 2 or more times per loop,
* so don't change lcdDrawUpdate without considering this.
2016-04-03 01:09:56 +02:00
*
* After the menu handler callback runs (or not):
* - Clear the LCD if lcdDrawUpdate == LCDVIEW_CLEAR_CALL_REDRAW
* - Update lcdDrawUpdate for the next loop (i.e., move one state down, usually)
2016-04-03 01:09:56 +02:00
*
* No worries. This function is only called from the main thread.
*/
void lcd_update() {
2016-06-11 23:12:00 +02:00
#if ENABLED(ULTIPANEL)
2015-04-13 03:07:08 +02:00
static millis_t return_to_status_ms = 0;
manage_manual_move();
lcd_buttons_update();
2017-11-24 22:47:29 +01:00
#if ENABLED(AUTO_BED_LEVELING_UBL)
// Don't run the debouncer if UBL owns the display
#define UBL_CONDITION !lcd_external_control
2017-03-18 16:15:54 +01:00
#else
2017-11-24 22:47:29 +01:00
#define UBL_CONDITION true
2017-03-18 16:15:54 +01:00
#endif
// If the action button is pressed...
2017-03-18 16:15:54 +01:00
if (UBL_CONDITION && LCD_CLICKED) {
if (!wait_for_unclick) { // If not waiting for a debounce release:
wait_for_unclick = true; // Set debounce flag to ignore continous clicks
lcd_clicked = !wait_for_user; // Keep the click if not waiting for a user-click
wait_for_user = false; // Any click clears wait for user
lcd_quick_feedback(); // Always make a click sound
}
}
else wait_for_unclick = false;
#endif
#if ENABLED(SDSUPPORT) && PIN_EXISTS(SD_DETECT)
2017-04-17 04:32:52 +02:00
const bool sd_status = IS_SD_INSERTED;
if (sd_status != lcd_sd_status && lcd_detected()) {
if (sd_status) {
card.initsd();
if (lcd_sd_status != 2) LCD_MESSAGEPGM(MSG_SD_INSERTED);
}
else {
card.release();
if (lcd_sd_status != 2) LCD_MESSAGEPGM(MSG_SD_REMOVED);
}
2016-08-09 05:53:18 +02:00
lcd_sd_status = sd_status;
lcdDrawUpdate = LCDVIEW_CLEAR_CALL_REDRAW;
lcd_implementation_init( // to maybe revive the LCD if static electricity killed it.
#if ENABLED(LCD_PROGRESS_BAR)
2017-11-23 00:44:56 +01:00
currentScreen == lcd_status_screen ? CHARSET_INFO : CHARSET_MENU
#endif
);
}
2017-05-09 19:35:43 +02:00
#endif // SDSUPPORT && SD_DETECT_PIN
2017-04-17 04:32:52 +02:00
const millis_t ms = millis();
if (ELAPSED(ms, next_lcd_update_ms)
#if ENABLED(DOGLCD)
|| drawing_screen
#endif
) {
next_lcd_update_ms = ms + LCD_UPDATE_INTERVAL;
#if ENABLED(LCD_HAS_STATUS_INDICATORS)
lcd_implementation_update_indicators();
#endif
#if ENABLED(ULTIPANEL)
2016-08-21 01:12:57 +02:00
#if ENABLED(LCD_HAS_SLOW_BUTTONS)
slow_buttons = lcd_implementation_read_slow_buttons(); // buttons which take too long to read in interrupt context
#endif
2017-06-10 07:12:18 +02:00
#if ENABLED(ADC_KEYPAD)
2017-06-26 23:01:27 +02:00
if (handle_adc_keypad())
return_to_status_ms = ms + LCD_TIMEOUT_TO_STATUS;
2017-06-10 07:12:18 +02:00
#elif ENABLED(REPRAPWORLD_KEYPAD)
handle_reprapworld_keypad();
2017-06-10 07:12:18 +02:00
#endif
const bool encoderPastThreshold = (abs(encoderDiff) >= ENCODER_PULSES_PER_STEP);
if (encoderPastThreshold || lcd_clicked) {
if (encoderPastThreshold) {
2015-02-22 05:18:49 +01:00
int32_t encoderMultiplier = 1;
#if ENABLED(ENCODER_RATE_MULTIPLIER)
2015-02-22 05:18:49 +01:00
if (encoderRateMultiplierEnabled) {
int32_t encoderMovementSteps = abs(encoderDiff) / ENCODER_PULSES_PER_STEP;
2017-06-10 07:12:18 +02:00
if (lastEncoderMovementMillis) {
// Note that the rate is always calculated between two passes through the
2015-02-22 05:18:49 +01:00
// loop and that the abs of the encoderDiff value is tracked.
2017-06-10 07:12:18 +02:00
float encoderStepRate = float(encoderMovementSteps) / float(ms - lastEncoderMovementMillis) * 1000.0;
2015-02-22 05:18:49 +01:00
if (encoderStepRate >= ENCODER_100X_STEPS_PER_SEC) encoderMultiplier = 100;
else if (encoderStepRate >= ENCODER_10X_STEPS_PER_SEC) encoderMultiplier = 10;
#if ENABLED(ENCODER_RATE_MULTIPLIER_DEBUG)
2017-06-09 17:51:23 +02:00
SERIAL_ECHO_START();
SERIAL_ECHOPAIR("Enc Step Rate: ", encoderStepRate);
SERIAL_ECHOPAIR(" Multiplier: ", encoderMultiplier);
SERIAL_ECHOPAIR(" ENCODER_10X_STEPS_PER_SEC: ", ENCODER_10X_STEPS_PER_SEC);
SERIAL_ECHOPAIR(" ENCODER_100X_STEPS_PER_SEC: ", ENCODER_100X_STEPS_PER_SEC);
2017-06-09 17:51:23 +02:00
SERIAL_EOL();
2017-05-09 19:35:43 +02:00
#endif // ENCODER_RATE_MULTIPLIER_DEBUG
2015-02-22 05:18:49 +01:00
}
lastEncoderMovementMillis = ms;
} // encoderRateMultiplierEnabled
2017-05-09 19:35:43 +02:00
#endif // ENCODER_RATE_MULTIPLIER
2015-02-22 05:18:49 +01:00
encoderPosition += (encoderDiff * encoderMultiplier) / ENCODER_PULSES_PER_STEP;
encoderDiff = 0;
}
2015-04-13 03:07:08 +02:00
return_to_status_ms = ms + LCD_TIMEOUT_TO_STATUS;
2017-05-25 22:13:57 +02:00
lcdDrawUpdate = LCDVIEW_REDRAW_NOW;
}
#endif // ULTIPANEL
// We arrive here every ~100ms when idling often enough.
// Instead of tracking the changes simply redraw the Info Screen ~1 time a second.
if (
#if ENABLED(ULTIPANEL)
currentScreen == lcd_status_screen &&
#endif
!lcd_status_update_delay--
) {
lcd_status_update_delay = 9
2016-12-14 13:20:33 +01:00
#if ENABLED(DOGLCD)
+ 3
#endif
;
max_display_update_time--;
lcdDrawUpdate = LCDVIEW_REDRAW_NOW;
}
2015-04-13 03:07:08 +02:00
#if ENABLED(SCROLL_LONG_FILENAMES)
// If scrolling of long file names is enabled and we are in the sd card menu,
// cause a refresh to occur until all the text has scrolled into view.
if (currentScreen == lcd_sdcard_menu && filename_scroll_pos < filename_scroll_max && !lcd_status_update_delay--) {
lcd_status_update_delay = 6;
lcdDrawUpdate = LCDVIEW_REDRAW_NOW;
filename_scroll_pos++;
return_to_status_ms = ms + LCD_TIMEOUT_TO_STATUS;
}
#endif
// then we want to use 1/2 of the time only.
uint16_t bbr2 = planner.block_buffer_runtime() >> 1;
#if ENABLED(DOGLCD)
#define IS_DRAWING drawing_screen
#else
#define IS_DRAWING false
#endif
if ((lcdDrawUpdate || IS_DRAWING) && (!bbr2 || bbr2 > max_display_update_time)) {
2017-11-08 07:31:48 +01:00
if (!IS_DRAWING) switch (lcdDrawUpdate) {
case LCDVIEW_CALL_NO_REDRAW:
lcdDrawUpdate = LCDVIEW_NONE;
break;
case LCDVIEW_CLEAR_CALL_REDRAW: // set by handlers, then altered after (rarely occurs here)
case LCDVIEW_CALL_REDRAW_NEXT: // set by handlers, then altered after (never occurs here?)
lcdDrawUpdate = LCDVIEW_REDRAW_NOW;
case LCDVIEW_REDRAW_NOW: // set above, or by a handler through LCDVIEW_CALL_REDRAW_NEXT
case LCDVIEW_NONE:
break;
} // switch
2017-06-10 07:12:18 +02:00
#if ENABLED(ADC_KEYPAD)
buttons_reprapworld_keypad = 0;
#endif
#if ENABLED(ULTIPANEL)
#define CURRENTSCREEN() (*currentScreen)(), lcd_clicked = false
#else
#define CURRENTSCREEN() lcd_status_screen()
#endif
2017-11-08 07:31:48 +01:00
#if ENABLED(DOGLCD)
if (!drawing_screen) { // If not already drawing pages
u8g.firstPage(); // Start the first page
drawing_screen = 1; // Flag as drawing pages
}
2017-11-08 07:31:48 +01:00
lcd_setFont(FONT_MENU); // Setup font for every page draw
u8g.setColorIndex(1); // And reset the color
CURRENTSCREEN(); // Draw and process the current screen
// The screen handler can clear drawing_screen for an action that changes the screen.
// If still drawing and there's another page, update max-time and return now.
// The nextPage will already be set up on the next call.
if (drawing_screen && (drawing_screen = u8g.nextPage())) {
2016-12-14 13:20:33 +01:00
NOLESS(max_display_update_time, millis() - ms);
return;
}
#else
CURRENTSCREEN();
#endif
2017-11-08 07:31:48 +01:00
// Keeping track of the longest time for an individual LCD update.
// Used to do screen throttling when the planner starts to fill up.
2016-12-14 13:20:33 +01:00
NOLESS(max_display_update_time, millis() - ms);
}
#if ENABLED(ULTIPANEL)
// Return to Status Screen after a timeout
if (currentScreen == lcd_status_screen || defer_return_to_status)
return_to_status_ms = ms + LCD_TIMEOUT_TO_STATUS;
else if (ELAPSED(ms, return_to_status_ms))
lcd_return_to_status();
#endif // ULTIPANEL
2017-11-08 07:31:48 +01:00
if (!IS_DRAWING) switch (lcdDrawUpdate) {
case LCDVIEW_CLEAR_CALL_REDRAW:
lcd_implementation_clear();
case LCDVIEW_CALL_REDRAW_NEXT:
lcdDrawUpdate = LCDVIEW_REDRAW_NOW;
break;
case LCDVIEW_REDRAW_NOW:
lcdDrawUpdate = LCDVIEW_NONE;
break;
case LCDVIEW_NONE:
break;
} // switch
Distribute GLCD screen updates in time Currently we draw and send the screens for a graphical LCD all at once. We draw in two or four parts but draw them directly behind each other. For the tested status screen this takes 59-62ms in a single block. During this time nothing else (except the interrupts) can be done. When printing a sequence of very short moves the buffer drains - sometimes until it's empty. This PR splits the screen update into parts. Currently we have 10 time slots. During the first one the complete screen is drawn. (60,0,0,0,0,0,0,0,0,0,0) Here i introduce pauses for doing other things. (30,30,0,0,0,0,0,0) or (15,15,15,15,0,0,0,0,0,0) Drawing in consecutive time slots prevents from lagging too much. Even with a 4 stripe display all the drawing is done after 400ms. Previous experiments with a even better distribution of the time slots like (30,0,0,0,0,30,0,0,0,0) and (15,0,15,0,15,0,15,0,0,0) did not feel good when using the menu, because of too much lag. Because of the previous PRs to speed up the display updates and especially reducing the difference between drawing 2 or 4 stripes, it now makes sense for the REPRAP_DISCOUNT_FULL_GRAPHIC_SMART_CONTROLLER to go from 2 to 4 stripes. This costs about 1-2ms per complete screen update, but is payed back by having partial updates lasting only the half time and two additional brakes. Also ~256 byte of framebuffer are saved in RAM. 13:45:59.213 : echo: #:17 >:13 s:30; #:16 >:13 s:29; S#:33 S>:26 S:59 13:46:00.213 : echo: #:16 >:14 s:30; #:17 >:13 s:30; S#:33 S>:27 S:60 13:46:01.215 : echo: #:17 >:13 s:30; #:16 >:13 s:29; S#:33 S>:26 S:59 13:46:02.215 : echo: #:16 >:13 s:29; #:16 >:14 s:30; S#:32 S>:27 S:59 13:46:03.214 : echo: #:17 >:13 s:30; #:17 >:13 s:30; S#:34 S>:26 S:60 13:46:04.214 : echo: #:16 >:13 s:29; #:16 >:14 s:30; S#:32 S>:27 S:59 13:46:05.212 : echo: #:16 >:14 s:30; #:17 >:13 s:30; S#:33 S>:27 S:60 13:46:06.212 : echo: #:17 >:13 s:30; #:16 >:13 s:29; S#:33 S>:26 S:59 03:30:36.779 : echo: #:8 >:7 s:15; #:10 >:7 s:17; #:8 >:6 s:14; #:8 >:7 s:15; S#:34 S>:27 S:61 03:30:37.778 : echo: #:8 >:6 s:14; #:10 >:7 s:17; #:9 >:7 s:16; #:8 >:6 s:14; S#:35 S>:26 S:61 03:30:38.778 : echo: #:8 >:6 s:14; #:11 >:7 s:18; #:8 >:6 s:14; #:8 >:7 s:15; S#:35 S>:26 S:61 03:30:39.777 : echo: #:8 >:6 s:14; #:10 >:7 s:17; #:8 >:8 s:16; #:8 >:6 s:14; S#:34 S>:27 S:61 03:30:40.780 : echo: #:8 >:6 s:14; #:11 >:7 s:18; #:8 >:6 s:14; #:8 >:6 s:14; S#:35 S>:25 S:60 03:30:41.780 : echo: #:9 >:6 s:15; #:10 >:7 s:17; #:8 >:6 s:14; #:9 >:6 s:15; S#:36 S>:25 S:61 03:30:42.779 : echo: #:8 >:6 s:14; #:10 >:8 s:18; #:8 >:6 s:14; #:8 >:6 s:14; S#:34 S>:26 S:60 03:30:43.778 : echo: #:9 >:6 s:15; #:10 >:7 s:17; #:8 >:7 s:15; #:9 >:6 s:15; S#:36 S>:26 S:62 #: draw a stripe >: transfer a stripe s: sum of of draw and transfer for one stripe S#: sum of draws for a complete screen S>: sum of transfers for a complete screen S: time to draw and transfer a complete screen
2016-11-24 21:17:25 +01:00
} // ELAPSED(ms, next_lcd_update_ms)
}
inline void pad_message_string() {
uint8_t i = 0, j = 0;
char c;
while ((c = lcd_status_message[i]) && j < LCD_WIDTH) {
if (PRINTABLE(c)) j++;
i++;
2016-07-17 20:33:01 +02:00
}
if (true
#if ENABLED(STATUS_MESSAGE_SCROLLING)
&& j < LCD_WIDTH
#endif
) {
// pad with spaces to fill up the line
while (j++ < LCD_WIDTH) lcd_status_message[i++] = ' ';
// chop off at the edge
lcd_status_message[i] = '\0';
}
}
2016-07-17 20:33:01 +02:00
void lcd_finishstatus(const bool persist=false) {
pad_message_string();
2017-05-28 18:12:12 +02:00
2016-04-02 23:28:17 +02:00
#if !(ENABLED(LCD_PROGRESS_BAR) && (PROGRESS_MSG_EXPIRE > 0))
UNUSED(persist);
#endif
#if ENABLED(LCD_PROGRESS_BAR)
progress_bar_ms = millis();
2014-12-28 07:26:14 +01:00
#if PROGRESS_MSG_EXPIRE > 0
expire_status_ms = persist ? 0 : progress_bar_ms + PROGRESS_MSG_EXPIRE;
2014-12-28 07:26:14 +01:00
#endif
#endif
lcdDrawUpdate = LCDVIEW_CLEAR_CALL_REDRAW;
2014-12-28 07:26:14 +01:00
#if ENABLED(FILAMENT_LCD_DISPLAY) && ENABLED(SDSUPPORT)
2015-04-13 03:07:08 +02:00
previous_lcd_status_ms = millis(); //get status message to show up for a while
2014-12-28 07:26:14 +01:00
#endif
2017-05-28 18:12:12 +02:00
#if ENABLED(STATUS_MESSAGE_SCROLLING)
status_scroll_pos = 0;
#endif
2014-12-28 07:26:14 +01:00
}
#if ENABLED(LCD_PROGRESS_BAR) && PROGRESS_MSG_EXPIRE > 0
void dontExpireStatus() { expire_status_ms = 0; }
#endif
bool lcd_hasstatus() { return (lcd_status_message[0] != '\0'); }
void lcd_setstatus(const char * const message, const bool persist) {
if (lcd_status_message_level > 0) return;
2016-03-13 07:38:55 +01:00
strncpy(lcd_status_message, message, 3 * (LCD_WIDTH));
lcd_finishstatus(persist);
}
void lcd_setstatusPGM(const char * const message, int8_t level) {
if (level < 0) level = lcd_status_message_level = 0;
2016-07-17 20:33:01 +02:00
if (level < lcd_status_message_level) return;
lcd_status_message_level = level;
strncpy_P(lcd_status_message, message, 3 * (LCD_WIDTH));
lcd_finishstatus(level > 0);
}
2017-04-02 07:46:37 +02:00
void lcd_status_printf_P(const uint8_t level, const char * const fmt, ...) {
if (level < lcd_status_message_level) return;
lcd_status_message_level = level;
va_list args;
2017-04-02 07:46:37 +02:00
va_start(args, fmt);
vsnprintf_P(lcd_status_message, 3 * (LCD_WIDTH), fmt, args);
va_end(args);
lcd_finishstatus(level > 0);
}
void lcd_setalertstatusPGM(const char * const message) {
lcd_setstatusPGM(message, 1);
#if ENABLED(ULTIPANEL)
lcd_return_to_status();
#endif
}
void lcd_reset_alert_level() { lcd_status_message_level = 0; }
2016-05-31 20:47:02 +02:00
#if HAS_LCD_CONTRAST
2017-05-21 02:54:23 +02:00
2017-05-21 19:01:44 +02:00
void set_lcd_contrast(const uint16_t value) {
lcd_contrast = constrain(value, LCD_CONTRAST_MIN, LCD_CONTRAST_MAX);
u8g.setContrast(lcd_contrast);
}
2017-05-21 02:54:23 +02:00
#endif
#if ENABLED(ULTIPANEL)
/**
* Setup Rotary Encoder Bit Values (for two pin encoders to indicate movement)
* These values are independent of which pins are used for EN_A and EN_B indications
* The rotary encoder part is also independent to the chipset used for the LCD
*/
#if defined(EN_A) && defined(EN_B)
#define encrot0 0
#define encrot1 2
#define encrot2 3
#define encrot3 1
#endif
#define GET_BUTTON_STATES(DST) \
uint8_t new_##DST = 0; \
WRITE(SHIFT_LD, LOW); \
WRITE(SHIFT_LD, HIGH); \
for (int8_t i = 0; i < 8; i++) { \
new_##DST >>= 1; \
if (READ(SHIFT_OUT)) SBI(new_##DST, 7); \
WRITE(SHIFT_CLK, HIGH); \
WRITE(SHIFT_CLK, LOW); \
} \
DST = ~new_##DST; //invert it, because a pressed switch produces a logical 0
/**
* Read encoder buttons from the hardware registers
* Warning: This function is called from interrupt context!
*/
void lcd_buttons_update() {
2017-04-17 04:32:52 +02:00
static uint8_t lastEncoderBits;
millis_t now = millis();
if (ELAPSED(now, next_button_update_ms)) {
#if ENABLED(NEWPANEL)
uint8_t newbutton = 0;
#if BUTTON_EXISTS(EN1)
if (BUTTON_PRESSED(EN1)) newbutton |= EN_A;
#endif
#if BUTTON_EXISTS(EN2)
if (BUTTON_PRESSED(EN2)) newbutton |= EN_B;
#endif
#if BUTTON_EXISTS(ENC)
if (BUTTON_PRESSED(ENC)) newbutton |= EN_C;
#endif
#if LCD_HAS_DIRECTIONAL_BUTTONS
2016-05-03 21:50:49 +02:00
// Manage directional buttons
#if ENABLED(REVERSE_MENU_DIRECTION)
#define _ENCODER_UD_STEPS (ENCODER_STEPS_PER_MENU_ITEM * encoderDirection)
#else
#define _ENCODER_UD_STEPS ENCODER_STEPS_PER_MENU_ITEM
#endif
#if ENABLED(REVERSE_ENCODER_DIRECTION)
#define ENCODER_UD_STEPS _ENCODER_UD_STEPS
#define ENCODER_LR_PULSES ENCODER_PULSES_PER_STEP
#else
#define ENCODER_UD_STEPS -(_ENCODER_UD_STEPS)
#define ENCODER_LR_PULSES -(ENCODER_PULSES_PER_STEP)
#endif
2016-05-03 21:50:49 +02:00
if (false) {
// for the else-ifs below
}
2016-05-03 21:50:49 +02:00
#if BUTTON_EXISTS(UP)
else if (BUTTON_PRESSED(UP)) {
encoderDiff = -(ENCODER_UD_STEPS);
2016-05-03 21:50:49 +02:00
next_button_update_ms = now + 300;
}
#endif
#if BUTTON_EXISTS(DWN)
else if (BUTTON_PRESSED(DWN)) {
encoderDiff = ENCODER_UD_STEPS;
2016-05-03 21:50:49 +02:00
next_button_update_ms = now + 300;
}
#endif
#if BUTTON_EXISTS(LFT)
else if (BUTTON_PRESSED(LFT)) {
encoderDiff = -(ENCODER_LR_PULSES);
2016-05-03 21:50:49 +02:00
next_button_update_ms = now + 300;
}
#endif
#if BUTTON_EXISTS(RT)
else if (BUTTON_PRESSED(RT)) {
encoderDiff = ENCODER_LR_PULSES;
2016-05-03 21:50:49 +02:00
next_button_update_ms = now + 300;
}
#endif
#endif // LCD_HAS_DIRECTIONAL_BUTTONS
2016-05-03 21:50:49 +02:00
buttons = newbutton;
#if ENABLED(LCD_HAS_SLOW_BUTTONS)
buttons |= slow_buttons;
#endif
2017-06-10 07:12:18 +02:00
#if ENABLED(ADC_KEYPAD)
uint8_t newbutton_reprapworld_keypad = 0;
buttons = 0;
if (buttons_reprapworld_keypad == 0) {
newbutton_reprapworld_keypad = get_ADC_keyValue();
if (WITHIN(newbutton_reprapworld_keypad, 1, 8))
buttons_reprapworld_keypad = _BV(newbutton_reprapworld_keypad - 1);
}
#elif ENABLED(REPRAPWORLD_KEYPAD)
GET_BUTTON_STATES(buttons_reprapworld_keypad);
2017-06-10 07:12:18 +02:00
#endif
2017-06-10 07:12:18 +02:00
#else
GET_BUTTON_STATES(buttons);
2017-05-09 19:35:43 +02:00
#endif // !NEWPANEL
} // next_button_update_ms
// Manage encoder rotation
2016-05-12 00:39:28 +02:00
#if ENABLED(REVERSE_MENU_DIRECTION) && ENABLED(REVERSE_ENCODER_DIRECTION)
#define ENCODER_DIFF_CW (encoderDiff -= encoderDirection)
#define ENCODER_DIFF_CCW (encoderDiff += encoderDirection)
#elif ENABLED(REVERSE_MENU_DIRECTION)
#define ENCODER_DIFF_CW (encoderDiff += encoderDirection)
#define ENCODER_DIFF_CCW (encoderDiff -= encoderDirection)
2016-05-12 00:39:28 +02:00
#elif ENABLED(REVERSE_ENCODER_DIRECTION)
#define ENCODER_DIFF_CW (encoderDiff--)
#define ENCODER_DIFF_CCW (encoderDiff++)
#else
#define ENCODER_DIFF_CW (encoderDiff++)
#define ENCODER_DIFF_CCW (encoderDiff--)
#endif
#define ENCODER_SPIN(_E1, _E2) switch (lastEncoderBits) { case _E1: ENCODER_DIFF_CW; break; case _E2: ENCODER_DIFF_CCW; }
uint8_t enc = 0;
if (buttons & EN_A) enc |= B01;
if (buttons & EN_B) enc |= B10;
if (enc != lastEncoderBits) {
switch (enc) {
case encrot0: ENCODER_SPIN(encrot3, encrot1); break;
case encrot1: ENCODER_SPIN(encrot0, encrot2); break;
case encrot2: ENCODER_SPIN(encrot1, encrot3); break;
case encrot3: ENCODER_SPIN(encrot2, encrot0); break;
}
2017-03-18 16:15:54 +01:00
#if ENABLED(AUTO_BED_LEVELING_UBL)
if (lcd_external_control) {
2017-05-22 18:42:17 +02:00
ubl.encoder_diff = encoderDiff; // Make the encoder's rotation available to G29's Mesh Editor
2017-03-18 16:15:54 +01:00
encoderDiff = 0; // We are going to lie to the LCD Panel and claim the encoder
2017-05-22 18:42:17 +02:00
// knob has not turned.
2017-03-18 16:15:54 +01:00
}
#endif
lastEncoderBits = enc;
}
}
2016-11-04 00:03:02 +01:00
#if (ENABLED(LCD_I2C_TYPE_MCP23017) || ENABLED(LCD_I2C_TYPE_MCP23008)) && ENABLED(DETECT_DEVICE)
bool lcd_detected() { return lcd.LcdDetected() == 1; }
2016-12-08 06:29:06 +01:00
#else
bool lcd_detected() { return true; }
2016-11-04 00:03:02 +01:00
#endif
#if ENABLED(G26_MESH_VALIDATION)
void lcd_chirp() {
2017-03-18 16:15:54 +01:00
#if ENABLED(LCD_USE_I2C_BUZZER)
lcd.buzz(LCD_FEEDBACK_FREQUENCY_DURATION_MS, LCD_FEEDBACK_FREQUENCY_HZ);
#elif PIN_EXISTS(BEEPER)
buzzer.tone(LCD_FEEDBACK_FREQUENCY_DURATION_MS, LCD_FEEDBACK_FREQUENCY_HZ);
#endif
}
#endif
2017-03-18 16:15:54 +01:00
#if ENABLED(AUTO_BED_LEVELING_UBL) || ENABLED(G26_MESH_VALIDATION)
bool is_lcd_clicked() { return LCD_CLICKED; }
2017-03-18 16:15:54 +01:00
#endif
#endif // ULTIPANEL
2017-06-10 07:12:18 +02:00
#if ENABLED(ADC_KEYPAD)
typedef struct {
uint16_t ADCKeyValueMin, ADCKeyValueMax;
uint8_t ADCKeyNo;
} _stADCKeypadTable_;
2017-06-26 23:01:27 +02:00
static const _stADCKeypadTable_ stADCKeyTable[] PROGMEM = {
2017-06-10 07:12:18 +02:00
// VALUE_MIN, VALUE_MAX, KEY
{ 4000, 4096, BLEN_REPRAPWORLD_KEYPAD_F1 + 1 }, // F1
{ 4000, 4096, BLEN_REPRAPWORLD_KEYPAD_F2 + 1 }, // F2
{ 4000, 4096, BLEN_REPRAPWORLD_KEYPAD_F3 + 1 }, // F3
{ 300, 500, BLEN_REPRAPWORLD_KEYPAD_LEFT + 1 }, // LEFT
{ 1900, 2200, BLEN_REPRAPWORLD_KEYPAD_RIGHT + 1 }, // RIGHT
{ 570, 870, BLEN_REPRAPWORLD_KEYPAD_UP + 1 }, // UP
{ 2670, 2870, BLEN_REPRAPWORLD_KEYPAD_DOWN + 1 }, // DOWN
{ 1150, 1450, BLEN_REPRAPWORLD_KEYPAD_MIDDLE + 1 }, // ENTER
};
uint8_t get_ADC_keyValue(void) {
if (thermalManager.ADCKey_count >= 16) {
const uint16_t currentkpADCValue = thermalManager.current_ADCKey_raw >> 2;
#if ENABLED(ADC_KEYPAD_DEBUG)
SERIAL_PROTOCOLLN(currentkpADCValue);
#endif
thermalManager.current_ADCKey_raw = 0;
thermalManager.ADCKey_count = 0;
if (currentkpADCValue < 4000)
for (uint8_t i = 0; i < ADC_KEY_NUM; i++) {
const uint16_t lo = pgm_read_word(&stADCKeyTable[i].ADCKeyValueMin),
hi = pgm_read_word(&stADCKeyTable[i].ADCKeyValueMax);
if (WITHIN(currentkpADCValue, lo, hi)) return pgm_read_byte(&stADCKeyTable[i].ADCKeyNo);
}
}
return 0;
}
#endif
#endif // ULTRA_LCD