Firmware2/Marlin/ultralcd.cpp

4697 lines
157 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 "ultralcd.h"
#if ENABLED(ULTRA_LCD)
#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"
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"
bool ubl_lcd_map_control = false;
#endif
int16_t lcd_preheat_hotend_temp[2], lcd_preheat_bed_temp[2], lcd_preheat_fan_speed[2];
#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_message_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(DOGLCD)
#include "ultralcd_impl_DOGM.h"
#include <U8glib.h>
#else
#include "ultralcd_impl_HD44780.h"
#endif
// 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)();
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-03-18 16:15:54 +01: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
#if ENABLED(DELTA_CALIBRATION_MENU)
void lcd_delta_calibrate_menu();
#endif
2017-03-15 09:32:00 +01:00
#if ENABLED(MESH_BED_LEVELING) && ENABLED(LCD_BED_LEVELING)
#include "mesh_bed_leveling.h"
extern void mesh_probing_done();
#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(screenFunc_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
#define ENCODER_FEEDRATE_DEADZONE 10
#endif
#ifndef ENCODER_STEPS_PER_MENU_ITEM
#define ENCODER_STEPS_PER_MENU_ITEM 5
#endif
#ifndef ENCODER_PULSES_PER_STEP
#define ENCODER_PULSES_PER_STEP 1
#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-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;
2016-06-11 23:19:17 +02:00
screen_history_depth = 0;
2016-06-11 23:12:00 +02:00
}
lcd_implementation_clear();
2016-06-11 23:12:00 +02:00
#if ENABLED(LCD_PROGRESS_BAR)
// For LCD_PROGRESS_BAR re-initialize custom characters
2016-06-11 23:19:17 +02:00
lcd_set_custom_characters(screen == lcd_status_screen);
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();
}
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)
2015-04-13 03:07:08 +02:00
millis_t ms = millis();
#if DISABLED(PROGRESS_MSG_ONCE)
2016-04-11 00:55:12 +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
#if PROGRESS_MSG_EXPIRE > 0
// Handle message expire
if (expire_status_ms > 0) {
#if ENABLED(SDSUPPORT)
if (card.isFileOpen()) {
// Expire the message when printing is active
if (IS_SD_PRINTING) {
2016-04-11 00:55:12 +02:00
if (ELAPSED(ms, expire_status_ms)) {
lcd_status_message[0] = '\0';
expire_status_ms = 0;
}
}
else {
expire_status_ms += LCD_UPDATE_INTERVAL;
2014-12-28 07:26:14 +01:00
}
}
else {
expire_status_ms = 0;
2014-12-28 07:26:14 +01:00
}
#else
expire_status_ms = 0;
2017-05-09 19:35:43 +02:00
#endif // SDSUPPORT
2014-12-28 07:26:14 +01:00
}
#endif
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)
false
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);
2016-07-10 04:50:45 +02:00
#if ENABLED(DOGLCD)
u8g.firstPage();
do {
lcd_kill_screen();
} while (u8g.nextPage());
#else
lcd_kill_screen();
#endif
}
#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)
extern int case_light_brightness;
extern bool case_light_on;
extern void update_case_light();
void case_light_menu() {
START_MENU();
//
// ^ Main
//
MENU_BACK(MSG_MAIN);
MENU_ITEM_EDIT_CALLBACK(int3, 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();
lcd_set_custom_characters(false);
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);
lcd.print(itostr3(bar_percent)); lcd.print('%');
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) {
lcd_return_to_status();
enqueue_and_echo_commands_P(cmd);
}
#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);
#if ENABLED(DELTA_CALIBRATION_MENU)
MENU_ITEM(submenu, MSG_DELTA_CALIBRATE, lcd_delta_calibrate_menu);
#endif
}
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
2016-06-11 23:12:00 +02:00
#if ENABLED(BABYSTEPPING)
void _lcd_babystep(const AxisEnum axis, const char* msg) {
if (lcd_clicked) { defer_return_to_status = false; return lcd_goto_previous_menu(); }
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)
void _lcd_babystep_x() { _lcd_babystep(X_AXIS, PSTR(MSG_BABYSTEPPING_X)); }
void _lcd_babystep_y() { _lcd_babystep(Y_AXIS, PSTR(MSG_BABYSTEPPING_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() {
if (lcd_clicked) { defer_return_to_status = false; return lcd_goto_previous_menu(); }
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.abl_enabled)
thermalManager.babystep_axis(Z_AXIS, babystep_increment);
zprobe_zoffset = new_zoffset;
refresh_zprobe_zoffset(true);
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));
}
#else // !BABYSTEP_ZPROBE_OFFSET
void _lcd_babystep_z() { _lcd_babystep(Z_AXIS, PSTR(MSG_BABYSTEPPING_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-03-20 07:42:41 +01:00
if (lcdDrawUpdate)
lcd_implementation_drawedit(msg, ftostr43sign(mesh_edit_value));
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
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
#if FAN_COUNT > 1
#define MSG_1ST_FAN_SPEED MSG_FAN_SPEED " 1"
#else
#define MSG_1ST_FAN_SPEED MSG_FAN_SPEED
2016-04-29 03:18:13 +02:00
#endif
2016-06-11 23:12:00 +02:00
MENU_MULTIPLIER_ITEM_EDIT(int3, MSG_1ST_FAN_SPEED, &fanSpeeds[0], 0, 255);
#endif
#if HAS_FAN1
MENU_MULTIPLIER_ITEM_EDIT(int3, MSG_FAN_SPEED " 2", &fanSpeeds[1], 0, 255);
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);
#endif
#endif // FAN_COUNT > 0
//
// Flow:
// Flow [1-5]:
2016-06-11 23:12:00 +02:00
//
#if EXTRUDERS == 1
2016-08-19 05:13:47 +02:00
MENU_ITEM_EDIT(int3, MSG_FLOW, &flow_percentage[0], 10, 999);
2016-06-11 23:12:00 +02:00
#else // EXTRUDERS > 1
2016-08-19 05:13:47 +02:00
MENU_ITEM_EDIT(int3, MSG_FLOW, &flow_percentage[active_extruder], 10, 999);
MENU_ITEM_EDIT(int3, MSG_FLOW MSG_N1, &flow_percentage[0], 10, 999);
MENU_ITEM_EDIT(int3, MSG_FLOW MSG_N2, &flow_percentage[1], 10, 999);
2016-06-11 23:12:00 +02:00
#if EXTRUDERS > 2
2016-08-19 05:13:47 +02:00
MENU_ITEM_EDIT(int3, MSG_FLOW MSG_N3, &flow_percentage[2], 10, 999);
2016-06-11 23:12:00 +02:00
#if EXTRUDERS > 3
2016-08-19 05:13:47 +02:00
MENU_ITEM_EDIT(int3, MSG_FLOW MSG_N4, &flow_percentage[3], 10, 999);
#if EXTRUDERS > 4
MENU_ITEM_EDIT(int3, MSG_FLOW MSG_N5, &flow_percentage[4], 10, 999);
#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
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
#if HAS_BED_PROBE && DISABLED(BABYSTEP_ZPROBE_OFFSET)
static void lcd_refresh_zprobe_zoffset() { refresh_zprobe_zoffset(); }
#endif
#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
line_to_z(LOGICAL_Z_POSITION(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
inline void _manual_probe_goto_xy(float x, float y) {
#if MANUAL_PROBE_HEIGHT > 0
line_to_z(LOGICAL_Z_POSITION(Z_MIN_POS) + MANUAL_PROBE_HEIGHT);
#endif
current_position[X_AXIS] = LOGICAL_X_POSITION(x);
current_position[Y_AXIS] = LOGICAL_Y_POSITION(y);
planner.buffer_line_kinematic(current_position, MMM_TO_MMS(XY_PROBE_SPEED), active_extruder);
#if MANUAL_PROBE_HEIGHT > 0
line_to_z(LOGICAL_Z_POSITION(Z_MIN_POS));
#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.set_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(
LOGICAL_X_POSITION(mbl.index_to_xpos[px]),
LOGICAL_Y_POSITION(mbl.index_to_ypos[py])
);
// 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
static bool _level_state;
void _lcd_toggle_bed_leveling() { set_bed_leveling_enabled(_level_state); }
#if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
void _lcd_set_z_fade_height() { set_z_fade_height(planner.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)
* Level Bed
* 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)
* 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"));
else if (leveling_is_valid()) {
_level_state = leveling_is_active();
MENU_ITEM_EDIT_CALLBACK(bool, MSG_BED_LEVELING, &_level_state, _lcd_toggle_bed_leveling);
}
#if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
set_z_fade_height(planner.z_fade_height);
MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(float62, MSG_Z_FADE_HEIGHT, &planner.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
MENU_ITEM_EDIT_CALLBACK(float32, MSG_ZPROBE_ZOFFSET, &zprobe_zoffset, Z_PROBE_OFFSET_RANGE_MIN, Z_PROBE_OFFSET_RANGE_MAX, lcd_refresh_zprobe_zoffset);
#endif
2017-05-29 19:19:41 +02:00
MENU_ITEM(submenu, MSG_LEVEL_BED, _lcd_level_bed_continue);
#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-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_bed_temp = 50,
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-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];
const int ind = ubl_height_amount < 0 ? 6 : 7;
strcpy_P(UBL_LCD_GCODE, PSTR("G29 P6-"));
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);
MENU_ITEM_EDIT(int3, MSG_UBL_MESH_HEIGHT_AMOUNT, &ubl_height_amount, -9, 9);
MENU_ITEM(function, MSG_UBL_MESH_HEIGHT_ADJUST, _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);
MENU_ITEM_EDIT(int3, MSG_UBL_FILLIN_AMOUNT, &ubl_fillin_amount, 0, 9);
MENU_ITEM(function, MSG_UBL_FILLIN_MESH, _lcd_ubl_fillin_amount_cmd);
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[8];
sprintf_P(UBL_LCD_GCODE, PSTR("G29 L%i"), ubl_storage_slot);
enqueue_and_echo_command(UBL_LCD_GCODE);
}
2017-05-25 22:13:57 +02:00
/**
* UBL Save Mesh Command
*/
void _lcd_ubl_save_mesh_cmd() {
char UBL_LCD_GCODE[8];
sprintf_P(UBL_LCD_GCODE, PSTR("G29 S%i"), ubl_storage_slot);
enqueue_and_echo_command(UBL_LCD_GCODE);
}
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() {
START_MENU();
MENU_BACK(MSG_UBL_LEVEL_BED);
MENU_ITEM_EDIT(int3, MSG_UBL_STORAGE_SLOT, &ubl_storage_slot, 0, 9);
MENU_ITEM(function, MSG_UBL_LOAD_MESH, _lcd_ubl_load_mesh_cmd);
MENU_ITEM(function, MSG_UBL_SAVE_MESH, _lcd_ubl_save_mesh_cmd);
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() {
if (lcdDrawUpdate) lcd_implementation_drawedit(PSTR(MSG_LEVEL_BED_HOMING), NULL);
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];
ubl_lcd_map_control = true; // Used for returning to the map screen
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);
}
2017-06-15 22:10:45 +02:00
#if ENABLED(DOGLCD)
/**
* UBL LCD "radar" map data
*/
2017-06-15 22:10:45 +02:00
#define MAP_UPPER_LEFT_CORNER_X 35 // These probably should be moved to the .h file But for now,
#define MAP_UPPER_LEFT_CORNER_Y 8 // it is easier to play with things having them here
#define MAP_MAX_PIXELS_X 53
#define MAP_MAX_PIXELS_Y 49
void _lcd_ubl_plot_drawing_prep() {
2017-06-15 22:10:45 +02:00
uint8_t i, j, x_offset, y_offset, x_map_pixels, y_map_pixels,
pixels_per_X_mesh_pnt, pixels_per_Y_mesh_pnt, inverted_y;
/*********************************************************/
/************ Scale the box pixels appropriately *********/
/*********************************************************/
2017-06-16 20:01:52 +02:00
x_map_pixels = ((MAP_MAX_PIXELS_X - 4) / (GRID_MAX_POINTS_X)) * (GRID_MAX_POINTS_X);
y_map_pixels = ((MAP_MAX_PIXELS_Y - 4) / (GRID_MAX_POINTS_Y)) * (GRID_MAX_POINTS_Y);
2017-06-16 20:01:52 +02:00
pixels_per_X_mesh_pnt = x_map_pixels / (GRID_MAX_POINTS_X);
pixels_per_Y_mesh_pnt = y_map_pixels / (GRID_MAX_POINTS_Y);
2017-06-15 22:10:45 +02:00
x_offset = MAP_UPPER_LEFT_CORNER_X + 1 + (MAP_MAX_PIXELS_X - x_map_pixels - 2) / 2;
y_offset = MAP_UPPER_LEFT_CORNER_Y + 1 + (MAP_MAX_PIXELS_Y - y_map_pixels - 2) / 2;
/*********************************************************/
/************ Clear the Mesh Map Box**********************/
/*********************************************************/
u8g.setColorIndex(1); // First draw the bigger box in White so we have a border around the mesh map box
2017-06-15 22:10:45 +02:00
u8g.drawBox(x_offset - 2, y_offset - 2, x_map_pixels + 4, y_map_pixels + 4);
u8g.setColorIndex(0); // Now actually clear the mesh map box
u8g.drawBox(x_offset, y_offset, x_map_pixels, y_map_pixels);
/*********************************************************/
/************ Display Mesh Point Locations ***************/
/*********************************************************/
u8g.setColorIndex(1);
for (i = 0; i < GRID_MAX_POINTS_X; i++) {
for (j = 0; j < GRID_MAX_POINTS_Y; j++) {
2017-06-15 22:10:45 +02:00
u8g.drawBox(x_offset + i * pixels_per_X_mesh_pnt + pixels_per_X_mesh_pnt / 2,
y_offset + j * pixels_per_Y_mesh_pnt + pixels_per_Y_mesh_pnt / 2, 1, 1);
}
}
/*********************************************************/
/************ Fill in the Specified Mesh Point ***********/
/*********************************************************/
2017-06-15 22:10:45 +02:00
inverted_y = GRID_MAX_POINTS_Y - y_plot - 1; // The origin is typically in the lower right corner. We need to
// invert the Y to get it to plot in the right location.
2017-06-15 22:10:45 +02:00
u8g.drawBox(x_offset + x_plot * pixels_per_X_mesh_pnt, y_offset + inverted_y * pixels_per_Y_mesh_pnt,
pixels_per_X_mesh_pnt, pixels_per_Y_mesh_pnt);
/*********************************************************/
/************** Put Relevent Text on Display *************/
/*********************************************************/
// Show X and Y positions at top of screen
u8g.setColorIndex(1);
u8g.setPrintPos(5, 7);
lcd_print("X:");
lcd_print(ftostr32(LOGICAL_X_POSITION(pgm_read_float(&ubl._mesh_index_to_xpos[x_plot]))));
u8g.setPrintPos(74, 7);
lcd_print("Y:");
lcd_print(ftostr32(LOGICAL_Y_POSITION(pgm_read_float(&ubl._mesh_index_to_ypos[y_plot]))));
// Print plot position
u8g.setPrintPos(5, 64);
2017-06-15 22:10:45 +02:00
lcd_print('(');
u8g.print(x_plot);
2017-06-15 22:10:45 +02:00
lcd_print(',');
u8g.print(y_plot);
2017-06-15 22:10:45 +02:00
lcd_print(')');
// Show the location value
u8g.setPrintPos(74, 64);
lcd_print("Z:");
if (!isnan(ubl.z_values[x_plot][y_plot])) {
lcd_print(ftostr43sign(ubl.z_values[x_plot][y_plot]));
}
else {
lcd_print(" -----");
}
}
#endif // DOGLCD
/**
* UBL LCD Map Movement
*/
void ubl_map_move_to_xy() {
current_position[X_AXIS] = LOGICAL_X_POSITION(pgm_read_float(&ubl._mesh_index_to_xpos[x_plot]));
current_position[Y_AXIS] = LOGICAL_Y_POSITION(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;
int32_t signed_enc_pos;
defer_return_to_status = true;
if (axis_known_position[X_AXIS] && axis_known_position[Y_AXIS] && axis_known_position[Z_AXIS]) {
if (lcd_clicked) { return _lcd_ubl_map_lcd_edit_cmd(); }
ENCODER_DIRECTION_NORMAL();
2017-06-16 20:01:52 +02:00
if (encoderPosition) {
signed_enc_pos = (int32_t)encoderPosition;
step_scaler += signed_enc_pos;
2017-06-16 20:01:52 +02:00
x_plot += step_scaler / (ENCODER_STEPS_PER_MENU_ITEM);
if (abs(step_scaler) >= ENCODER_STEPS_PER_MENU_ITEM)
step_scaler = 0;
refresh_cmd_timeout();
lcdDrawUpdate = LCDVIEW_REDRAW_NOW;
}
encoderPosition = 0;
// 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;
// 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;
// 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);
// Determine number of points to edit
#if IS_KINEMATIC
n_edit_pts = 9; //TODO: Delta accessible edit points
#else
if (x_plot < 1 || x_plot >= GRID_MAX_POINTS_X - 1)
if (y_plot < 1 || y_plot >= GRID_MAX_POINTS_Y - 1) n_edit_pts = 4; // Corners
else n_edit_pts = 6;
else if (y_plot < 1 || y_plot >= GRID_MAX_POINTS_Y - 1) n_edit_pts = 6; // Edges
else n_edit_pts = 9; // Field
#endif
if (lcdDrawUpdate) {
#if ENABLED(DOGLCD)
_lcd_ubl_plot_drawing_prep();
#else
_lcd_ubl_output_char_lcd();
#endif
ubl_map_move_to_xy(); // Move to current location
2017-06-16 20:01:52 +02:00
if (planner.movesplanned() > 1) { // if the nozzle is moving, cancel the move. There is a new location
#define ENABLE_STEPPER_DRIVER_INTERRUPT() SBI(TIMSK1, OCIE1A)
#define DISABLE_STEPPER_DRIVER_INTERRUPT() CBI(TIMSK1, OCIE1A)
DISABLE_STEPPER_DRIVER_INTERRUPT();
while (planner.blocks_queued()) planner.discard_current_block();
stepper.current_block = NULL;
planner.clear_block_buffer_runtime();
ENABLE_STEPPER_DRIVER_INTERRUPT();
set_current_from_steppers_for_axis(ALL_AXES);
sync_plan_position();
ubl_map_move_to_xy(); // Move to new location
}
}
safe_delay(10);
}
else lcd_goto_screen(_lcd_ubl_map_homing);
}
/**
* 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]))
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(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_MANUAL_MESH, PSTR("G29 I999\nG29 P2 B T0"));
2017-05-25 22:13:57 +02:00
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);
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)
if (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-05-29 19:47:35 +02:00
MENU_ITEM(submenu, MSG_BED_LEVELING, lcd_bed_leveling);
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))
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
2016-06-11 23:12:00 +02:00
END_MENU();
}
2016-12-13 07:03:54 +01:00
float move_menu_scale;
2016-06-11 23:12:00 +02:00
#if ENABLED(DELTA_CALIBRATION_MENU)
2016-12-13 07:03:54 +01:00
void lcd_move_z();
void lcd_delta_calibrate_menu();
void _lcd_calibrate_homing() {
if (lcdDrawUpdate) lcd_implementation_drawmenu_static(LCD_HEIGHT >= 4 ? 1 : 0, PSTR(MSG_LEVEL_BED_HOMING));
2017-05-25 22:13:57 +02:00
lcdDrawUpdate = LCDVIEW_CALL_REDRAW_NEXT;
2016-12-13 07:03:54 +01:00
if (axis_homed[X_AXIS] && axis_homed[Y_AXIS] && axis_homed[Z_AXIS])
lcd_goto_previous_menu();
}
void _lcd_delta_calibrate_home() {
2017-05-21 02:23:39 +02:00
#if HAS_LEVELING
reset_bed_level(); // After calibration bed-level data is no longer valid
#endif
2016-12-13 07:03:54 +01:00
enqueue_and_echo_commands_P(PSTR("G28"));
lcd_goto_screen(_lcd_calibrate_homing);
}
// Move directly to the tower position with uninterpolated moves
// If we used interpolated moves it would cause this to become re-entrant
void _goto_tower_pos(const float &a) {
2017-05-21 02:23:39 +02:00
#if HAS_LEVELING
reset_bed_level(); // After calibration bed-level data is no longer valid
#endif
line_to_z(max(Z_HOMING_HEIGHT, Z_CLEARANCE_BETWEEN_PROBES) + (DELTA_PRINTABLE_RADIUS) / 5);
2016-12-13 07:03:54 +01:00
current_position[X_AXIS] = a < 0 ? LOGICAL_X_POSITION(X_HOME_POS) : cos(RADIANS(a)) * delta_calibration_radius;
current_position[Y_AXIS] = a < 0 ? LOGICAL_Y_POSITION(Y_HOME_POS) : sin(RADIANS(a)) * delta_calibration_radius;
line_to_current_z();
2016-12-13 07:03:54 +01:00
line_to_z(4.0);
2016-12-13 07:03:54 +01:00
lcd_synchronize();
move_menu_scale = 0.1;
lcd_goto_screen(lcd_move_z);
}
void _goto_tower_x() { _goto_tower_pos(210); }
void _goto_tower_y() { _goto_tower_pos(330); }
void _goto_tower_z() { _goto_tower_pos(90); }
void _goto_center() { _goto_tower_pos(-1); }
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"));
#endif
2016-12-13 07:03:54 +01:00
MENU_ITEM(submenu, MSG_AUTO_HOME, _lcd_delta_calibrate_home);
if (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);
}
2016-06-11 23:12:00 +02:00
END_MENU();
}
2016-06-11 23:12:00 +02:00
#endif // DELTA_CALIBRATION_MENU
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() {
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()) {
planner.buffer_line_kinematic(current_position, MMM_TO_MMS(manual_feedrate_mm_m[manual_move_axis]), manual_move_e_index);
2016-06-11 23:12:00 +02:00
manual_move_axis = (int8_t)NO_AXIS;
}
}
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 E_MANUAL > 1
if (axis == E_AXIS) 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();
if (encoderPosition) {
refresh_cmd_timeout();
float min = current_position[axis] - 1000,
max = current_position[axis] + 1000;
#if HAS_SOFTWARE_ENDSTOPS
// Limit to software endstops, if enabled
if (soft_endstops_enabled) {
#if ENABLED(MIN_SOFTWARE_ENDSTOPS)
min = soft_endstop_min[axis];
#endif
#if ENABLED(MAX_SOFTWARE_ENDSTOPS)
max = soft_endstop_max[axis];
#endif
}
#endif
// Get the new position
2016-06-11 23:12:00 +02:00
current_position[axis] += float((int32_t)encoderPosition) * move_menu_scale;
// Delta limits XY based on the current offset from center
// This assumes the center is 0,0
#if ENABLED(DELTA)
if (axis != Z_AXIS) {
max = SQRT(sq((float)(DELTA_PRINTABLE_RADIUS)) - sq(current_position[Y_AXIS - axis]));
min = -max;
}
#endif
// 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);
2016-06-11 23:12:00 +02:00
manual_move_to_current(axis);
encoderPosition = 0;
2017-05-25 22:13:57 +02:00
lcdDrawUpdate = LCDVIEW_REDRAW_NOW;
2016-06-11 23:12:00 +02:00
}
if (lcdDrawUpdate) lcd_implementation_drawedit(name, ftostr41sign(current_position[axis]));
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) {
current_position[E_AXIS] += float((int32_t)encoderPosition) * move_menu_scale;
encoderPosition = 0;
manual_move_to_current(E_AXIS
#if E_MANUAL > 1
, eindex
#endif
);
2017-05-25 22:13:57 +02:00
lcdDrawUpdate = LCDVIEW_REDRAW_NOW;
2016-06-11 23:12:00 +02:00
}
if (lcdDrawUpdate) {
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
2016-06-11 23:12:00 +02:00
lcd_implementation_drawedit(pos_label, ftostr41sign(current_position[E_AXIS]));
}
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;
void lcd_move_menu_10mm() { move_menu_scale = 10.0; lcd_goto_screen(_manual_move_func_ptr); }
void lcd_move_menu_1mm() { move_menu_scale = 1.0; lcd_goto_screen(_manual_move_func_ptr); }
void lcd_move_menu_01mm() { move_menu_scale = 0.1; lcd_goto_screen(_manual_move_func_ptr); }
void _lcd_move_distance_menu(AxisEnum axis, 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
#define _MOVE_XYZ_ALLOWED (axis_homed[X_AXIS] && axis_homed[Y_AXIS] && axis_homed[Z_AXIS])
#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);
2017-04-11 02:17:14 +02:00
lcd_synchronize();
}
#else
#define _MOVE_XY_ALLOWED true
#endif
#else
#define _MOVE_XYZ_ALLOWED true
#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)
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();
}
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 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(gcode, MSG_INIT_EEPROM, PSTR("M502\nM500")); // TODO: Add "Are You Sure?" step
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
#if FAN_COUNT > 1
#define MSG_1ST_FAN_SPEED MSG_FAN_SPEED " 1"
#else
#define MSG_1ST_FAN_SPEED MSG_FAN_SPEED
#endif
MENU_MULTIPLIER_ITEM_EDIT(int3, MSG_1ST_FAN_SPEED, &fanSpeeds[0], 0, 255);
#endif
#if HAS_FAN1
MENU_MULTIPLIER_ITEM_EDIT(int3, MSG_FAN_SPEED " 2", &fanSpeeds[1], 0, 255);
#endif
#if HAS_FAN2
MENU_MULTIPLIER_ITEM_EDIT(int3, MSG_FAN_SPEED " 3", &fanSpeeds[2], 0, 255);
#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
MENU_ITEM_EDIT_CALLBACK(float32, MSG_ZPROBE_ZOFFSET, &zprobe_zoffset, Z_PROBE_OFFSET_RANGE_MIN, Z_PROBE_OFFSET_RANGE_MAX, lcd_refresh_zprobe_zoffset);
#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
2016-06-11 23:12:00 +02:00
MENU_ITEM_EDIT_CALLBACK(bool, MSG_VOLUMETRIC_ENABLED, &volumetric_enabled, calculate_volumetric_multipliers);
if (volumetric_enabled) {
#if EXTRUDERS == 1
MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(float43, MSG_FILAMENT_DIAM, &filament_size[0], 1.5, 3.25, calculate_volumetric_multipliers);
#else // EXTRUDERS > 1
2016-06-11 23:12:00 +02:00
MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(float43, MSG_FILAMENT_DIAM MSG_DIAM_E1, &filament_size[0], 1.5, 3.25, calculate_volumetric_multipliers);
MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(float43, MSG_FILAMENT_DIAM MSG_DIAM_E2, &filament_size[1], 1.5, 3.25, calculate_volumetric_multipliers);
#if EXTRUDERS > 2
MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(float43, MSG_FILAMENT_DIAM MSG_DIAM_E3, &filament_size[2], 1.5, 3.25, calculate_volumetric_multipliers);
#if EXTRUDERS > 3
MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(float43, MSG_FILAMENT_DIAM MSG_DIAM_E4, &filament_size[3], 1.5, 3.25, calculate_volumetric_multipliers);
#if EXTRUDERS > 4
MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(float43, MSG_FILAMENT_DIAM MSG_DIAM_E5, &filament_size[4], 1.5, 3.25, 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
MENU_ITEM_EDIT(float52, MSG_CONTROL_RETRACT_SWAP, &retract_length_swap, 0, 100);
#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
MENU_ITEM_EDIT(float52, MSG_CONTROL_RETRACT_RECOVER_SWAP, &retract_recover_length_swap, -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);
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
*
*/
void lcd_sdcard_menu() {
ENCODER_DIRECTION_MENUS();
if (!lcdDrawUpdate && !lcd_clicked) return; // nothing to do (so don't thrash the SD card)
2017-04-17 04:32:52 +02:00
const uint16_t fileCnt = card.getnrfilenames();
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
/**
*
* Handlers for RepRap World Keypad input
*
*/
#if ENABLED(REPRAPWORLD_KEYPAD)
void _reprapworld_keypad_move(AxisEnum axis, 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) {
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() {
lcd_implementation_init(
#if ENABLED(LCD_PROGRESS_BAR)
true
#endif
);
#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
#if ENABLED(REPRAPWORLD_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-03-18 16:15:54 +01:00
#if ENABLED(AUTO_BED_LEVELING_UBL)
const bool UBL_CONDITION = !ubl.has_control_of_lcd_panel;
2017-03-18 16:15:54 +01:00
#else
constexpr bool UBL_CONDITION = true;
#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)
currentScreen == lcd_status_screen
#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
#if ENABLED(REPRAPWORLD_KEYPAD)
handle_reprapworld_keypad();
#endif
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;
if (lastEncoderMovementMillis != 0) {
// 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.
float encoderStepRate = (float)(encoderMovementSteps) / ((float)(ms - lastEncoderMovementMillis)) * 1000.0;
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.
static int8_t lcd_status_update_delay = 1; // first update one loop delayed
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
// then we want to use 1/2 of the time only.
uint16_t bbr2 = planner.block_buffer_runtime() >> 1;
#if ENABLED(DOGLCD)
if ((lcdDrawUpdate || drawing_screen) && (!bbr2 || (bbr2 > max_display_update_time)))
#else
if (lcdDrawUpdate && (!bbr2 || (bbr2 > max_display_update_time)))
#endif
{
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)
if (!drawing_screen)
#endif
{
switch (lcdDrawUpdate) {
case LCDVIEW_CALL_NO_REDRAW:
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
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
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
case LCDVIEW_NONE:
break;
} // switch
}
#if ENABLED(ULTIPANEL)
#define CURRENTSCREEN() (*currentScreen)(), lcd_clicked = false
#else
#define CURRENTSCREEN() lcd_status_screen()
#endif
#if ENABLED(DOGLCD) // Changes due to different driver architecture of the DOGM display
if (!drawing_screen) {
u8g.firstPage();
drawing_screen = 1;
}
lcd_setFont(FONT_MENU);
u8g.setColorIndex(1);
CURRENTSCREEN();
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
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
#if ENABLED(DOGLCD)
if (!drawing_screen)
#endif
{
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)
}
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
#if ENABLED(REPRAPWORLD_KEYPAD)
GET_BUTTON_STATES(buttons_reprapworld_keypad);
#endif
#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 (ubl.has_control_of_lcd_panel) {
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
2017-03-18 16:15:54 +01:00
#if ENABLED(AUTO_BED_LEVELING_UBL)
2017-03-20 07:42:41 +01:00
2017-03-18 16:15:54 +01:00
void chirp_at_user() {
#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
}
2017-03-20 07:42:41 +01:00
bool ubl_lcd_clicked() { return LCD_CLICKED; }
2017-03-18 16:15:54 +01:00
#endif
#endif // ULTIPANEL
#endif // ULTRA_LCD