2011-12-12 18:34:37 +00:00
# include "ultralcd.h"
2015-07-31 05:26:53 +00:00
# if ENABLED(ULTRA_LCD)
2011-12-22 13:55:45 +00:00
# include "Marlin.h"
2012-05-03 12:22:43 +00:00
# include "language.h"
2012-12-12 10:47:03 +00:00
# include "cardreader.h"
2012-05-03 12:22:43 +00:00
# include "temperature.h"
2013-01-31 15:43:03 +00:00
# include "stepper.h"
2015-04-26 04:04:54 +00:00
# include "configuration_store.h"
2012-11-06 11:06:41 +00:00
2015-05-13 01:46:16 +00:00
int8_t encoderDiff ; // updated from interrupt context and added to encoderPosition every LCD update
2013-07-14 13:35:54 +00:00
2015-02-20 02:42:57 +00:00
bool encoderRateMultiplierEnabled ;
int32_t lastEncoderMovementMillis ;
2012-11-06 11:06:41 +00:00
int plaPreheatHotendTemp ;
int plaPreheatHPBTemp ;
int plaPreheatFanSpeed ;
int absPreheatHotendTemp ;
int absPreheatHPBTemp ;
int absPreheatFanSpeed ;
2013-07-30 12:33:30 +00:00
2015-07-31 05:26:53 +00:00
# if ENABLED(FILAMENT_LCD_DISPLAY)
2015-04-13 01:07:08 +00:00
millis_t previous_lcd_status_ms = 0 ;
2014-11-11 03:43:58 +00:00
# endif
2015-05-13 01:46:16 +00:00
// Function pointer to menu functions.
2012-12-12 10:47:03 +00:00
typedef void ( * menuFunc_t ) ( ) ;
2011-12-12 18:34:37 +00:00
2012-12-12 10:47:03 +00:00
uint8_t lcd_status_message_level ;
2015-04-07 00:33:34 +00:00
char lcd_status_message [ 3 * LCD_WIDTH + 1 ] = WELCOME_MSG ; // worst case is kana with up to 3*LCD_WIDTH+1
2011-12-12 18:34:37 +00:00
2015-07-31 05:26:53 +00:00
# if ENABLED(DOGLCD)
2015-03-28 03:29:05 +00:00
# include "dogm_lcd_implementation.h"
2013-03-19 19:59:21 +00:00
# else
2015-03-28 03:29:05 +00:00
# include "ultralcd_implementation_hitachi_HD44780.h"
2013-03-19 19:59:21 +00:00
# endif
2011-12-12 18:34:37 +00:00
2015-03-28 03:29:05 +00:00
// The main status screen
2012-12-12 10:47:03 +00:00
static void lcd_status_screen ( ) ;
2015-03-28 03:29:05 +00:00
2015-07-31 05:26:53 +00:00
# if ENABLED(ULTIPANEL)
2015-03-28 03:29:05 +00:00
2015-03-30 23:50:05 +00:00
# if HAS_POWER_SWITCH
extern bool powersupply ;
# endif
2015-07-22 22:14:40 +00:00
const float manual_feedrate [ ] = MANUAL_FEEDRATE ;
2015-03-28 03:29:05 +00:00
static void lcd_main_menu ( ) ;
static void lcd_tune_menu ( ) ;
static void lcd_prepare_menu ( ) ;
static void lcd_move_menu ( ) ;
static void lcd_control_menu ( ) ;
static void lcd_control_temperature_menu ( ) ;
static void lcd_control_temperature_preheat_pla_settings_menu ( ) ;
static void lcd_control_temperature_preheat_abs_settings_menu ( ) ;
static void lcd_control_motion_menu ( ) ;
static void lcd_control_volumetric_menu ( ) ;
2015-07-31 05:26:53 +00:00
# if ENABLED(HAS_LCD_CONTRAST)
2015-03-28 03:29:05 +00:00
static void lcd_set_contrast ( ) ;
2013-12-08 20:34:56 +00:00
# endif
2015-07-31 05:26:53 +00:00
# if ENABLED(FWRETRACT)
2015-03-28 03:29:05 +00:00
static void lcd_control_retract_menu ( ) ;
2013-09-23 21:25:11 +00:00
# endif
2015-03-28 03:29:05 +00:00
static void lcd_sdcard_menu ( ) ;
2015-07-31 05:26:53 +00:00
# if ENABLED(DELTA_CALIBRATION_MENU)
2015-03-28 03:29:05 +00:00
static void lcd_delta_calibrate_menu ( ) ;
2013-12-08 20:34:56 +00:00
# endif
2015-03-28 03:29:05 +00:00
2015-07-31 05:26:53 +00:00
# if ENABLED(MANUAL_BED_LEVELING)
2015-03-28 03:29:05 +00:00
# include "mesh_bed_leveling.h"
static void _lcd_level_bed ( ) ;
static void _lcd_level_bed_homing ( ) ;
static void lcd_level_bed ( ) ;
2013-09-23 21:25:11 +00:00
# endif
2012-12-12 10:47:03 +00:00
2015-03-28 03:29:05 +00:00
/* Different types of actions that can be used in menu items. */
static void menu_action_back ( menuFunc_t data ) ;
static void menu_action_submenu ( menuFunc_t data ) ;
static void menu_action_gcode ( const char * pgcode ) ;
static void menu_action_function ( menuFunc_t data ) ;
static void menu_action_sdfile ( const char * filename , char * longFilename ) ;
static void menu_action_sddirectory ( const char * filename , char * longFilename ) ;
static void menu_action_setting_edit_bool ( const char * pstr , bool * ptr ) ;
static void menu_action_setting_edit_int3 ( const char * pstr , int * ptr , int minValue , int maxValue ) ;
static void menu_action_setting_edit_float3 ( const char * pstr , float * ptr , float minValue , float maxValue ) ;
static void menu_action_setting_edit_float32 ( const char * pstr , float * ptr , float minValue , float maxValue ) ;
static void menu_action_setting_edit_float43 ( const char * pstr , float * ptr , float minValue , float maxValue ) ;
static void menu_action_setting_edit_float5 ( const char * pstr , float * ptr , float minValue , float maxValue ) ;
static void menu_action_setting_edit_float51 ( const char * pstr , float * ptr , float minValue , float maxValue ) ;
static void menu_action_setting_edit_float52 ( const char * pstr , float * ptr , float minValue , float maxValue ) ;
static void menu_action_setting_edit_long5 ( const char * pstr , unsigned long * ptr , unsigned long minValue , unsigned long maxValue ) ;
static void menu_action_setting_edit_callback_bool ( const char * pstr , bool * ptr , menuFunc_t callbackFunc ) ;
static void menu_action_setting_edit_callback_int3 ( const char * pstr , int * ptr , int minValue , int maxValue , menuFunc_t callbackFunc ) ;
static void menu_action_setting_edit_callback_float3 ( const char * pstr , float * ptr , float minValue , float maxValue , menuFunc_t callbackFunc ) ;
static void menu_action_setting_edit_callback_float32 ( const char * pstr , float * ptr , float minValue , float maxValue , menuFunc_t callbackFunc ) ;
static void menu_action_setting_edit_callback_float43 ( const char * pstr , float * ptr , float minValue , float maxValue , menuFunc_t callbackFunc ) ;
static void menu_action_setting_edit_callback_float5 ( const char * pstr , float * ptr , float minValue , float maxValue , menuFunc_t callbackFunc ) ;
static void menu_action_setting_edit_callback_float51 ( const char * pstr , float * ptr , float minValue , float maxValue , menuFunc_t callbackFunc ) ;
static void menu_action_setting_edit_callback_float52 ( const char * pstr , float * ptr , float minValue , float maxValue , menuFunc_t callbackFunc ) ;
static void menu_action_setting_edit_callback_long5 ( const char * pstr , unsigned long * ptr , unsigned long minValue , unsigned long maxValue , menuFunc_t callbackFunc ) ;
# define ENCODER_FEEDRATE_DEADZONE 10
2015-07-31 05:26:53 +00:00
# if DISABLED(LCD_I2C_VIKI)
2015-03-28 03:29:05 +00:00
# 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
# else
# ifndef ENCODER_STEPS_PER_MENU_ITEM
# define ENCODER_STEPS_PER_MENU_ITEM 2 // VIKI LCD rotary encoder uses a different number of steps per rotation
# endif
# ifndef ENCODER_PULSES_PER_STEP
# define ENCODER_PULSES_PER_STEP 1
# endif
# endif
2012-12-12 10:47:03 +00:00
2015-03-16 05:02:33 +00:00
2015-03-28 03:29:05 +00:00
/* Helper macros for menus */
2015-03-16 05:02:33 +00:00
/**
2015-03-28 03:29:05 +00:00
* START_MENU generates the init code for a menu function
2015-03-16 05:02:33 +00:00
*/
2015-03-28 03:29:05 +00:00
# define START_MENU() do { \
encoderRateMultiplierEnabled = false ; \
if ( encoderPosition > 0x8000 ) encoderPosition = 0 ; \
uint8_t encoderLine = encoderPosition / ENCODER_STEPS_PER_MENU_ITEM ; \
if ( encoderLine < currentMenuViewOffset ) currentMenuViewOffset = encoderLine ; \
uint8_t _lineNr = currentMenuViewOffset , _menuItemNr ; \
bool wasClicked = LCD_CLICKED , itemSelected ; \
for ( uint8_t _drawLineNr = 0 ; _drawLineNr < LCD_HEIGHT ; _drawLineNr + + , _lineNr + + ) { \
_menuItemNr = 0 ;
/**
* 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 , lcd_status_screen )
* lcd_implementation_drawmenu_back ( sel , row , PSTR ( MSG_WATCH ) , lcd_status_screen )
* menu_action_back ( lcd_status_screen )
*
* 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 )
*
2015-04-14 00:17:36 +00:00
* MENU_ITEM_EDIT ( int3 , MSG_SPEED , & feedrate_multiplier , 10 , 999 )
* MENU_ITEM ( setting_edit_int3 , MSG_SPEED , PSTR ( MSG_SPEED ) , & feedrate_multiplier , 10 , 999 )
* lcd_implementation_drawmenu_setting_edit_int3 ( sel , row , PSTR ( MSG_SPEED ) , PSTR ( MSG_SPEED ) , & feedrate_multiplier , 10 , 999 )
* menu_action_setting_edit_int3 ( PSTR ( MSG_SPEED ) , & feedrate_multiplier , 10 , 999 )
2015-03-28 03:29:05 +00:00
*
*/
# define MENU_ITEM(type, label, args...) do { \
2015-02-20 02:42:57 +00:00
if ( _menuItemNr = = _lineNr ) { \
2015-03-16 05:02:33 +00:00
itemSelected = encoderLine = = _menuItemNr ; \
if ( lcdDrawUpdate ) \
lcd_implementation_drawmenu_ # # type ( itemSelected , _drawLineNr , PSTR ( label ) , # # args ) ; \
if ( wasClicked & & itemSelected ) { \
2015-03-31 08:41:24 +00:00
lcd_quick_feedback ( ) ; \
2015-03-16 05:02:33 +00:00
menu_action_ # # type ( args ) ; \
2015-02-20 10:17:16 +00:00
return ; \
} \
} \
_menuItemNr + + ; \
2015-02-22 02:24:16 +00:00
} while ( 0 )
2015-03-28 03:29:05 +00:00
2015-07-31 05:26:53 +00:00
# if ENABLED(ENCODER_RATE_MULTIPLIER)
2015-04-28 02:11:25 +00:00
//#define ENCODER_RATE_MULTIPLIER_DEBUG // If defined, output the encoder steps per second value
2015-03-28 03:29:05 +00:00
/**
* MENU_MULTIPLIER_ITEM generates drawing and handling code for a multiplier menu item
*/
# define MENU_MULTIPLIER_ITEM(type, label, args...) do { \
if ( _menuItemNr = = _lineNr ) { \
itemSelected = encoderLine = = _menuItemNr ; \
if ( lcdDrawUpdate ) \
lcd_implementation_drawmenu_ # # type ( itemSelected , _drawLineNr , PSTR ( label ) , # # args ) ; \
if ( wasClicked & & itemSelected ) { \
2015-03-31 16:29:16 +00:00
lcd_quick_feedback ( ) ; \
2015-03-28 03:29:05 +00:00
encoderRateMultiplierEnabled = true ; \
lastEncoderMovementMillis = 0 ; \
menu_action_ # # type ( args ) ; \
return ; \
} \
} \
_menuItemNr + + ; \
} while ( 0 )
# endif //ENCODER_RATE_MULTIPLIER
# define MENU_ITEM_DUMMY() do { _menuItemNr++; } while(0)
# define MENU_ITEM_EDIT(type, label, args...) MENU_ITEM(setting_edit_ ## type, label, PSTR(label), ## args)
# define MENU_ITEM_EDIT_CALLBACK(type, label, args...) MENU_ITEM(setting_edit_callback_ ## type, label, PSTR(label), ## args)
2015-07-31 05:26:53 +00:00
# if ENABLED(ENCODER_RATE_MULTIPLIER)
2015-03-28 03:29:05 +00:00
# define MENU_MULTIPLIER_ITEM_EDIT(type, label, args...) MENU_MULTIPLIER_ITEM(setting_edit_ ## type, label, PSTR(label), ## args)
# define MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(type, label, args...) MENU_MULTIPLIER_ITEM(setting_edit_callback_ ## type, label, PSTR(label), ## args)
# else //!ENCODER_RATE_MULTIPLIER
# define MENU_MULTIPLIER_ITEM_EDIT(type, label, args...) MENU_ITEM(setting_edit_ ## type, label, PSTR(label), ## args)
# define MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(type, label, args...) MENU_ITEM(setting_edit_callback_ ## type, label, PSTR(label), ## args)
# endif //!ENCODER_RATE_MULTIPLIER
# define END_MENU() \
if ( encoderLine > = _menuItemNr ) { encoderPosition = _menuItemNr * ENCODER_STEPS_PER_MENU_ITEM - 1 ; encoderLine = encoderPosition / ENCODER_STEPS_PER_MENU_ITEM ; } \
if ( encoderLine > = currentMenuViewOffset + LCD_HEIGHT ) { currentMenuViewOffset = encoderLine - LCD_HEIGHT + 1 ; lcdDrawUpdate = 1 ; _lineNr = currentMenuViewOffset - 1 ; _drawLineNr = - 1 ; } \
} } while ( 0 )
/** Used variables to keep track of the menu */
2015-05-05 09:03:20 +00:00
volatile uint8_t buttons ; //the last checked buttons in a bit array.
2015-07-31 05:26:53 +00:00
# if ENABLED(REPRAPWORLD_KEYPAD)
2015-05-05 09:03:20 +00:00
volatile uint8_t buttons_reprapworld_keypad ; // to store the keypad shift register values
2015-03-28 03:29:05 +00:00
# endif
2015-05-05 09:03:20 +00:00
2015-07-31 05:26:53 +00:00
# if ENABLED(LCD_HAS_SLOW_BUTTONS)
2015-03-28 03:29:05 +00:00
volatile uint8_t slow_buttons ; // Bits of the pressed buttons.
# endif
uint8_t currentMenuViewOffset ; /* scroll offset in the current menu */
2015-04-13 01:07:08 +00:00
millis_t next_button_update_ms ;
2015-03-28 03:29:05 +00:00
uint8_t lastEncoderBits ;
uint32_t encoderPosition ;
2015-07-31 23:40:50 +00:00
# if PIN_EXISTS(SD_DETECT)
2015-03-28 03:29:05 +00:00
bool lcd_oldcardstatus ;
# endif
# endif // ULTIPANEL
2012-12-12 10:47:03 +00:00
menuFunc_t currentMenu = lcd_status_screen ; /* function pointer to the currently active menu */
2015-04-13 01:07:08 +00:00
millis_t next_lcd_update_ms ;
2012-12-12 10:47:03 +00:00
uint8_t lcd_status_update_delay ;
2014-11-25 00:56:37 +00:00
bool ignore_click = false ;
2014-11-25 01:12:08 +00:00
bool wait_for_unclick ;
2014-02-17 13:04:44 +00:00
uint8_t lcdDrawUpdate = 2 ; /* Set to none-zero when the LCD needs to draw, decreased after every draw. Set to 2 in LCD routines so the LCD gets at least 1 full redraw (first redraw is partial) */
2012-12-12 10:47:03 +00:00
//prevMenu and prevEncoderPosition are used to store the previous menu location when editing settings.
menuFunc_t prevMenu = NULL ;
uint16_t prevEncoderPosition ;
//Variables used when editing values.
const char * editLabel ;
void * editValue ;
int32_t minEditValue , maxEditValue ;
Allow Edit menu to call fn after edit; Fix PID Ki and Kd display in menus; Actually use changed PID and Max Accel values
Add new 'callback' edit-menu types that call a function after the edit is done. Use this to display and edit Ki and Kd correctly (removing the scaling first and reapplying it after). Also use it to reset maximum stepwise acceleration rates, after updating mm/s^2 rates via menus. (Previously, changes did nothing to affect planner unless saved back to EEPROM, and the machine reset).
Add calls to updatePID() so that PID loop uses updated values whether set by gcode (it already did this), or by restoring defaults, or loading from EEPROM (it didn't do those last two). Similarly, update the maximum step/s^2 accel rates when the mm/s^2 values are changed - whether by menu edits, restore defaults, or EEPROM read.
Refactor the acceleration rate update logic, and the PID scaling logic, into new functions that can be called from wherever, including the callbacks.
Add menu items to allow the z jerk and e jerk to be viewed/edited in the Control->Motion menu, as per xy jerk.
Conflicts:
Marlin/language.h
2013-03-19 14:05:11 +00:00
menuFunc_t callbackFunc ;
2015-02-20 07:54:06 +00:00
// place-holders for Ki and Kd edits
Allow Edit menu to call fn after edit; Fix PID Ki and Kd display in menus; Actually use changed PID and Max Accel values
Add new 'callback' edit-menu types that call a function after the edit is done. Use this to display and edit Ki and Kd correctly (removing the scaling first and reapplying it after). Also use it to reset maximum stepwise acceleration rates, after updating mm/s^2 rates via menus. (Previously, changes did nothing to affect planner unless saved back to EEPROM, and the machine reset).
Add calls to updatePID() so that PID loop uses updated values whether set by gcode (it already did this), or by restoring defaults, or loading from EEPROM (it didn't do those last two). Similarly, update the maximum step/s^2 accel rates when the mm/s^2 values are changed - whether by menu edits, restore defaults, or EEPROM read.
Refactor the acceleration rate update logic, and the PID scaling logic, into new functions that can be called from wherever, including the callbacks.
Add menu items to allow the z jerk and e jerk to be viewed/edited in the Control->Motion menu, as per xy jerk.
Conflicts:
Marlin/language.h
2013-03-19 14:05:11 +00:00
float raw_Ki , raw_Kd ;
2012-12-12 10:47:03 +00:00
2015-04-28 02:11:25 +00:00
/**
* General function to go directly to a menu
*/
2015-04-11 11:45:04 +00:00
static void lcd_goto_menu ( menuFunc_t menu , const bool feedback = false , const uint32_t encoder = 0 ) {
2014-12-18 15:30:05 +00:00
if ( currentMenu ! = menu ) {
currentMenu = menu ;
2015-07-31 05:26:53 +00:00
# if ENABLED(NEWPANEL)
2015-04-09 10:26:45 +00:00
encoderPosition = encoder ;
if ( feedback ) lcd_quick_feedback ( ) ;
# endif
2014-12-28 06:26:14 +00:00
// For LCD_PROGRESS_BAR re-initialize the custom characters
2015-07-31 05:26:53 +00:00
# if ENABLED(LCD_PROGRESS_BAR)
2014-12-28 06:26:14 +00:00
lcd_set_custom_characters ( menu = = lcd_status_screen ) ;
# endif
2014-12-18 15:30:05 +00:00
}
}
2015-04-28 02:11:25 +00:00
/**
*
* " Info Screen "
*
* This is very display - dependent , so the lcd implementation draws this .
*/
2015-04-04 20:02:24 +00:00
static void lcd_status_screen ( ) {
2015-02-20 02:42:57 +00:00
encoderRateMultiplierEnabled = false ;
2015-03-31 01:00:54 +00:00
2015-07-31 05:26:53 +00:00
# if ENABLED(LCD_PROGRESS_BAR)
2015-04-13 01:07:08 +00:00
millis_t ms = millis ( ) ;
2015-08-03 19:30:37 +00:00
# if DISABLED(PROGRESS_MSG_ONCE)
2015-04-25 05:16:09 +00:00
if ( ms > progress_bar_ms + PROGRESS_BAR_MSG_TIME + PROGRESS_BAR_BAR_TIME ) {
progress_bar_ms = ms ;
2014-12-28 06:26:14 +00:00
}
# endif
# if PROGRESS_MSG_EXPIRE > 0
2015-03-31 01:00:54 +00:00
// Handle message expire
2015-04-25 04:51:10 +00:00
if ( expire_status_ms > 0 ) {
2015-09-05 00:40:12 +00:00
# if ENABLED(SDSUPPORT)
if ( card . isFileOpen ( ) ) {
2015-03-31 01:00:54 +00:00
// Expire the message when printing is active
2015-09-05 00:40:12 +00:00
if ( IS_SD_PRINTING ) {
if ( ms > = expire_status_ms ) {
lcd_status_message [ 0 ] = ' \0 ' ;
expire_status_ms = 0 ;
}
}
else {
expire_status_ms + = LCD_UPDATE_INTERVAL ;
2014-12-28 06:26:14 +00:00
}
}
else {
2015-09-05 00:40:12 +00:00
expire_status_ms = 0 ;
2014-12-28 06:26:14 +00:00
}
2015-09-05 00:40:12 +00:00
# else
2015-04-25 04:51:10 +00:00
expire_status_ms = 0 ;
2015-09-05 00:40:12 +00:00
# endif //SDSUPPORT
2014-12-28 06:26:14 +00:00
}
# endif
# endif //LCD_PROGRESS_BAR
2015-04-11 11:45:04 +00:00
lcd_implementation_status_screen ( ) ;
2015-01-10 02:16:56 +00:00
2015-07-31 05:26:53 +00:00
# if ENABLED(ULTIPANEL)
2014-11-25 00:56:37 +00:00
2014-11-25 01:12:08 +00:00
bool current_click = LCD_CLICKED ;
if ( ignore_click ) {
2015-04-11 11:45:04 +00:00
if ( wait_for_unclick ) {
2015-04-11 11:56:08 +00:00
if ( ! current_click )
2015-04-11 11:45:04 +00:00
ignore_click = wait_for_unclick = false ;
2015-04-11 11:56:08 +00:00
else
2015-04-11 11:45:04 +00:00
current_click = false ;
}
else if ( current_click ) {
lcd_quick_feedback ( ) ;
wait_for_unclick = true ;
current_click = false ;
}
2014-11-25 01:12:08 +00:00
}
2015-04-11 11:45:04 +00:00
if ( current_click ) {
lcd_goto_menu ( lcd_main_menu , true ) ;
lcd_implementation_init ( // to maybe revive the LCD if static electricity killed it.
2015-07-31 05:26:53 +00:00
# if ENABLED(LCD_PROGRESS_BAR)
2015-04-11 11:45:04 +00:00
currentMenu = = lcd_status_screen
2014-12-28 06:26:14 +00:00
# endif
2015-04-11 11:45:04 +00:00
) ;
2015-07-31 05:26:53 +00:00
# if ENABLED(FILAMENT_LCD_DISPLAY)
2015-04-13 01:07:08 +00:00
previous_lcd_status_ms = millis ( ) ; // get status message to show up for a while
2015-04-11 11:45:04 +00:00
# endif
2012-12-12 10:47:03 +00:00
}
2013-06-06 22:49:25 +00:00
2015-07-31 05:26:53 +00:00
# if ENABLED(ULTIPANEL_FEEDMULTIPLY)
2015-04-11 11:45:04 +00:00
// Dead zone at 100% feedrate
2015-04-14 00:17:36 +00:00
if ( ( feedrate_multiplier < 100 & & ( feedrate_multiplier + int ( encoderPosition ) ) > 100 ) | |
( feedrate_multiplier > 100 & & ( feedrate_multiplier + int ( encoderPosition ) ) < 100 ) ) {
2013-06-06 22:49:25 +00:00
encoderPosition = 0 ;
2015-04-14 00:17:36 +00:00
feedrate_multiplier = 100 ;
2015-04-11 11:45:04 +00:00
}
2015-04-14 00:17:36 +00:00
if ( feedrate_multiplier = = 100 ) {
2015-04-11 11:56:08 +00:00
if ( int ( encoderPosition ) > ENCODER_FEEDRATE_DEADZONE ) {
2015-04-14 00:17:36 +00:00
feedrate_multiplier + = int ( encoderPosition ) - ENCODER_FEEDRATE_DEADZONE ;
2015-04-11 11:56:08 +00:00
encoderPosition = 0 ;
}
else if ( int ( encoderPosition ) < - ENCODER_FEEDRATE_DEADZONE ) {
2015-04-14 00:17:36 +00:00
feedrate_multiplier + = int ( encoderPosition ) + ENCODER_FEEDRATE_DEADZONE ;
2015-04-11 11:56:08 +00:00
encoderPosition = 0 ;
}
2015-04-11 11:45:04 +00:00
}
2015-04-11 11:56:08 +00:00
else {
2015-04-14 00:17:36 +00:00
feedrate_multiplier + = int ( encoderPosition ) ;
2013-06-06 22:49:25 +00:00
encoderPosition = 0 ;
2015-04-11 11:45:04 +00:00
}
# endif // ULTIPANEL_FEEDMULTIPLY
2015-04-14 00:17:36 +00:00
feedrate_multiplier = constrain ( feedrate_multiplier , 10 , 999 ) ;
2013-06-06 22:49:25 +00:00
2015-04-11 11:45:04 +00:00
# endif //ULTIPANEL
2011-12-12 18:34:37 +00:00
}
2015-07-31 05:26:53 +00:00
# if ENABLED(ULTIPANEL)
2014-12-28 06:26:14 +00:00
2015-04-11 11:45:04 +00:00
static void lcd_return_to_status ( ) { lcd_goto_menu ( lcd_status_screen ) ; }
2014-12-28 06:26:14 +00:00
2015-09-05 00:40:12 +00:00
# if ENABLED(SDSUPPORT)
2014-12-28 06:26:14 +00:00
2015-09-05 00:40:12 +00:00
static void lcd_sdcard_pause ( ) { card . pauseSDPrint ( ) ; }
2011-12-12 18:34:37 +00:00
2015-09-05 00:40:12 +00:00
static void lcd_sdcard_resume ( ) { card . startFileprint ( ) ; }
static void lcd_sdcard_stop ( ) {
quickStop ( ) ;
card . sdprinting = false ;
card . closefile ( ) ;
autotempShutdown ( ) ;
cancel_heatup = true ;
lcd_setstatus ( MSG_PRINT_ABORTED , true ) ;
}
# endif //SDSUPPORT
2011-12-12 18:34:37 +00:00
2015-04-28 02:11:25 +00:00
/**
*
* " Main " menu
*
*/
2015-02-22 01:38:56 +00:00
static void lcd_main_menu ( ) {
START_MENU ( ) ;
MENU_ITEM ( back , MSG_WATCH , lcd_status_screen ) ;
if ( movesplanned ( ) | | IS_SD_PRINTING ) {
MENU_ITEM ( submenu , MSG_TUNE , lcd_tune_menu ) ;
}
else {
MENU_ITEM ( submenu , MSG_PREPARE , lcd_prepare_menu ) ;
2015-07-31 05:26:53 +00:00
# if ENABLED(DELTA_CALIBRATION_MENU)
2015-02-22 01:38:56 +00:00
MENU_ITEM ( submenu , MSG_DELTA_CALIBRATE , lcd_delta_calibrate_menu ) ;
# endif
}
MENU_ITEM ( submenu , MSG_CONTROL , lcd_control_menu ) ;
2015-07-31 05:26:53 +00:00
# if ENABLED(SDSUPPORT)
2015-02-22 01:38:56 +00:00
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 ) ;
2015-07-31 23:40:50 +00:00
# if !PIN_EXISTS(SD_DETECT)
2015-02-22 01:38:56 +00:00
MENU_ITEM ( gcode , MSG_CNG_SDCARD , PSTR ( " M21 " ) ) ; // SD-card changed by user
# endif
}
2011-12-12 18:34:37 +00:00
}
2015-02-22 01:38:56 +00:00
else {
MENU_ITEM ( submenu , MSG_NO_CARD , lcd_sdcard_menu ) ;
2015-07-31 23:40:50 +00:00
# if !PIN_EXISTS(SD_DETECT)
2013-06-06 22:49:25 +00:00
MENU_ITEM ( gcode , MSG_INIT_SDCARD , PSTR ( " M21 " ) ) ; // Manually initialize the SD-card via user interface
2015-02-22 01:38:56 +00:00
# endif
2011-12-12 18:34:37 +00:00
}
2015-02-22 01:38:56 +00:00
# endif //SDSUPPORT
END_MENU ( ) ;
2011-12-12 18:34:37 +00:00
}
2015-07-31 05:26:53 +00:00
# if ENABLED(SDSUPPORT) && ENABLED(MENU_ADDAUTOSTART)
2015-02-22 01:38:56 +00:00
static void lcd_autostart_sd ( ) {
card . autostart_index = 0 ;
2012-12-12 10:47:03 +00:00
card . setroot ( ) ;
card . checkautostart ( true ) ;
2015-02-22 01:38:56 +00:00
}
2012-12-12 10:47:03 +00:00
# endif
2011-12-12 18:34:37 +00:00
2015-04-30 01:26:16 +00:00
/**
* Set the home offset based on the current_position
*/
2015-02-22 01:38:56 +00:00
void lcd_set_home_offsets ( ) {
2015-04-30 02:05:48 +00:00
// M428 Command
enqueuecommands_P ( PSTR ( " M428 " ) ) ;
2015-02-22 01:38:56 +00:00
lcd_return_to_status ( ) ;
2014-10-05 20:35:45 +00:00
}
2015-07-31 05:26:53 +00:00
# if ENABLED(BABYSTEPPING)
Add the socalled "Babystepping" feature.
It is a realtime control over the head position via the LCD menu system that works _while_ printing.
Using it, one can e.g. tune the z-position in realtime, while printing the first layer.
Also, lost steps can be manually added/removed, but thats not the prime feature.
Stuff is placed into the Tune->Babystep *
It is not possible to have realtime control via gcode sending due to the buffering, so I did not include a gcode yet. However, it could be added, but it movements will not be realtime then.
Historically, a very similar thing was implemented for the "Kaamermaker" project, while Joris was babysitting his offspring, hence the name.
say goodby to fuddling around with the z-axis.
2013-10-06 19:14:51 +00:00
2014-12-18 15:30:05 +00:00
static void _lcd_babystep ( int axis , const char * msg ) {
if ( encoderPosition ! = 0 ) {
babystepsTodo [ axis ] + = ( int ) encoderPosition ;
encoderPosition = 0 ;
lcdDrawUpdate = 1 ;
Add the socalled "Babystepping" feature.
It is a realtime control over the head position via the LCD menu system that works _while_ printing.
Using it, one can e.g. tune the z-position in realtime, while printing the first layer.
Also, lost steps can be manually added/removed, but thats not the prime feature.
Stuff is placed into the Tune->Babystep *
It is not possible to have realtime control via gcode sending due to the buffering, so I did not include a gcode yet. However, it could be added, but it movements will not be realtime then.
Historically, a very similar thing was implemented for the "Kaamermaker" project, while Joris was babysitting his offspring, hence the name.
say goodby to fuddling around with the z-axis.
2013-10-06 19:14:51 +00:00
}
2014-12-23 17:49:54 +00:00
if ( lcdDrawUpdate ) lcd_implementation_drawedit ( msg , " " ) ;
2014-12-18 15:30:05 +00:00
if ( LCD_CLICKED ) lcd_goto_menu ( lcd_tune_menu ) ;
}
2014-12-23 17:49:54 +00:00
static void lcd_babystep_x ( ) { _lcd_babystep ( X_AXIS , PSTR ( MSG_BABYSTEPPING_X ) ) ; }
static void lcd_babystep_y ( ) { _lcd_babystep ( Y_AXIS , PSTR ( MSG_BABYSTEPPING_Y ) ) ; }
static void lcd_babystep_z ( ) { _lcd_babystep ( Z_AXIS , PSTR ( MSG_BABYSTEPPING_Z ) ) ; }
Add the socalled "Babystepping" feature.
It is a realtime control over the head position via the LCD menu system that works _while_ printing.
Using it, one can e.g. tune the z-position in realtime, while printing the first layer.
Also, lost steps can be manually added/removed, but thats not the prime feature.
Stuff is placed into the Tune->Babystep *
It is not possible to have realtime control via gcode sending due to the buffering, so I did not include a gcode yet. However, it could be added, but it movements will not be realtime then.
Historically, a very similar thing was implemented for the "Kaamermaker" project, while Joris was babysitting his offspring, hence the name.
say goodby to fuddling around with the z-axis.
2013-10-06 19:14:51 +00:00
# endif //BABYSTEPPING
2015-04-28 02:11:25 +00:00
/**
*
* " Tune " submenu
*
*/
2015-02-22 01:38:56 +00:00
static void lcd_tune_menu ( ) {
START_MENU ( ) ;
2015-09-07 00:14:02 +00:00
//
// ^ Main
//
2015-02-22 01:38:56 +00:00
MENU_ITEM ( back , MSG_MAIN , lcd_main_menu ) ;
2015-09-07 00:14:02 +00:00
//
// Speed:
//
2015-04-14 00:17:36 +00:00
MENU_ITEM_EDIT ( int3 , MSG_SPEED , & feedrate_multiplier , 10 , 999 ) ;
2015-09-07 00:14:02 +00:00
//
// Nozzle:
// Nozzle 2:
// Nozzle 3:
// Nozzle 4:
//
2015-02-22 01:38:56 +00:00
# if TEMP_SENSOR_0 != 0
2015-02-20 02:42:57 +00:00
MENU_MULTIPLIER_ITEM_EDIT ( int3 , MSG_NOZZLE , & target_temperature [ 0 ] , 0 , HEATER_0_MAXTEMP - 15 ) ;
2015-02-22 01:38:56 +00:00
# endif
2015-09-07 00:14:02 +00:00
# if EXTRUDERS > 1
# if TEMP_SENSOR_1 != 0
MENU_MULTIPLIER_ITEM_EDIT ( int3 , MSG_NOZZLE MSG_N2 , & target_temperature [ 1 ] , 0 , HEATER_1_MAXTEMP - 15 ) ;
# endif
# if EXTRUDERS > 2
# if TEMP_SENSOR_2 != 0
MENU_MULTIPLIER_ITEM_EDIT ( int3 , MSG_NOZZLE MSG_N3 , & target_temperature [ 2 ] , 0 , HEATER_2_MAXTEMP - 15 ) ;
# endif
# if EXTRUDERS > 3
# if TEMP_SENSOR_3 != 0
MENU_MULTIPLIER_ITEM_EDIT ( int3 , MSG_NOZZLE MSG_N4 , & target_temperature [ 3 ] , 0 , HEATER_3_MAXTEMP - 15 ) ;
# endif
# endif //EXTRUDERS > 3
# endif //EXTRUDERS > 2
# endif //EXTRUDERS > 1
//
// Bed:
//
2015-02-22 01:38:56 +00:00
# if TEMP_SENSOR_BED != 0
2015-02-20 09:22:56 +00:00
MENU_MULTIPLIER_ITEM_EDIT ( int3 , MSG_BED , & target_temperature_bed , 0 , BED_MAXTEMP - 15 ) ;
2015-02-22 01:38:56 +00:00
# endif
2015-09-07 00:14:02 +00:00
//
// Fan Speed:
//
2015-03-16 05:02:33 +00:00
MENU_MULTIPLIER_ITEM_EDIT ( int3 , MSG_FAN_SPEED , & fanSpeed , 0 , 255 ) ;
2015-09-07 00:14:02 +00:00
//
// Flow:
//
2015-06-01 20:33:22 +00:00
MENU_ITEM_EDIT ( int3 , MSG_FLOW , & extruder_multiplier [ active_extruder ] , 10 , 999 ) ;
2015-09-07 00:14:02 +00:00
//
// Flow 0:
// Flow 1:
// Flow 2:
// Flow 3:
//
2015-06-01 20:33:22 +00:00
MENU_ITEM_EDIT ( int3 , MSG_FLOW MSG_N0 , & extruder_multiplier [ 0 ] , 10 , 999 ) ;
2015-09-07 00:14:02 +00:00
# if EXTRUDERS > 1
2015-06-01 20:33:22 +00:00
MENU_ITEM_EDIT ( int3 , MSG_FLOW MSG_N1 , & extruder_multiplier [ 1 ] , 10 , 999 ) ;
2015-09-07 00:14:02 +00:00
# if EXTRUDERS > 2
MENU_ITEM_EDIT ( int3 , MSG_FLOW MSG_N2 , & extruder_multiplier [ 2 ] , 10 , 999 ) ;
# if EXTRUDERS > 3
MENU_ITEM_EDIT ( int3 , MSG_FLOW MSG_N3 , & extruder_multiplier [ 3 ] , 10 , 999 ) ;
# endif //EXTRUDERS > 3
# endif //EXTRUDERS > 2
# endif //EXTRUDERS > 1
//
// Babystep X:
// Babystep Y:
// Babystep Z:
//
2015-07-31 05:26:53 +00:00
# if ENABLED(BABYSTEPPING)
# if ENABLED(BABYSTEP_XY)
2014-02-11 13:54:43 +00:00
MENU_ITEM ( submenu , MSG_BABYSTEP_X , lcd_babystep_x ) ;
MENU_ITEM ( submenu , MSG_BABYSTEP_Y , lcd_babystep_y ) ;
Add the socalled "Babystepping" feature.
It is a realtime control over the head position via the LCD menu system that works _while_ printing.
Using it, one can e.g. tune the z-position in realtime, while printing the first layer.
Also, lost steps can be manually added/removed, but thats not the prime feature.
Stuff is placed into the Tune->Babystep *
It is not possible to have realtime control via gcode sending due to the buffering, so I did not include a gcode yet. However, it could be added, but it movements will not be realtime then.
Historically, a very similar thing was implemented for the "Kaamermaker" project, while Joris was babysitting his offspring, hence the name.
say goodby to fuddling around with the z-axis.
2013-10-06 19:14:51 +00:00
# endif //BABYSTEP_XY
2014-02-11 13:54:43 +00:00
MENU_ITEM ( submenu , MSG_BABYSTEP_Z , lcd_babystep_z ) ;
2015-02-22 01:38:56 +00:00
# endif
2015-09-07 00:14:02 +00:00
//
// Change filament
//
2015-07-31 05:26:53 +00:00
# if ENABLED(FILAMENTCHANGEENABLE)
Added a feature to have filament change by gcode or display trigger.
[default off for now]
syntax: M600 X[pos] Y[pos] Z[relative lift] E[initial retract] L[later retract distance for removal]
if enabled, after a M600, the printer will retract by E, lift by Z, move to XY, retract even more filament.
Oh, and it will display "remove filament" and beep like crazy.
You are then supposed to insert a new filament (other color, e.g.) and click the display to continue.
After having the nozzle cleaned manually, aided by the disabled e-steppers.
After clicking, the printer will then go back the whole shebang, and continue printing with a fancy new color.
2013-01-27 12:21:34 +00:00
MENU_ITEM ( gcode , MSG_FILAMENTCHANGE , PSTR ( " M600 " ) ) ;
2015-02-22 01:38:56 +00:00
# endif
2015-09-07 00:14:02 +00:00
2015-02-22 01:38:56 +00:00
END_MENU ( ) ;
2012-12-12 10:47:03 +00:00
}
2011-12-12 18:34:37 +00:00
2015-02-22 01:38:56 +00:00
void _lcd_preheat ( int endnum , const float temph , const float tempb , const int fan ) {
if ( temph > 0 ) setTargetHotend ( temph , endnum ) ;
2015-05-21 18:36:11 +00:00
# if TEMP_SENSOR_BED != 0
setTargetBed ( tempb ) ;
# endif
2015-02-22 01:38:56 +00:00
fanSpeed = fan ;
lcd_return_to_status ( ) ;
2014-03-17 17:37:46 +00:00
}
2015-02-22 01:38:56 +00:00
void lcd_preheat_pla0 ( ) { _lcd_preheat ( 0 , plaPreheatHotendTemp , plaPreheatHPBTemp , plaPreheatFanSpeed ) ; }
void lcd_preheat_abs0 ( ) { _lcd_preheat ( 0 , absPreheatHotendTemp , absPreheatHPBTemp , absPreheatFanSpeed ) ; }
2014-03-17 17:37:46 +00:00
2015-07-19 19:07:12 +00:00
# if EXTRUDERS > 1
void lcd_preheat_pla1 ( ) { _lcd_preheat ( 1 , plaPreheatHotendTemp , plaPreheatHPBTemp , plaPreheatFanSpeed ) ; }
void lcd_preheat_abs1 ( ) { _lcd_preheat ( 1 , absPreheatHotendTemp , absPreheatHPBTemp , absPreheatFanSpeed ) ; }
# if EXTRUDERS > 2
2015-03-28 03:29:05 +00:00
void lcd_preheat_pla2 ( ) { _lcd_preheat ( 2 , plaPreheatHotendTemp , plaPreheatHPBTemp , plaPreheatFanSpeed ) ; }
void lcd_preheat_abs2 ( ) { _lcd_preheat ( 2 , absPreheatHotendTemp , absPreheatHPBTemp , absPreheatFanSpeed ) ; }
2015-07-19 19:07:12 +00:00
# if EXTRUDERS > 3
void lcd_preheat_pla3 ( ) { _lcd_preheat ( 3 , plaPreheatHotendTemp , plaPreheatHPBTemp , plaPreheatFanSpeed ) ; }
void lcd_preheat_abs3 ( ) { _lcd_preheat ( 3 , absPreheatHotendTemp , absPreheatHPBTemp , absPreheatFanSpeed ) ; }
# endif
2015-03-28 03:29:05 +00:00
# endif
2015-01-23 22:13:06 +00:00
2015-02-22 01:38:56 +00:00
void lcd_preheat_pla0123 ( ) {
2014-03-17 17:37:46 +00:00
setTargetHotend0 ( plaPreheatHotendTemp ) ;
setTargetHotend1 ( plaPreheatHotendTemp ) ;
setTargetHotend2 ( plaPreheatHotendTemp ) ;
2015-02-22 01:38:56 +00:00
_lcd_preheat ( 3 , plaPreheatHotendTemp , plaPreheatHPBTemp , plaPreheatFanSpeed ) ;
}
void lcd_preheat_abs0123 ( ) {
2014-03-17 17:37:46 +00:00
setTargetHotend0 ( absPreheatHotendTemp ) ;
setTargetHotend1 ( absPreheatHotendTemp ) ;
setTargetHotend2 ( absPreheatHotendTemp ) ;
2015-02-22 01:38:56 +00:00
_lcd_preheat ( 3 , absPreheatHotendTemp , absPreheatHPBTemp , absPreheatFanSpeed ) ;
}
2014-03-17 17:37:46 +00:00
2015-07-19 19:07:12 +00:00
# endif // EXTRUDERS > 1
2014-03-17 17:37:46 +00:00
2015-07-19 19:07:12 +00:00
# if TEMP_SENSOR_BED != 0
void lcd_preheat_pla_bedonly ( ) { _lcd_preheat ( 0 , 0 , plaPreheatHPBTemp , plaPreheatFanSpeed ) ; }
void lcd_preheat_abs_bedonly ( ) { _lcd_preheat ( 0 , 0 , absPreheatHPBTemp , absPreheatFanSpeed ) ; }
# endif
2014-03-17 17:37:46 +00:00
2015-07-19 19:07:12 +00:00
static void lcd_preheat_pla_menu ( ) {
START_MENU ( ) ;
MENU_ITEM ( back , MSG_PREPARE , lcd_prepare_menu ) ;
# if EXTRUDERS == 1
MENU_ITEM ( function , MSG_PREHEAT_PLA , lcd_preheat_pla0 ) ;
# else
MENU_ITEM ( function , MSG_PREHEAT_PLA_N MSG_H1 , lcd_preheat_pla0 ) ;
# if EXTRUDERS > 1
MENU_ITEM ( function , MSG_PREHEAT_PLA_N MSG_H2 , lcd_preheat_pla1 ) ;
# if EXTRUDERS > 2
2015-03-28 03:29:05 +00:00
MENU_ITEM ( function , MSG_PREHEAT_PLA_N MSG_H3 , lcd_preheat_pla2 ) ;
2015-07-19 19:07:12 +00:00
# if EXTRUDERS > 3
MENU_ITEM ( function , MSG_PREHEAT_PLA_N MSG_H4 , lcd_preheat_pla3 ) ;
# endif
2015-03-28 03:29:05 +00:00
# endif
2015-07-19 19:07:12 +00:00
# endif
MENU_ITEM ( function , MSG_PREHEAT_PLA_ALL , lcd_preheat_pla0123 ) ;
# endif
# if TEMP_SENSOR_BED != 0
MENU_ITEM ( function , MSG_PREHEAT_PLA_BEDONLY , lcd_preheat_pla_bedonly ) ;
# endif
END_MENU ( ) ;
}
2015-03-28 03:29:05 +00:00
2015-07-19 19:07:12 +00:00
static void lcd_preheat_abs_menu ( ) {
START_MENU ( ) ;
MENU_ITEM ( back , MSG_PREPARE , lcd_prepare_menu ) ;
# if EXTRUDERS == 1
MENU_ITEM ( function , MSG_PREHEAT_ABS , lcd_preheat_abs0 ) ;
# else
MENU_ITEM ( function , MSG_PREHEAT_ABS_N MSG_H1 , lcd_preheat_abs0 ) ;
# if EXTRUDERS > 1
MENU_ITEM ( function , MSG_PREHEAT_ABS_N MSG_H2 , lcd_preheat_abs1 ) ;
# if EXTRUDERS > 2
2015-03-28 03:29:05 +00:00
MENU_ITEM ( function , MSG_PREHEAT_ABS_N MSG_H3 , lcd_preheat_abs2 ) ;
2015-07-19 19:07:12 +00:00
# if EXTRUDERS > 3
MENU_ITEM ( function , MSG_PREHEAT_ABS_N MSG_H4 , lcd_preheat_abs3 ) ;
# endif
2015-03-28 03:29:05 +00:00
# endif
2015-07-19 19:07:12 +00:00
# endif
MENU_ITEM ( function , MSG_PREHEAT_ABS_ALL , lcd_preheat_abs0123 ) ;
2015-02-22 01:38:56 +00:00
# endif
2015-07-19 19:07:12 +00:00
# if TEMP_SENSOR_BED != 0
MENU_ITEM ( function , MSG_PREHEAT_ABS_BEDONLY , lcd_preheat_abs_bedonly ) ;
# endif
END_MENU ( ) ;
}
2014-03-17 17:37:46 +00:00
2015-02-22 01:38:56 +00:00
void lcd_cooldown ( ) {
2015-05-21 18:36:11 +00:00
disable_all_heaters ( ) ;
2015-02-22 01:38:56 +00:00
fanSpeed = 0 ;
lcd_return_to_status ( ) ;
2014-03-17 17:37:46 +00:00
}
2015-04-28 02:11:25 +00:00
/**
*
* " Prepare " submenu
*
*/
2015-02-22 01:38:56 +00:00
static void lcd_prepare_menu ( ) {
START_MENU ( ) ;
2015-04-28 02:11:25 +00:00
//
// ^ Main
//
2015-02-22 01:38:56 +00:00
MENU_ITEM ( back , MSG_MAIN , lcd_main_menu ) ;
2015-04-28 02:11:25 +00:00
//
// Auto Home
//
2015-02-22 01:38:56 +00:00
MENU_ITEM ( gcode , MSG_AUTO_HOME , PSTR ( " G28 " ) ) ;
2015-04-28 02:11:25 +00:00
//
// Set Home Offsets
//
2015-02-22 01:38:56 +00:00
MENU_ITEM ( function , MSG_SET_HOME_OFFSETS , lcd_set_home_offsets ) ;
//MENU_ITEM(gcode, MSG_SET_ORIGIN, PSTR("G92 X0 Y0 Z0"));
2015-03-30 23:39:47 +00:00
2015-04-28 02:11:25 +00:00
//
// Level Bed
//
2015-08-05 12:12:26 +00:00
# if ENABLED(AUTO_BED_LEVELING_FEATURE)
2015-04-28 02:11:25 +00:00
if ( axis_known_position [ X_AXIS ] & & axis_known_position [ Y_AXIS ] )
MENU_ITEM ( gcode , MSG_LEVEL_BED , PSTR ( " G29 " ) ) ;
2015-07-31 05:26:53 +00:00
# elif ENABLED(MANUAL_BED_LEVELING)
2015-04-28 02:11:25 +00:00
MENU_ITEM ( submenu , MSG_LEVEL_BED , lcd_level_bed ) ;
# endif
//
// Move Axis
//
MENU_ITEM ( submenu , MSG_MOVE_AXIS , lcd_move_menu ) ;
//
// Disable Steppers
//
MENU_ITEM ( gcode , MSG_DISABLE_STEPPERS , PSTR ( " M84 " ) ) ;
//
// Preheat PLA
// Preheat ABS
//
2015-02-22 01:38:56 +00:00
# if TEMP_SENSOR_0 != 0
2015-03-28 03:29:05 +00:00
# if TEMP_SENSOR_1 != 0 || TEMP_SENSOR_2 != 0 || TEMP_SENSOR_3 != 0 || TEMP_SENSOR_BED != 0
2015-02-22 01:38:56 +00:00
MENU_ITEM ( submenu , MSG_PREHEAT_PLA , lcd_preheat_pla_menu ) ;
MENU_ITEM ( submenu , MSG_PREHEAT_ABS , lcd_preheat_abs_menu ) ;
# else
MENU_ITEM ( function , MSG_PREHEAT_PLA , lcd_preheat_pla0 ) ;
MENU_ITEM ( function , MSG_PREHEAT_ABS , lcd_preheat_abs0 ) ;
# endif
# endif
2015-03-30 23:39:47 +00:00
2015-04-28 02:11:25 +00:00
//
// Cooldown
//
2015-02-22 01:38:56 +00:00
MENU_ITEM ( function , MSG_COOLDOWN , lcd_cooldown ) ;
2015-03-30 23:39:47 +00:00
2015-04-28 02:11:25 +00:00
//
// Switch power on/off
//
2015-03-30 23:39:47 +00:00
# if HAS_POWER_SWITCH
if ( powersupply )
2015-02-22 01:38:56 +00:00
MENU_ITEM ( gcode , MSG_SWITCH_PS_OFF , PSTR ( " M81 " ) ) ;
2015-03-30 23:39:47 +00:00
else
2015-02-22 01:38:56 +00:00
MENU_ITEM ( gcode , MSG_SWITCH_PS_ON , PSTR ( " M80 " ) ) ;
# endif
2015-03-30 23:39:47 +00:00
2015-04-28 02:11:25 +00:00
//
// Autostart
//
2015-07-31 05:26:53 +00:00
# if ENABLED(SDSUPPORT) && ENABLED(MENU_ADDAUTOSTART)
2015-04-28 02:11:25 +00:00
MENU_ITEM ( function , MSG_AUTOSTART , lcd_autostart_sd ) ;
2015-03-15 22:18:11 +00:00
# endif
2015-04-28 02:11:25 +00:00
2015-02-22 01:38:56 +00:00
END_MENU ( ) ;
2011-12-12 18:34:37 +00:00
}
2015-07-31 05:26:53 +00:00
# if ENABLED(DELTA_CALIBRATION_MENU)
2015-04-09 11:32:14 +00:00
static void lcd_delta_calibrate_menu ( ) {
2014-12-29 17:19:25 +00:00
START_MENU ( ) ;
MENU_ITEM ( back , MSG_MAIN , lcd_main_menu ) ;
MENU_ITEM ( gcode , MSG_AUTO_HOME , PSTR ( " G28 " ) ) ;
MENU_ITEM ( gcode , MSG_DELTA_CALIBRATE_X , PSTR ( " G0 F8000 X-77.94 Y-45 Z0 " ) ) ;
MENU_ITEM ( gcode , MSG_DELTA_CALIBRATE_Y , PSTR ( " G0 F8000 X77.94 Y-45 Z0 " ) ) ;
MENU_ITEM ( gcode , MSG_DELTA_CALIBRATE_Z , PSTR ( " G0 F8000 X0 Y90 Z0 " ) ) ;
MENU_ITEM ( gcode , MSG_DELTA_CALIBRATE_CENTER , PSTR ( " G0 F8000 X0 Y0 Z0 " ) ) ;
END_MENU ( ) ;
2015-04-09 11:32:14 +00:00
}
2014-12-29 17:19:25 +00:00
# endif // DELTA_CALIBRATION_MENU
2015-04-24 02:10:09 +00:00
inline void line_to_current ( AxisEnum axis ) {
2015-07-31 05:26:53 +00:00
# if ENABLED(DELTA)
2015-04-09 11:32:14 +00:00
calculate_delta ( current_position ) ;
2015-04-24 02:10:09 +00:00
plan_buffer_line ( delta [ X_AXIS ] , delta [ Y_AXIS ] , delta [ Z_AXIS ] , current_position [ E_AXIS ] , manual_feedrate [ axis ] / 60 , active_extruder ) ;
2015-04-09 11:32:14 +00:00
# else
2015-04-24 02:10:09 +00:00
plan_buffer_line ( current_position [ X_AXIS ] , current_position [ Y_AXIS ] , current_position [ Z_AXIS ] , current_position [ E_AXIS ] , manual_feedrate [ axis ] / 60 , active_extruder ) ;
2015-04-09 11:32:14 +00:00
# endif
}
2015-04-28 02:11:25 +00:00
/**
*
* " Prepare " > " Move Axis " submenu
*
*/
2015-04-10 03:05:10 +00:00
float move_menu_scale ;
static void lcd_move_menu_axis ( ) ;
2015-04-24 02:32:37 +00:00
static void _lcd_move ( const char * name , AxisEnum axis , int min , int max ) {
2014-12-18 15:30:05 +00:00
if ( encoderPosition ! = 0 ) {
refresh_cmd_timeout ( ) ;
current_position [ axis ] + = float ( ( int ) encoderPosition ) * move_menu_scale ;
if ( min_software_endstops & & current_position [ axis ] < min ) current_position [ axis ] = min ;
if ( max_software_endstops & & current_position [ axis ] > max ) current_position [ axis ] = max ;
encoderPosition = 0 ;
2015-04-24 02:10:09 +00:00
line_to_current ( axis ) ;
2014-12-18 15:30:05 +00:00
lcdDrawUpdate = 1 ;
}
if ( lcdDrawUpdate ) lcd_implementation_drawedit ( name , ftostr31 ( current_position [ axis ] ) ) ;
if ( LCD_CLICKED ) lcd_goto_menu ( lcd_move_menu_axis ) ;
2012-12-12 10:47:03 +00:00
}
2015-06-11 23:59:23 +00:00
static void lcd_move_x ( ) { _lcd_move ( PSTR ( MSG_MOVE_X ) , X_AXIS , X_MIN_POS , X_MAX_POS ) ; }
static void lcd_move_y ( ) { _lcd_move ( PSTR ( MSG_MOVE_Y ) , Y_AXIS , Y_MIN_POS , Y_MAX_POS ) ; }
static void lcd_move_z ( ) { _lcd_move ( PSTR ( MSG_MOVE_Z ) , Z_AXIS , Z_MIN_POS , Z_MAX_POS ) ; }
2015-08-20 16:37:00 +00:00
static void lcd_move_e (
# if EXTRUDERS > 1
uint8_t e = 0
# endif
) {
# if EXTRUDERS > 1
unsigned short original_active_extruder = active_extruder ;
active_extruder = e ;
# endif
2015-04-10 03:21:30 +00:00
if ( encoderPosition ! = 0 ) {
current_position [ E_AXIS ] + = float ( ( int ) encoderPosition ) * move_menu_scale ;
encoderPosition = 0 ;
2015-04-24 02:10:09 +00:00
line_to_current ( E_AXIS ) ;
2015-04-10 03:21:30 +00:00
lcdDrawUpdate = 1 ;
}
2015-06-11 23:59:23 +00:00
if ( lcdDrawUpdate ) lcd_implementation_drawedit ( PSTR ( MSG_MOVE_E ) , ftostr31 ( current_position [ E_AXIS ] ) ) ;
2015-04-10 03:21:30 +00:00
if ( LCD_CLICKED ) lcd_goto_menu ( lcd_move_menu_axis ) ;
2015-08-20 16:37:00 +00:00
# if EXTRUDERS > 1
active_extruder = original_active_extruder ;
# endif
2015-04-10 03:21:30 +00:00
}
2014-12-18 15:30:05 +00:00
2015-08-20 16:37:00 +00:00
# if EXTRUDERS > 1
2015-09-06 22:53:23 +00:00
static void lcd_move_e1 ( ) { lcd_move_e ( 1 ) ; }
2015-08-20 16:37:00 +00:00
# if EXTRUDERS > 2
2015-09-06 22:53:23 +00:00
static void lcd_move_e2 ( ) { lcd_move_e ( 2 ) ; }
2015-08-20 16:37:00 +00:00
# if EXTRUDERS > 3
2015-09-06 22:53:23 +00:00
static void lcd_move_e3 ( ) { lcd_move_e ( 3 ) ; }
2015-08-20 16:37:00 +00:00
# endif
# endif
# endif // EXTRUDERS > 1
2015-04-28 02:11:25 +00:00
/**
*
* " Prepare " > " Move Xmm " > " Move XYZ " submenu
*
*/
2015-04-10 02:33:16 +00:00
static void lcd_move_menu_axis ( ) {
START_MENU ( ) ;
MENU_ITEM ( back , MSG_MOVE_AXIS , lcd_move_menu ) ;
MENU_ITEM ( submenu , MSG_MOVE_X , lcd_move_x ) ;
MENU_ITEM ( submenu , MSG_MOVE_Y , lcd_move_y ) ;
if ( move_menu_scale < 10.0 ) {
MENU_ITEM ( submenu , MSG_MOVE_Z , lcd_move_z ) ;
MENU_ITEM ( submenu , MSG_MOVE_E , lcd_move_e ) ;
2015-08-20 16:37:00 +00:00
# if EXTRUDERS > 1
MENU_ITEM ( submenu , MSG_MOVE_E1 , lcd_move_e1 ) ;
# if EXTRUDERS > 2
MENU_ITEM ( submenu , MSG_MOVE_E2 , lcd_move_e2 ) ;
# if EXTRUDERS > 3
MENU_ITEM ( submenu , MSG_MOVE_E3 , lcd_move_e3 ) ;
# endif
# endif
# endif // EXTRUDERS > 1
2015-04-10 02:33:16 +00:00
}
END_MENU ( ) ;
}
2015-02-22 01:38:56 +00:00
static void lcd_move_menu_10mm ( ) {
move_menu_scale = 10.0 ;
lcd_move_menu_axis ( ) ;
2012-12-12 10:47:03 +00:00
}
2015-02-22 01:38:56 +00:00
static void lcd_move_menu_1mm ( ) {
move_menu_scale = 1.0 ;
lcd_move_menu_axis ( ) ;
2012-12-12 10:47:03 +00:00
}
2015-02-22 01:38:56 +00:00
static void lcd_move_menu_01mm ( ) {
move_menu_scale = 0.1 ;
lcd_move_menu_axis ( ) ;
2012-12-12 10:47:03 +00:00
}
2012-06-02 18:32:28 +00:00
2015-04-28 02:11:25 +00:00
/**
*
* " Prepare " > " Move Axis " submenu
*
*/
2015-02-22 01:38:56 +00:00
static void lcd_move_menu ( ) {
START_MENU ( ) ;
MENU_ITEM ( back , MSG_PREPARE , lcd_prepare_menu ) ;
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 ) ;
//TODO:X,Y,Z,E
END_MENU ( ) ;
2012-12-12 10:47:03 +00:00
}
2012-06-02 18:32:28 +00:00
2015-04-28 02:11:25 +00:00
/**
*
* " Control " submenu
*
*/
2015-02-22 01:38:56 +00:00
static void lcd_control_menu ( ) {
START_MENU ( ) ;
MENU_ITEM ( back , MSG_MAIN , lcd_main_menu ) ;
MENU_ITEM ( submenu , MSG_TEMPERATURE , lcd_control_temperature_menu ) ;
MENU_ITEM ( submenu , MSG_MOTION , lcd_control_motion_menu ) ;
MENU_ITEM ( submenu , MSG_VOLUMETRIC , lcd_control_volumetric_menu ) ;
2014-12-29 01:43:14 +00:00
2015-07-31 05:26:53 +00:00
# if ENABLED(HAS_LCD_CONTRAST)
2015-02-22 01:38:56 +00:00
//MENU_ITEM_EDIT(int3, MSG_CONTRAST, &lcd_contrast, 0, 63);
2013-07-14 08:28:26 +00:00
MENU_ITEM ( submenu , MSG_CONTRAST , lcd_set_contrast ) ;
2015-02-22 01:38:56 +00:00
# endif
2015-07-31 05:26:53 +00:00
# if ENABLED(FWRETRACT)
2012-12-12 10:47:03 +00:00
MENU_ITEM ( submenu , MSG_RETRACT , lcd_control_retract_menu ) ;
2015-02-22 01:38:56 +00:00
# endif
2015-07-31 05:26:53 +00:00
# if ENABLED(EEPROM_SETTINGS)
2012-12-12 10:47:03 +00:00
MENU_ITEM ( function , MSG_STORE_EPROM , Config_StoreSettings ) ;
MENU_ITEM ( function , MSG_LOAD_EPROM , Config_RetrieveSettings ) ;
2015-02-22 01:38:56 +00:00
# endif
MENU_ITEM ( function , MSG_RESTORE_FAILSAFE , Config_ResetDefault ) ;
END_MENU ( ) ;
2012-12-12 10:47:03 +00:00
}
2011-12-12 18:34:37 +00:00
2015-04-28 02:11:25 +00:00
/**
*
* " Temperature " submenu
*
*/
2015-07-31 05:26:53 +00:00
# if ENABLED(PIDTEMP)
2015-02-20 08:00:19 +00:00
2015-02-20 07:54:06 +00: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 ( int e ) {
PID_PARAM ( Ki , e ) = scalePID_i ( raw_Ki ) ;
updatePID ( ) ;
}
void copy_and_scalePID_d ( int e ) {
PID_PARAM ( Kd , e ) = scalePID_d ( raw_Kd ) ;
updatePID ( ) ;
}
void copy_and_scalePID_i_E1 ( ) { copy_and_scalePID_i ( 0 ) ; }
void copy_and_scalePID_d_E1 ( ) { copy_and_scalePID_d ( 0 ) ; }
2015-07-31 05:26:53 +00:00
# if ENABLED(PID_PARAMS_PER_EXTRUDER)
2015-02-20 08:00:19 +00:00
# if EXTRUDERS > 1
void copy_and_scalePID_i_E2 ( ) { copy_and_scalePID_i ( 1 ) ; }
void copy_and_scalePID_d_E2 ( ) { copy_and_scalePID_d ( 1 ) ; }
# if EXTRUDERS > 2
void copy_and_scalePID_i_E3 ( ) { copy_and_scalePID_i ( 2 ) ; }
void copy_and_scalePID_d_E3 ( ) { copy_and_scalePID_d ( 2 ) ; }
# if EXTRUDERS > 3
void copy_and_scalePID_i_E4 ( ) { copy_and_scalePID_i ( 3 ) ; }
2015-02-22 02:41:04 +00:00
void copy_and_scalePID_d_E4 ( ) { copy_and_scalePID_d ( 3 ) ; }
2015-02-20 08:00:19 +00:00
# endif //EXTRUDERS > 3
# endif //EXTRUDERS > 2
# endif //EXTRUDERS > 1
# endif //PID_PARAMS_PER_EXTRUDER
# endif //PIDTEMP
2015-02-20 07:54:06 +00:00
2015-04-28 02:11:25 +00:00
/**
*
* " Control " > " Temperature " submenu
*
*/
2015-02-22 01:38:56 +00:00
static void lcd_control_temperature_menu ( ) {
2015-01-23 22:13:06 +00:00
START_MENU ( ) ;
2015-05-13 01:46:16 +00:00
//
// ^ Control
//
2015-01-23 22:13:06 +00:00
MENU_ITEM ( back , MSG_CONTROL , lcd_control_menu ) ;
2015-05-13 01:46:16 +00:00
//
// Nozzle, Nozzle 2, Nozzle 3, Nozzle 4
//
2015-02-20 07:54:06 +00:00
# if TEMP_SENSOR_0 != 0
2015-02-22 02:13:31 +00:00
MENU_MULTIPLIER_ITEM_EDIT ( int3 , MSG_NOZZLE , & target_temperature [ 0 ] , 0 , HEATER_0_MAXTEMP - 15 ) ;
2015-02-20 07:54:06 +00:00
# endif
# if EXTRUDERS > 1
# if TEMP_SENSOR_1 != 0
2015-02-22 04:18:49 +00:00
MENU_MULTIPLIER_ITEM_EDIT ( int3 , MSG_NOZZLE MSG_N2 , & target_temperature [ 1 ] , 0 , HEATER_1_MAXTEMP - 15 ) ;
2015-02-20 07:54:06 +00:00
# endif
# if EXTRUDERS > 2
# if TEMP_SENSOR_2 != 0
2015-02-22 04:18:49 +00:00
MENU_MULTIPLIER_ITEM_EDIT ( int3 , MSG_NOZZLE MSG_N3 , & target_temperature [ 2 ] , 0 , HEATER_2_MAXTEMP - 15 ) ;
2015-02-20 07:54:06 +00:00
# endif
2015-02-22 01:38:56 +00:00
# if EXTRUDERS > 3
2015-02-20 07:54:06 +00:00
# if TEMP_SENSOR_3 != 0
2015-02-22 04:18:49 +00:00
MENU_MULTIPLIER_ITEM_EDIT ( int3 , MSG_NOZZLE MSG_N4 , & target_temperature [ 3 ] , 0 , HEATER_3_MAXTEMP - 15 ) ;
2015-02-20 07:54:06 +00:00
# endif
2015-02-22 04:18:49 +00:00
# endif // EXTRUDERS > 3
# endif // EXTRUDERS > 2
# endif // EXTRUDERS > 1
2015-05-13 01:46:16 +00:00
//
// Bed
//
2015-02-20 07:54:06 +00:00
# if TEMP_SENSOR_BED != 0
2015-02-22 02:13:31 +00:00
MENU_MULTIPLIER_ITEM_EDIT ( int3 , MSG_BED , & target_temperature_bed , 0 , BED_MAXTEMP - 15 ) ;
2015-02-20 07:54:06 +00:00
# endif
2015-05-13 01:46:16 +00:00
//
// Fan Speed
//
2015-02-20 02:42:57 +00:00
MENU_MULTIPLIER_ITEM_EDIT ( int3 , MSG_FAN_SPEED , & fanSpeed , 0 , 255 ) ;
2015-05-13 01:46:16 +00:00
//
// Autotemp, Min, Max, Fact
//
2015-07-31 05:26:53 +00:00
# if ENABLED(AUTOTEMP) && (TEMP_SENSOR_0 != 0)
2015-02-20 07:54:06 +00:00
MENU_ITEM_EDIT ( bool , MSG_AUTOTEMP , & autotemp_enabled ) ;
MENU_ITEM_EDIT ( float3 , MSG_MIN , & autotemp_min , 0 , HEATER_0_MAXTEMP - 15 ) ;
MENU_ITEM_EDIT ( float3 , MSG_MAX , & autotemp_max , 0 , HEATER_0_MAXTEMP - 15 ) ;
MENU_ITEM_EDIT ( float32 , MSG_FACTOR , & autotemp_factor , 0.0 , 1.0 ) ;
# endif
2015-05-13 01:46:16 +00:00
//
// PID-P, PID-I, PID-D, PID-C
//
2015-07-31 05:26:53 +00:00
# if ENABLED(PIDTEMP)
2015-02-20 07:54:06 +00:00
// set up temp variables - undo the default scaling
raw_Ki = unscalePID_i ( PID_PARAM ( Ki , 0 ) ) ;
raw_Kd = unscalePID_d ( PID_PARAM ( Kd , 0 ) ) ;
MENU_ITEM_EDIT ( float52 , MSG_PID_P , & PID_PARAM ( Kp , 0 ) , 1 , 9990 ) ;
// i is typically a small value so allows values below 1
MENU_ITEM_EDIT_CALLBACK ( float52 , MSG_PID_I , & raw_Ki , 0.01 , 9990 , copy_and_scalePID_i_E1 ) ;
MENU_ITEM_EDIT_CALLBACK ( float52 , MSG_PID_D , & raw_Kd , 1 , 9990 , copy_and_scalePID_d_E1 ) ;
2015-07-31 05:26:53 +00:00
# if ENABLED(PID_ADD_EXTRUSION_RATE)
2015-02-20 07:54:06 +00:00
MENU_ITEM_EDIT ( float3 , MSG_PID_C , & PID_PARAM ( Kc , 0 ) , 1 , 9990 ) ;
2015-01-11 02:50:17 +00:00
# endif //PID_ADD_EXTRUSION_RATE
2015-07-31 05:26:53 +00:00
# if ENABLED(PID_PARAMS_PER_EXTRUDER)
2015-02-20 07:54:06 +00:00
# if EXTRUDERS > 1
// set up temp variables - undo the default scaling
raw_Ki = unscalePID_i ( PID_PARAM ( Ki , 1 ) ) ;
raw_Kd = unscalePID_d ( PID_PARAM ( Kd , 1 ) ) ;
2015-02-22 01:38:56 +00:00
MENU_ITEM_EDIT ( float52 , MSG_PID_P MSG_E2 , & PID_PARAM ( Kp , 1 ) , 1 , 9990 ) ;
2015-02-20 07:54:06 +00:00
// i is typically a small value so allows values below 1
2015-02-22 01:38:56 +00:00
MENU_ITEM_EDIT_CALLBACK ( float52 , MSG_PID_I MSG_E2 , & raw_Ki , 0.01 , 9990 , copy_and_scalePID_i_E2 ) ;
MENU_ITEM_EDIT_CALLBACK ( float52 , MSG_PID_D MSG_E2 , & raw_Kd , 1 , 9990 , copy_and_scalePID_d_E2 ) ;
2015-07-31 05:26:53 +00:00
# if ENABLED(PID_ADD_EXTRUSION_RATE)
2015-02-22 01:38:56 +00:00
MENU_ITEM_EDIT ( float3 , MSG_PID_C MSG_E2 , & PID_PARAM ( Kc , 1 ) , 1 , 9990 ) ;
2015-01-11 02:50:17 +00:00
# endif //PID_ADD_EXTRUSION_RATE
2015-02-20 07:54:06 +00:00
# if EXTRUDERS > 2
// set up temp variables - undo the default scaling
raw_Ki = unscalePID_i ( PID_PARAM ( Ki , 2 ) ) ;
raw_Kd = unscalePID_d ( PID_PARAM ( Kd , 2 ) ) ;
2015-02-22 01:38:56 +00:00
MENU_ITEM_EDIT ( float52 , MSG_PID_P MSG_E3 , & PID_PARAM ( Kp , 2 ) , 1 , 9990 ) ;
2015-02-20 07:54:06 +00:00
// i is typically a small value so allows values below 1
2015-02-22 01:38:56 +00:00
MENU_ITEM_EDIT_CALLBACK ( float52 , MSG_PID_I MSG_E3 , & raw_Ki , 0.01 , 9990 , copy_and_scalePID_i_E3 ) ;
MENU_ITEM_EDIT_CALLBACK ( float52 , MSG_PID_D MSG_E3 , & raw_Kd , 1 , 9990 , copy_and_scalePID_d_E3 ) ;
2015-07-31 05:26:53 +00:00
# if ENABLED(PID_ADD_EXTRUSION_RATE)
2015-02-22 01:38:56 +00:00
MENU_ITEM_EDIT ( float3 , MSG_PID_C MSG_E3 , & PID_PARAM ( Kc , 2 ) , 1 , 9990 ) ;
2015-02-20 07:54:06 +00:00
# endif //PID_ADD_EXTRUSION_RATE
# if EXTRUDERS > 3
// set up temp variables - undo the default scaling
raw_Ki = unscalePID_i ( PID_PARAM ( Ki , 3 ) ) ;
raw_Kd = unscalePID_d ( PID_PARAM ( Kd , 3 ) ) ;
2015-02-22 01:38:56 +00:00
MENU_ITEM_EDIT ( float52 , MSG_PID_P MSG_E4 , & PID_PARAM ( Kp , 3 ) , 1 , 9990 ) ;
2015-02-20 07:54:06 +00:00
// i is typically a small value so allows values below 1
2015-02-22 01:38:56 +00:00
MENU_ITEM_EDIT_CALLBACK ( float52 , MSG_PID_I MSG_E4 , & raw_Ki , 0.01 , 9990 , copy_and_scalePID_i_E4 ) ;
MENU_ITEM_EDIT_CALLBACK ( float52 , MSG_PID_D MSG_E4 , & raw_Kd , 1 , 9990 , copy_and_scalePID_d_E4 ) ;
2015-07-31 05:26:53 +00:00
# if ENABLED(PID_ADD_EXTRUSION_RATE)
2015-02-22 01:38:56 +00:00
MENU_ITEM_EDIT ( float3 , MSG_PID_C MSG_E4 , & PID_PARAM ( Kc , 3 ) , 1 , 9990 ) ;
2015-02-20 07:54:06 +00:00
# endif //PID_ADD_EXTRUSION_RATE
# endif //EXTRUDERS > 3
# endif //EXTRUDERS > 2
# endif //EXTRUDERS > 1
# endif //PID_PARAMS_PER_EXTRUDER
# endif //PIDTEMP
2015-05-13 01:46:16 +00:00
//
// Preheat PLA conf
//
2015-02-20 07:54:06 +00:00
MENU_ITEM ( submenu , MSG_PREHEAT_PLA_SETTINGS , lcd_control_temperature_preheat_pla_settings_menu ) ;
2015-05-13 01:46:16 +00:00
//
// Preheat ABS conf
//
2015-02-20 07:54:06 +00:00
MENU_ITEM ( submenu , MSG_PREHEAT_ABS_SETTINGS , lcd_control_temperature_preheat_abs_settings_menu ) ;
END_MENU ( ) ;
2011-12-12 18:34:37 +00:00
}
2015-04-28 02:11:25 +00:00
/**
*
* " Temperature " > " Preheat PLA conf " submenu
*
*/
2015-02-22 01:38:56 +00:00
static void lcd_control_temperature_preheat_pla_settings_menu ( ) {
START_MENU ( ) ;
MENU_ITEM ( back , MSG_TEMPERATURE , lcd_control_temperature_menu ) ;
MENU_ITEM_EDIT ( int3 , MSG_FAN_SPEED , & plaPreheatFanSpeed , 0 , 255 ) ;
# if TEMP_SENSOR_0 != 0
2015-04-27 01:44:01 +00:00
MENU_ITEM_EDIT ( int3 , MSG_NOZZLE , & plaPreheatHotendTemp , HEATER_0_MINTEMP , HEATER_0_MAXTEMP - 15 ) ;
2015-02-22 01:38:56 +00:00
# endif
# if TEMP_SENSOR_BED != 0
2015-04-27 01:44:01 +00:00
MENU_ITEM_EDIT ( int3 , MSG_BED , & plaPreheatHPBTemp , BED_MINTEMP , BED_MAXTEMP - 15 ) ;
2015-02-22 01:38:56 +00:00
# endif
2015-07-31 05:26:53 +00:00
# if ENABLED(EEPROM_SETTINGS)
2012-12-12 10:47:03 +00:00
MENU_ITEM ( function , MSG_STORE_EPROM , Config_StoreSettings ) ;
2015-02-22 01:38:56 +00:00
# endif
END_MENU ( ) ;
2012-12-12 10:47:03 +00:00
}
2011-12-12 18:34:37 +00:00
2015-04-28 02:11:25 +00:00
/**
*
* " Temperature " > " Preheat ABS conf " submenu
*
*/
2015-02-22 01:38:56 +00:00
static void lcd_control_temperature_preheat_abs_settings_menu ( ) {
START_MENU ( ) ;
MENU_ITEM ( back , MSG_TEMPERATURE , lcd_control_temperature_menu ) ;
MENU_ITEM_EDIT ( int3 , MSG_FAN_SPEED , & absPreheatFanSpeed , 0 , 255 ) ;
# if TEMP_SENSOR_0 != 0
2015-04-27 01:44:01 +00:00
MENU_ITEM_EDIT ( int3 , MSG_NOZZLE , & absPreheatHotendTemp , HEATER_0_MINTEMP , HEATER_0_MAXTEMP - 15 ) ;
2015-02-22 01:38:56 +00:00
# endif
# if TEMP_SENSOR_BED != 0
2015-04-27 01:44:01 +00:00
MENU_ITEM_EDIT ( int3 , MSG_BED , & absPreheatHPBTemp , BED_MINTEMP , BED_MAXTEMP - 15 ) ;
2015-02-22 01:38:56 +00:00
# endif
2015-07-31 05:26:53 +00:00
# if ENABLED(EEPROM_SETTINGS)
2012-12-12 10:47:03 +00:00
MENU_ITEM ( function , MSG_STORE_EPROM , Config_StoreSettings ) ;
2015-02-22 01:38:56 +00:00
# endif
END_MENU ( ) ;
2012-12-12 10:47:03 +00:00
}
2011-12-12 18:34:37 +00:00
2015-04-28 02:11:25 +00:00
/**
*
* " Control " > " Motion " submenu
*
*/
2015-02-22 01:38:56 +00:00
static void lcd_control_motion_menu ( ) {
START_MENU ( ) ;
MENU_ITEM ( back , MSG_CONTROL , lcd_control_menu ) ;
2015-08-05 12:12:26 +00:00
# if ENABLED(AUTO_BED_LEVELING_FEATURE)
2015-03-26 20:52:48 +00:00
MENU_ITEM_EDIT ( float32 , MSG_ZPROBE_ZOFFSET , & zprobe_zoffset , Z_PROBE_OFFSET_RANGE_MIN , Z_PROBE_OFFSET_RANGE_MAX ) ;
2015-02-22 01:38:56 +00:00
# endif
2015-03-23 11:29:12 +00:00
MENU_ITEM_EDIT ( float5 , MSG_ACC , & acceleration , 10 , 99000 ) ;
2015-02-22 01:38:56 +00:00
MENU_ITEM_EDIT ( float3 , MSG_VXY_JERK , & max_xy_jerk , 1 , 990 ) ;
MENU_ITEM_EDIT ( float52 , MSG_VZ_JERK , & max_z_jerk , 0.1 , 990 ) ;
MENU_ITEM_EDIT ( float3 , MSG_VE_JERK , & max_e_jerk , 1 , 990 ) ;
MENU_ITEM_EDIT ( float3 , MSG_VMAX MSG_X , & max_feedrate [ X_AXIS ] , 1 , 999 ) ;
MENU_ITEM_EDIT ( float3 , MSG_VMAX MSG_Y , & max_feedrate [ Y_AXIS ] , 1 , 999 ) ;
MENU_ITEM_EDIT ( float3 , MSG_VMAX MSG_Z , & max_feedrate [ Z_AXIS ] , 1 , 999 ) ;
MENU_ITEM_EDIT ( float3 , MSG_VMAX MSG_E , & max_feedrate [ E_AXIS ] , 1 , 999 ) ;
MENU_ITEM_EDIT ( float3 , MSG_VMIN , & minimumfeedrate , 0 , 999 ) ;
MENU_ITEM_EDIT ( float3 , MSG_VTRAV_MIN , & mintravelfeedrate , 0 , 999 ) ;
MENU_ITEM_EDIT_CALLBACK ( long5 , MSG_AMAX MSG_X , & max_acceleration_units_per_sq_second [ X_AXIS ] , 100 , 99000 , reset_acceleration_rates ) ;
MENU_ITEM_EDIT_CALLBACK ( long5 , MSG_AMAX MSG_Y , & max_acceleration_units_per_sq_second [ Y_AXIS ] , 100 , 99000 , reset_acceleration_rates ) ;
2015-03-23 11:29:12 +00:00
MENU_ITEM_EDIT_CALLBACK ( long5 , MSG_AMAX MSG_Z , & max_acceleration_units_per_sq_second [ Z_AXIS ] , 10 , 99000 , reset_acceleration_rates ) ;
2015-02-22 01:38:56 +00:00
MENU_ITEM_EDIT_CALLBACK ( long5 , MSG_AMAX MSG_E , & max_acceleration_units_per_sq_second [ E_AXIS ] , 100 , 99000 , reset_acceleration_rates ) ;
MENU_ITEM_EDIT ( float5 , MSG_A_RETRACT , & retract_acceleration , 100 , 99000 ) ;
2015-03-11 16:19:02 +00:00
MENU_ITEM_EDIT ( float5 , MSG_A_TRAVEL , & travel_acceleration , 100 , 99000 ) ;
2015-02-22 01:38:56 +00:00
MENU_ITEM_EDIT ( float52 , MSG_XSTEPS , & axis_steps_per_unit [ X_AXIS ] , 5 , 9999 ) ;
MENU_ITEM_EDIT ( float52 , MSG_YSTEPS , & axis_steps_per_unit [ Y_AXIS ] , 5 , 9999 ) ;
MENU_ITEM_EDIT ( float51 , MSG_ZSTEPS , & axis_steps_per_unit [ Z_AXIS ] , 5 , 9999 ) ;
MENU_ITEM_EDIT ( float51 , MSG_ESTEPS , & axis_steps_per_unit [ E_AXIS ] , 5 , 9999 ) ;
2015-07-31 05:26:53 +00:00
# if ENABLED(ABORT_ON_ENDSTOP_HIT_FEATURE_ENABLED)
2014-02-11 13:54:43 +00:00
MENU_ITEM_EDIT ( bool , MSG_ENDSTOP_ABORT , & abort_on_endstop_hit ) ;
2015-02-22 01:38:56 +00:00
# endif
2015-07-31 05:26:53 +00:00
# if ENABLED(SCARA)
2014-07-20 11:49:26 +00:00
MENU_ITEM_EDIT ( float74 , MSG_XSCALE , & axis_scaling [ X_AXIS ] , 0.5 , 2 ) ;
MENU_ITEM_EDIT ( float74 , MSG_YSCALE , & axis_scaling [ Y_AXIS ] , 0.5 , 2 ) ;
2015-02-22 01:38:56 +00:00
# endif
END_MENU ( ) ;
2012-12-12 10:47:03 +00:00
}
2011-12-12 18:34:37 +00:00
2015-04-28 02:11:25 +00:00
/**
*
* " Control " > " Filament " submenu
*
*/
2015-02-22 04:18:49 +00:00
static void lcd_control_volumetric_menu ( ) {
2015-02-22 01:38:56 +00:00
START_MENU ( ) ;
MENU_ITEM ( back , MSG_CONTROL , lcd_control_menu ) ;
MENU_ITEM_EDIT_CALLBACK ( bool , MSG_VOLUMETRIC_ENABLED , & volumetric_enabled , calculate_volumetric_multipliers ) ;
if ( volumetric_enabled ) {
2015-02-20 09:22:56 +00:00
MENU_MULTIPLIER_ITEM_EDIT_CALLBACK ( float43 , MSG_FILAMENT_SIZE_EXTRUDER_0 , & filament_size [ 0 ] , 1.5 , 3.25 , calculate_volumetric_multipliers ) ;
2015-02-22 01:38:56 +00:00
# if EXTRUDERS > 1
2015-02-20 09:22:56 +00:00
MENU_MULTIPLIER_ITEM_EDIT_CALLBACK ( float43 , MSG_FILAMENT_SIZE_EXTRUDER_1 , & filament_size [ 1 ] , 1.5 , 3.25 , calculate_volumetric_multipliers ) ;
2015-02-22 01:38:56 +00:00
# if EXTRUDERS > 2
2015-02-20 09:22:56 +00:00
MENU_MULTIPLIER_ITEM_EDIT_CALLBACK ( float43 , MSG_FILAMENT_SIZE_EXTRUDER_2 , & filament_size [ 2 ] , 1.5 , 3.25 , calculate_volumetric_multipliers ) ;
2015-02-22 01:38:56 +00:00
# if EXTRUDERS > 3
2015-02-20 09:22:56 +00:00
MENU_MULTIPLIER_ITEM_EDIT_CALLBACK ( float43 , MSG_FILAMENT_SIZE_EXTRUDER_3 , & filament_size [ 3 ] , 1.5 , 3.25 , calculate_volumetric_multipliers ) ;
2015-02-22 01:38:56 +00:00
# endif //EXTRUDERS > 3
# endif //EXTRUDERS > 2
# endif //EXTRUDERS > 1
}
END_MENU ( ) ;
2014-12-29 01:43:14 +00:00
}
2015-02-22 01:38:56 +00:00
2015-04-28 02:11:25 +00:00
/**
*
* " Control " > " Contrast " submenu
*
*/
2015-07-31 05:26:53 +00:00
# if ENABLED(HAS_LCD_CONTRAST)
2015-04-08 04:11:03 +00:00
static void lcd_set_contrast ( ) {
if ( encoderPosition ! = 0 ) {
2015-07-31 05:26:53 +00:00
# if ENABLED(U8GLIB_LM6059_AF)
2015-05-18 12:37:46 +00:00
lcd_contrast + = encoderPosition ;
lcd_contrast & = 0xFF ;
# else
lcd_contrast - = encoderPosition ;
lcd_contrast & = 0x3F ;
# endif
2015-04-08 04:11:03 +00:00
encoderPosition = 0 ;
lcdDrawUpdate = 1 ;
u8g . setContrast ( lcd_contrast ) ;
}
2015-05-18 12:37:46 +00:00
if ( lcdDrawUpdate ) {
2015-07-31 05:26:53 +00:00
# if ENABLED(U8GLIB_LM6059_AF)
2015-05-18 12:37:46 +00:00
lcd_implementation_drawedit ( PSTR ( MSG_CONTRAST ) , itostr3 ( lcd_contrast ) ) ;
# else
lcd_implementation_drawedit ( PSTR ( MSG_CONTRAST ) , itostr2 ( lcd_contrast ) ) ;
# endif
}
2015-04-08 04:11:03 +00:00
if ( LCD_CLICKED ) lcd_goto_menu ( lcd_control_menu ) ;
2015-02-22 01:38:56 +00:00
}
2015-04-08 10:56:38 +00:00
# endif // HAS_LCD_CONTRAST
2013-07-14 08:28:26 +00:00
2015-04-28 02:11:25 +00:00
/**
*
* " Control " > " Retract " submenu
*
*/
2015-07-31 05:26:53 +00:00
# if ENABLED(FWRETRACT)
2015-04-08 04:11:03 +00:00
static void lcd_control_retract_menu ( ) {
START_MENU ( ) ;
MENU_ITEM ( back , MSG_CONTROL , lcd_control_menu ) ;
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
MENU_ITEM_EDIT ( float3 , MSG_CONTROL_RETRACTF , & retract_feedrate , 1 , 999 ) ;
MENU_ITEM_EDIT ( float52 , MSG_CONTROL_RETRACT_ZLIFT , & retract_zlift , 0 , 999 ) ;
MENU_ITEM_EDIT ( float52 , MSG_CONTROL_RETRACT_RECOVER , & retract_recover_length , 0 , 100 ) ;
# if EXTRUDERS > 1
MENU_ITEM_EDIT ( float52 , MSG_CONTROL_RETRACT_RECOVER_SWAP , & retract_recover_length_swap , 0 , 100 ) ;
# endif
MENU_ITEM_EDIT ( float3 , MSG_CONTROL_RETRACT_RECOVERF , & retract_recover_feedrate , 1 , 999 ) ;
END_MENU ( ) ;
}
# endif // FWRETRACT
2011-12-12 18:34:37 +00:00
2015-09-05 00:40:12 +00:00
# if ENABLED(SDSUPPORT)
2015-02-22 01:38:56 +00:00
2015-09-05 00:40:12 +00:00
# if !PIN_EXISTS(SD_DETECT)
static void lcd_sd_refresh ( ) {
card . initsd ( ) ;
currentMenuViewOffset = 0 ;
}
# endif
2011-12-12 18:34:37 +00:00
2015-09-05 00:40:12 +00:00
static void lcd_sd_updir ( ) {
card . updir ( ) ;
currentMenuViewOffset = 0 ;
2015-02-22 01:38:56 +00:00
}
2013-12-08 20:34:56 +00:00
2015-09-05 00:40:12 +00:00
/**
*
* " Print from SD " submenu
*
*/
void lcd_sdcard_menu ( ) {
if ( lcdDrawUpdate = = 0 & & LCD_CLICKED = = 0 ) return ; // nothing to do (so don't thrash the SD card)
uint16_t fileCnt = card . getnrfilenames ( ) ;
START_MENU ( ) ;
MENU_ITEM ( back , MSG_MAIN , lcd_main_menu ) ;
card . getWorkDirName ( ) ;
if ( card . filename [ 0 ] = = ' / ' ) {
# if !PIN_EXISTS(SD_DETECT)
MENU_ITEM ( function , LCD_STR_REFRESH MSG_REFRESH , lcd_sd_refresh ) ;
# endif
2011-12-12 18:34:37 +00:00
}
2015-02-22 01:38:56 +00:00
else {
2015-09-05 00:40:12 +00:00
MENU_ITEM ( function , LCD_STR_FOLDER " .. " , lcd_sd_updir ) ;
}
for ( uint16_t i = 0 ; i < fileCnt ; i + + ) {
if ( _menuItemNr = = _lineNr ) {
card . getfilename (
# if ENABLED(SDCARD_RATHERRECENTFIRST)
fileCnt - 1 -
# endif
i
) ;
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 ( ) ;
}
2015-02-22 01:38:56 +00:00
}
2015-09-05 00:40:12 +00:00
END_MENU ( ) ;
2015-02-22 01:38:56 +00:00
}
2015-09-05 00:40:12 +00:00
# endif //SDSUPPORT
2011-12-12 18:34:37 +00:00
2015-04-28 02:11:25 +00:00
/**
*
* Functions for editing single values
*
*/
2012-12-12 10:47:03 +00:00
# define menu_edit_type(_type, _name, _strFunc, scale) \
2015-02-24 04:31:28 +00:00
bool _menu_edit_ # # _name ( ) { \
2015-02-24 04:11:52 +00:00
bool isClicked = LCD_CLICKED ; \
if ( ( int32_t ) encoderPosition < 0 ) encoderPosition = 0 ; \
if ( ( int32_t ) encoderPosition > maxEditValue ) encoderPosition = maxEditValue ; \
if ( lcdDrawUpdate ) \
lcd_implementation_drawedit ( editLabel , _strFunc ( ( ( _type ) ( ( int32_t ) encoderPosition + minEditValue ) ) / scale ) ) ; \
if ( isClicked ) { \
* ( ( _type * ) editValue ) = ( ( _type ) ( ( int32_t ) encoderPosition + minEditValue ) ) / scale ; \
lcd_goto_menu ( prevMenu , prevEncoderPosition ) ; \
Allow Edit menu to call fn after edit; Fix PID Ki and Kd display in menus; Actually use changed PID and Max Accel values
Add new 'callback' edit-menu types that call a function after the edit is done. Use this to display and edit Ki and Kd correctly (removing the scaling first and reapplying it after). Also use it to reset maximum stepwise acceleration rates, after updating mm/s^2 rates via menus. (Previously, changes did nothing to affect planner unless saved back to EEPROM, and the machine reset).
Add calls to updatePID() so that PID loop uses updated values whether set by gcode (it already did this), or by restoring defaults, or loading from EEPROM (it didn't do those last two). Similarly, update the maximum step/s^2 accel rates when the mm/s^2 values are changed - whether by menu edits, restore defaults, or EEPROM read.
Refactor the acceleration rate update logic, and the PID scaling logic, into new functions that can be called from wherever, including the callbacks.
Add menu items to allow the z jerk and e jerk to be viewed/edited in the Control->Motion menu, as per xy jerk.
Conflicts:
Marlin/language.h
2013-03-19 14:05:11 +00:00
} \
2015-02-24 04:11:52 +00:00
return isClicked ; \
} \
2015-02-24 04:31:28 +00:00
void menu_edit_ # # _name ( ) { _menu_edit_ # # _name ( ) ; } \
void menu_edit_callback_ # # _name ( ) { if ( _menu_edit_ # # _name ( ) ) ( * callbackFunc ) ( ) ; } \
2015-02-22 01:38:56 +00:00
static void _menu_action_setting_edit_ # # _name ( const char * pstr , _type * ptr , _type minValue , _type maxValue ) { \
prevMenu = currentMenu ; \
prevEncoderPosition = encoderPosition ; \
\
lcdDrawUpdate = 2 ; \
currentMenu = menu_edit_ # # _name ; \
\
editLabel = pstr ; \
editValue = ptr ; \
minEditValue = minValue * scale ; \
maxEditValue = maxValue * scale - minEditValue ; \
encoderPosition = ( * ptr ) * scale - minEditValue ; \
} \
static void menu_action_setting_edit_ # # _name ( const char * pstr , _type * ptr , _type minValue , _type maxValue ) { \
_menu_action_setting_edit_ # # _name ( pstr , ptr , minValue , maxValue ) ; \
currentMenu = menu_edit_ # # _name ; \
} \
static void menu_action_setting_edit_callback_ # # _name ( const char * pstr , _type * ptr , _type minValue , _type maxValue , menuFunc_t callback ) { \
_menu_action_setting_edit_ # # _name ( pstr , ptr , minValue , maxValue ) ; \
currentMenu = menu_edit_callback_ # # _name ; \
callbackFunc = callback ; \
}
2012-12-12 10:47:03 +00:00
menu_edit_type ( int , int3 , itostr3 , 1 )
menu_edit_type ( float , float3 , ftostr3 , 1 )
menu_edit_type ( float , float32 , ftostr32 , 100 )
2014-12-29 01:43:14 +00:00
menu_edit_type ( float , float43 , ftostr43 , 1000 )
2012-12-12 10:47:03 +00:00
menu_edit_type ( float , float5 , ftostr5 , 0.01 )
menu_edit_type ( float , float51 , ftostr51 , 10 )
menu_edit_type ( float , float52 , ftostr52 , 100 )
menu_edit_type ( unsigned long , long5 , ftostr5 , 0.01 )
2011-12-12 18:34:37 +00:00
2015-04-28 02:11:25 +00:00
/**
*
* Handlers for RepRap World Keypad input
*
*/
2015-07-31 05:26:53 +00:00
# if ENABLED(REPRAPWORLD_KEYPAD)
2015-02-22 01:38:56 +00:00
static void reprapworld_keypad_move_z_up ( ) {
2013-07-14 13:35:54 +00:00
encoderPosition = 1 ;
move_menu_scale = REPRAPWORLD_KEYPAD_MOVE_STEP ;
2015-02-22 01:38:56 +00:00
lcd_move_z ( ) ;
2013-07-14 13:35:54 +00:00
}
2015-02-22 01:38:56 +00:00
static void reprapworld_keypad_move_z_down ( ) {
2013-07-14 13:35:54 +00:00
encoderPosition = - 1 ;
move_menu_scale = REPRAPWORLD_KEYPAD_MOVE_STEP ;
2015-02-22 01:38:56 +00:00
lcd_move_z ( ) ;
2013-07-14 13:35:54 +00:00
}
2015-02-22 01:38:56 +00:00
static void reprapworld_keypad_move_x_left ( ) {
2013-07-14 13:35:54 +00:00
encoderPosition = - 1 ;
move_menu_scale = REPRAPWORLD_KEYPAD_MOVE_STEP ;
2015-02-22 01:38:56 +00:00
lcd_move_x ( ) ;
2013-07-14 13:35:54 +00:00
}
2015-02-22 01:38:56 +00:00
static void reprapworld_keypad_move_x_right ( ) {
2013-07-14 13:35:54 +00:00
encoderPosition = 1 ;
move_menu_scale = REPRAPWORLD_KEYPAD_MOVE_STEP ;
2015-02-22 01:38:56 +00:00
lcd_move_x ( ) ;
}
static void reprapworld_keypad_move_y_down ( ) {
2013-07-14 13:35:54 +00:00
encoderPosition = 1 ;
move_menu_scale = REPRAPWORLD_KEYPAD_MOVE_STEP ;
lcd_move_y ( ) ;
2015-02-22 01:38:56 +00:00
}
static void reprapworld_keypad_move_y_up ( ) {
encoderPosition = - 1 ;
move_menu_scale = REPRAPWORLD_KEYPAD_MOVE_STEP ;
lcd_move_y ( ) ;
}
static void reprapworld_keypad_move_home ( ) {
2015-04-13 01:07:08 +00:00
enqueuecommands_P ( ( PSTR ( " G28 " ) ) ) ; // move all axis home
2015-02-22 01:38:56 +00:00
}
2015-04-28 02:11:25 +00:00
# endif // REPRAPWORLD_KEYPAD
2013-06-06 22:49:25 +00:00
2011-12-12 18:34:37 +00:00
2015-04-28 02:11:25 +00:00
/**
*
* Audio feedback for controller clicks
*
*/
2015-06-17 14:31:14 +00:00
2015-07-31 05:26:53 +00:00
# if ENABLED(LCD_USE_I2C_BUZZER)
2015-06-17 14:31:14 +00:00
void lcd_buzz ( long duration , uint16_t freq ) { // called from buzz() in Marlin_main.cpp where lcd is unknown
lcd . buzz ( duration , freq ) ;
}
# endif
2015-04-13 01:07:08 +00:00
void lcd_quick_feedback ( ) {
2015-02-22 01:38:56 +00:00
lcdDrawUpdate = 2 ;
2015-04-13 01:07:08 +00:00
next_button_update_ms = millis ( ) + 500 ;
2015-03-26 08:00:34 +00:00
2015-07-31 05:26:53 +00:00
# if ENABLED(LCD_USE_I2C_BUZZER)
2015-03-26 08:00:34 +00:00
# ifndef LCD_FEEDBACK_FREQUENCY_HZ
# define LCD_FEEDBACK_FREQUENCY_HZ 100
# endif
# ifndef LCD_FEEDBACK_FREQUENCY_DURATION_MS
# define LCD_FEEDBACK_FREQUENCY_DURATION_MS (1000 / 6)
# endif
2015-06-17 14:31:14 +00:00
lcd . buzz ( LCD_FEEDBACK_FREQUENCY_DURATION_MS , LCD_FEEDBACK_FREQUENCY_HZ ) ;
2015-07-31 06:19:11 +00:00
# elif PIN_EXISTS(BEEPER)
2015-03-26 08:00:34 +00:00
# ifndef LCD_FEEDBACK_FREQUENCY_HZ
2015-03-31 08:41:24 +00:00
# define LCD_FEEDBACK_FREQUENCY_HZ 5000
2015-03-26 08:00:34 +00:00
# endif
# ifndef LCD_FEEDBACK_FREQUENCY_DURATION_MS
2015-03-31 08:41:24 +00:00
# define LCD_FEEDBACK_FREQUENCY_DURATION_MS 2
2015-03-26 08:00:34 +00:00
# endif
2015-06-14 22:12:02 +00:00
buzz ( LCD_FEEDBACK_FREQUENCY_DURATION_MS , LCD_FEEDBACK_FREQUENCY_HZ ) ;
2015-04-20 09:11:13 +00:00
# else
# ifndef LCD_FEEDBACK_FREQUENCY_DURATION_MS
# define LCD_FEEDBACK_FREQUENCY_DURATION_MS 2
# endif
delay ( LCD_FEEDBACK_FREQUENCY_DURATION_MS ) ;
2015-03-26 08:00:34 +00:00
# endif
2012-12-12 10:47:03 +00:00
}
2011-12-12 18:34:37 +00:00
2015-04-28 02:11:25 +00:00
/**
*
* Menu actions
*
*/
static void menu_action_back ( menuFunc_t func ) { lcd_goto_menu ( func ) ; }
static void menu_action_submenu ( menuFunc_t func ) { lcd_goto_menu ( func ) ; }
2015-04-13 01:07:08 +00:00
static void menu_action_gcode ( const char * pgcode ) { enqueuecommands_P ( pgcode ) ; }
2015-04-28 02:11:25 +00:00
static void menu_action_function ( menuFunc_t func ) { ( * func ) ( ) ; }
2015-02-22 01:38:56 +00:00
static void menu_action_sdfile ( const char * filename , char * longFilename ) {
char cmd [ 30 ] ;
char * c ;
sprintf_P ( cmd , PSTR ( " M23 %s " ) , filename ) ;
for ( c = & cmd [ 4 ] ; * c ; c + + ) * c = tolower ( * c ) ;
2015-04-13 01:07:08 +00:00
enqueuecommand ( cmd ) ;
enqueuecommands_P ( PSTR ( " M24 " ) ) ;
2015-02-22 01:38:56 +00:00
lcd_return_to_status ( ) ;
2012-12-12 10:47:03 +00:00
}
2015-09-05 00:40:12 +00:00
# if ENABLED(SDSUPPORT)
static void menu_action_sddirectory ( const char * filename , char * longFilename ) {
card . chdir ( filename ) ;
encoderPosition = 0 ;
}
# endif
2015-02-22 01:38:56 +00:00
static void menu_action_setting_edit_bool ( const char * pstr , bool * ptr ) { * ptr = ! ( * ptr ) ; }
static void menu_action_setting_edit_callback_bool ( const char * pstr , bool * ptr , menuFunc_t callback ) {
menu_action_setting_edit_bool ( pstr , ptr ) ;
( * callback ) ( ) ;
2012-12-12 10:47:03 +00:00
}
2015-02-22 01:38:56 +00:00
# endif //ULTIPANEL
2011-12-12 18:34:37 +00:00
2012-12-12 10:47:03 +00:00
/** LCD API **/
2015-02-22 01:38:56 +00:00
void lcd_init ( ) {
lcd_implementation_init ( ) ;
2015-07-31 05:26:53 +00:00
# if ENABLED(NEWPANEL)
2011-12-12 18:34:37 +00:00
2014-12-28 18:54:06 +00:00
SET_INPUT ( BTN_EN1 ) ;
SET_INPUT ( BTN_EN2 ) ;
2012-12-12 10:47:03 +00:00
WRITE ( BTN_EN1 , HIGH ) ;
WRITE ( BTN_EN2 , HIGH ) ;
2013-06-06 22:49:25 +00:00
# if BTN_ENC > 0
2014-12-28 18:54:06 +00:00
SET_INPUT ( BTN_ENC ) ;
2012-12-12 10:47:03 +00:00
WRITE ( BTN_ENC , HIGH ) ;
2013-12-08 20:34:56 +00:00
# endif
2015-07-31 05:26:53 +00:00
# if ENABLED(REPRAPWORLD_KEYPAD)
2013-06-06 22:49:25 +00:00
pinMode ( SHIFT_CLK , OUTPUT ) ;
pinMode ( SHIFT_LD , OUTPUT ) ;
pinMode ( SHIFT_OUT , INPUT ) ;
WRITE ( SHIFT_OUT , HIGH ) ;
WRITE ( SHIFT_LD , HIGH ) ;
# endif
2014-01-17 22:00:47 +00:00
# else // Not NEWPANEL
2015-07-31 05:26:53 +00:00
# if ENABLED(SR_LCD_2W_NL) // Non latching 2 wire shift register
2013-10-30 10:45:32 +00:00
pinMode ( SR_DATA_PIN , OUTPUT ) ;
pinMode ( SR_CLK_PIN , OUTPUT ) ;
2014-11-24 14:51:16 +00:00
# elif defined(SHIFT_CLK)
2013-10-30 10:45:32 +00:00
pinMode ( SHIFT_CLK , OUTPUT ) ;
pinMode ( SHIFT_LD , OUTPUT ) ;
pinMode ( SHIFT_EN , OUTPUT ) ;
pinMode ( SHIFT_OUT , INPUT ) ;
WRITE ( SHIFT_OUT , HIGH ) ;
2013-12-08 20:34:56 +00:00
WRITE ( SHIFT_LD , HIGH ) ;
2013-10-30 10:45:32 +00:00
WRITE ( SHIFT_EN , LOW ) ;
2014-01-17 22:00:47 +00:00
# endif // SR_LCD_2W_NL
2012-12-12 10:47:03 +00:00
# endif //!NEWPANEL
2013-10-30 10:45:32 +00:00
2015-07-31 23:40:50 +00:00
# if ENABLED(SDSUPPORT) && PIN_EXISTS(SD_DETECT)
pinMode ( SD_DETECT_PIN , INPUT ) ;
WRITE ( SD_DETECT_PIN , HIGH ) ;
2012-12-12 10:47:03 +00:00
lcd_oldcardstatus = IS_SD_INSERTED ;
2015-07-31 22:09:36 +00:00
# endif
2015-02-22 01:38:56 +00:00
2015-07-31 05:26:53 +00:00
# if ENABLED(LCD_HAS_SLOW_BUTTONS)
2013-11-17 16:41:30 +00:00
slow_buttons = 0 ;
2015-02-22 01:38:56 +00:00
# endif
lcd_buttons_update ( ) ;
2015-07-31 05:26:53 +00:00
# if ENABLED(ULTIPANEL)
2012-12-21 15:14:47 +00:00
encoderDiff = 0 ;
2015-02-22 01:38:56 +00:00
# endif
2012-12-12 10:47:03 +00:00
}
2011-12-12 18:34:37 +00:00
2015-02-16 12:53:58 +00:00
int lcd_strlen ( char * s ) {
2015-02-22 01:38:56 +00:00
int i = 0 , j = 0 ;
while ( s [ i ] ) {
if ( ( s [ i ] & 0xc0 ) ! = 0x80 ) j + + ;
i + + ;
}
return j ;
2015-02-16 12:53:58 +00:00
}
int lcd_strlen_P ( const char * s ) {
2015-02-22 01:38:56 +00:00
int j = 0 ;
while ( pgm_read_byte ( s ) ) {
if ( ( pgm_read_byte ( s ) & 0xc0 ) ! = 0x80 ) j + + ;
s + + ;
}
return j ;
2015-02-16 12:53:58 +00:00
}
2015-04-28 02:11:25 +00:00
/**
* 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
* - Reset the Info Screen timeout if there ' s any input
* - Update status indicators , if any
* - Clear the LCD if lcdDrawUpdate = = 2
*
* Warning : This function is called from interrupt context !
*/
2015-02-22 01:38:56 +00:00
void lcd_update ( ) {
2015-07-31 05:26:53 +00:00
# if ENABLED(ULTIPANEL)
2015-04-13 01:07:08 +00:00
static millis_t return_to_status_ms = 0 ;
2015-04-09 10:26:45 +00:00
# endif
2015-02-16 12:53:58 +00:00
2015-07-31 05:26:53 +00:00
# if ENABLED(LCD_HAS_SLOW_BUTTONS)
2013-11-17 16:41:30 +00:00
slow_buttons = lcd_implementation_read_slow_buttons ( ) ; // buttons which take too long to read in interrupt context
2015-02-22 01:38:56 +00:00
# endif
2013-12-08 20:34:56 +00:00
2015-02-22 01:38:56 +00:00
lcd_buttons_update ( ) ;
2013-12-08 20:34:56 +00:00
2015-09-05 00:40:12 +00:00
# if ENABLED(SDSUPPORT) && PIN_EXISTS(SD_DETECT)
2015-02-22 01:38:56 +00:00
if ( IS_SD_INSERTED ! = lcd_oldcardstatus & & lcd_detected ( ) ) {
lcdDrawUpdate = 2 ;
lcd_oldcardstatus = IS_SD_INSERTED ;
lcd_implementation_init ( // to maybe revive the LCD if static electricity killed it.
2015-07-31 05:26:53 +00:00
# if ENABLED(LCD_PROGRESS_BAR)
2015-02-22 01:38:56 +00:00
currentMenu = = lcd_status_screen
# endif
) ;
2013-12-08 20:34:56 +00:00
2015-02-22 01:38:56 +00:00
if ( lcd_oldcardstatus ) {
card . initsd ( ) ;
LCD_MESSAGEPGM ( MSG_SD_INSERTED ) ;
}
else {
card . release ( ) ;
LCD_MESSAGEPGM ( MSG_SD_REMOVED ) ;
}
2012-12-12 10:47:03 +00:00
}
2015-09-05 00:40:12 +00:00
# endif //SDSUPPORT && SD_DETECT_PIN
2015-04-04 16:33:36 +00:00
2015-04-13 01:07:08 +00:00
millis_t ms = millis ( ) ;
if ( ms > next_lcd_update_ms ) {
2015-02-22 01:38:56 +00:00
2015-07-31 05:26:53 +00:00
# if ENABLED(ULTIPANEL)
2015-02-22 01:38:56 +00:00
2015-07-31 05:26:53 +00:00
# if ENABLED(REPRAPWORLD_KEYPAD)
2015-02-22 01:38:56 +00:00
if ( REPRAPWORLD_KEYPAD_MOVE_Z_UP ) reprapworld_keypad_move_z_up ( ) ;
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 ( ) ;
if ( REPRAPWORLD_KEYPAD_MOVE_HOME ) reprapworld_keypad_move_home ( ) ;
2015-02-22 04:18:49 +00:00
# endif
2015-02-22 01:38:56 +00:00
bool encoderPastThreshold = ( abs ( encoderDiff ) > = ENCODER_PULSES_PER_STEP ) ;
if ( encoderPastThreshold | | LCD_CLICKED ) {
if ( encoderPastThreshold ) {
2015-02-22 04:18:49 +00:00
int32_t encoderMultiplier = 1 ;
2015-07-31 05:26:53 +00:00
# if ENABLED(ENCODER_RATE_MULTIPLIER)
2015-02-22 04:18:49 +00:00
if ( encoderRateMultiplierEnabled ) {
int32_t encoderMovementSteps = abs ( encoderDiff ) / ENCODER_PULSES_PER_STEP ;
if ( lastEncoderMovementMillis ! = 0 ) {
// Note that the rate is always calculated between to passes through the
// 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 ;
2015-07-31 05:26:53 +00:00
# if ENABLED(ENCODER_RATE_MULTIPLIER_DEBUG)
2015-02-22 04:18:49 +00:00
SERIAL_ECHO_START ;
SERIAL_ECHO ( " Enc Step Rate: " ) ;
SERIAL_ECHO ( encoderStepRate ) ;
SERIAL_ECHO ( " Multiplier: " ) ;
SERIAL_ECHO ( encoderMultiplier ) ;
SERIAL_ECHO ( " ENCODER_10X_STEPS_PER_SEC: " ) ;
SERIAL_ECHO ( ENCODER_10X_STEPS_PER_SEC ) ;
SERIAL_ECHO ( " ENCODER_100X_STEPS_PER_SEC: " ) ;
SERIAL_ECHOLN ( ENCODER_100X_STEPS_PER_SEC ) ;
# endif //ENCODER_RATE_MULTIPLIER_DEBUG
}
lastEncoderMovementMillis = ms ;
2015-03-30 23:39:47 +00:00
} // encoderRateMultiplierEnabled
2015-02-22 04:18:49 +00:00
# endif //ENCODER_RATE_MULTIPLIER
encoderPosition + = ( encoderDiff * encoderMultiplier ) / ENCODER_PULSES_PER_STEP ;
2015-02-22 01:38:56 +00:00
encoderDiff = 0 ;
2012-08-21 22:46:10 +00:00
}
2015-04-13 01:07:08 +00:00
return_to_status_ms = ms + LCD_TIMEOUT_TO_STATUS ;
2015-04-04 20:02:24 +00:00
lcdDrawUpdate = 1 ;
2015-02-22 01:38:56 +00:00
}
# endif //ULTIPANEL
2015-04-04 20:02:24 +00:00
if ( currentMenu = = lcd_status_screen ) {
if ( ! lcd_status_update_delay ) {
lcdDrawUpdate = 1 ;
lcd_status_update_delay = 10 ; /* redraw the main screen every second. This is easier then trying keep track of all things that change on the screen */
}
else {
lcd_status_update_delay - - ;
}
}
2015-07-31 05:26:53 +00:00
# if ENABLED(DOGLCD) // Changes due to different driver architecture of the DOGM display
2015-04-04 15:49:39 +00:00
if ( lcdDrawUpdate ) {
2015-04-04 20:02:24 +00:00
blink + + ; // Variable for fan animation and alive dot
u8g . firstPage ( ) ;
2015-04-04 15:49:39 +00:00
do {
lcd_setFont ( FONT_MENU ) ;
u8g . setPrintPos ( 125 , 0 ) ;
2015-04-04 20:02:24 +00:00
if ( blink % 2 ) u8g . setColorIndex ( 1 ) ; else u8g . setColorIndex ( 0 ) ; // Set color for the alive dot
u8g . drawPixel ( 127 , 63 ) ; // draw alive dot
u8g . setColorIndex ( 1 ) ; // black on white
2015-04-04 15:49:39 +00:00
( * currentMenu ) ( ) ;
} while ( u8g . nextPage ( ) ) ;
}
2015-02-22 01:38:56 +00:00
# else
( * currentMenu ) ( ) ;
# endif
2013-03-19 19:19:16 +00:00
2015-07-31 05:26:53 +00:00
# if ENABLED(LCD_HAS_STATUS_INDICATORS)
2015-02-22 01:38:56 +00:00
lcd_implementation_update_indicators ( ) ;
# endif
2013-06-06 22:49:25 +00:00
2015-07-31 05:26:53 +00:00
# if ENABLED(ULTIPANEL)
2015-04-13 01:07:08 +00:00
// Return to Status Screen after a timeout
2015-03-15 22:18:11 +00:00
if ( currentMenu ! = lcd_status_screen & &
2015-07-31 05:26:53 +00:00
# if ENABLED(MANUAL_BED_LEVELING)
2015-04-13 01:07:08 +00:00
currentMenu ! = _lcd_level_bed & &
currentMenu ! = _lcd_level_bed_homing & &
# endif
millis ( ) > return_to_status_ms
) {
2015-02-22 01:38:56 +00:00
lcd_return_to_status ( ) ;
lcdDrawUpdate = 2 ;
}
2015-04-13 01:07:08 +00:00
# endif // ULTIPANEL
2015-02-22 01:38:56 +00:00
if ( lcdDrawUpdate = = 2 ) lcd_implementation_clear ( ) ;
if ( lcdDrawUpdate ) lcdDrawUpdate - - ;
2015-04-28 02:11:25 +00:00
next_lcd_update_ms = ms + LCD_UPDATE_INTERVAL ;
2015-02-22 01:38:56 +00:00
}
2012-12-12 10:47:03 +00:00
}
2012-08-21 22:46:10 +00:00
2015-02-22 01:38:56 +00:00
void lcd_ignore_click ( bool b ) {
ignore_click = b ;
wait_for_unclick = false ;
2014-11-25 00:56:37 +00:00
}
2015-03-31 01:00:54 +00:00
void lcd_finishstatus ( bool persist = false ) {
2015-07-31 05:26:53 +00:00
# if ENABLED(LCD_PROGRESS_BAR)
2015-04-25 05:16:09 +00:00
progress_bar_ms = millis ( ) ;
2014-12-28 06:26:14 +00:00
# if PROGRESS_MSG_EXPIRE > 0
2015-04-25 05:16:09 +00:00
expire_status_ms = persist ? 0 : progress_bar_ms + PROGRESS_MSG_EXPIRE ;
2014-12-28 06:26:14 +00:00
# endif
# endif
lcdDrawUpdate = 2 ;
2015-07-31 05:26:53 +00:00
# if ENABLED(FILAMENT_LCD_DISPLAY)
2015-04-13 01:07:08 +00:00
previous_lcd_status_ms = millis ( ) ; //get status message to show up for a while
2014-12-28 06:26:14 +00:00
# endif
}
2015-02-22 01:38:56 +00:00
2015-07-31 05:26:53 +00:00
# if ENABLED(LCD_PROGRESS_BAR) && PROGRESS_MSG_EXPIRE > 0
2015-04-25 04:51:10 +00:00
void dontExpireStatus ( ) { expire_status_ms = 0 ; }
2015-03-31 01:00:54 +00:00
# endif
2015-04-07 00:33:34 +00:00
void set_utf_strlen ( char * s , uint8_t n ) {
uint8_t i = 0 , j = 0 ;
while ( s [ i ] & & ( j < n ) ) {
if ( ( s [ i ] & 0xc0u ) ! = 0x80u ) j + + ;
i + + ;
}
while ( j + + < n ) s [ i + + ] = ' ' ;
s [ i ] = 0 ;
}
2015-04-25 03:13:01 +00:00
bool lcd_hasstatus ( ) { return ( lcd_status_message [ 0 ] ! = ' \0 ' ) ; }
2015-03-31 01:00:54 +00:00
void lcd_setstatus ( const char * message , bool persist ) {
2015-02-22 01:38:56 +00:00
if ( lcd_status_message_level > 0 ) return ;
2015-04-07 00:33:34 +00:00
strncpy ( lcd_status_message , message , 3 * LCD_WIDTH ) ;
set_utf_strlen ( lcd_status_message , LCD_WIDTH ) ;
2015-03-31 01:00:54 +00:00
lcd_finishstatus ( persist ) ;
2012-12-12 10:47:03 +00:00
}
2015-02-22 01:38:56 +00:00
2015-03-31 01:00:54 +00:00
void lcd_setstatuspgm ( const char * message , uint8_t level ) {
if ( level > = lcd_status_message_level ) {
2015-04-07 00:33:34 +00:00
strncpy_P ( lcd_status_message , message , 3 * LCD_WIDTH ) ;
set_utf_strlen ( lcd_status_message , LCD_WIDTH ) ;
2015-03-31 01:00:54 +00:00
lcd_status_message_level = level ;
lcd_finishstatus ( level > 0 ) ;
}
2012-12-12 10:47:03 +00:00
}
2015-02-22 01:38:56 +00:00
void lcd_setalertstatuspgm ( const char * message ) {
2015-03-31 01:00:54 +00:00
lcd_setstatuspgm ( message , 1 ) ;
2015-07-31 05:26:53 +00:00
# if ENABLED(ULTIPANEL)
2012-12-12 10:47:03 +00:00
lcd_return_to_status ( ) ;
2015-02-22 01:38:56 +00:00
# endif
2012-12-12 10:47:03 +00:00
}
2012-08-21 22:46:10 +00:00
2015-02-22 01:38:56 +00:00
void lcd_reset_alert_level ( ) { lcd_status_message_level = 0 ; }
2015-07-31 05:26:53 +00:00
# if ENABLED(HAS_LCD_CONTRAST)
2015-02-22 01:38:56 +00:00
void lcd_setcontrast ( uint8_t value ) {
2015-04-08 04:11:03 +00:00
lcd_contrast = value & 0x3F ;
2013-12-08 20:34:56 +00:00
u8g . setContrast ( lcd_contrast ) ;
2015-02-22 01:38:56 +00:00
}
2013-07-14 08:28:26 +00:00
# endif
2015-07-31 05:26:53 +00:00
# if ENABLED(ULTIPANEL)
2015-02-22 01:38:56 +00:00
2015-04-28 02:11:25 +00:00
/**
* 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
2015-06-12 11:12:55 +00:00
# endif
2015-04-28 02:11:25 +00:00
/**
* Read encoder buttons from the hardware registers
* Warning : This function is called from interrupt context !
*/
void lcd_buttons_update ( ) {
2015-07-31 05:26:53 +00:00
# if ENABLED(NEWPANEL)
2015-04-28 02:11:25 +00:00
uint8_t newbutton = 0 ;
if ( READ ( BTN_EN1 ) = = 0 ) newbutton | = EN_A ;
if ( READ ( BTN_EN2 ) = = 0 ) newbutton | = EN_B ;
# if BTN_ENC > 0
if ( millis ( ) > next_button_update_ms & & READ ( BTN_ENC ) = = 0 ) newbutton | = EN_C ;
# endif
buttons = newbutton ;
2015-07-31 05:26:53 +00:00
# if ENABLED(LCD_HAS_SLOW_BUTTONS)
2015-04-28 02:11:25 +00:00
buttons | = slow_buttons ;
# endif
2015-07-31 05:26:53 +00:00
# if ENABLED(REPRAPWORLD_KEYPAD)
2015-04-28 02:11:25 +00:00
// for the reprapworld_keypad
uint8_t newbutton_reprapworld_keypad = 0 ;
WRITE ( SHIFT_LD , LOW ) ;
WRITE ( SHIFT_LD , HIGH ) ;
for ( int8_t i = 0 ; i < 8 ; i + + ) {
newbutton_reprapworld_keypad > > = 1 ;
if ( READ ( SHIFT_OUT ) ) newbutton_reprapworld_keypad | = BIT ( 7 ) ;
WRITE ( SHIFT_CLK , HIGH ) ;
WRITE ( SHIFT_CLK , LOW ) ;
}
buttons_reprapworld_keypad = ~ newbutton_reprapworld_keypad ; //invert it, because a pressed switch produces a logical 0
# endif
# else //read it from the shift register
uint8_t newbutton = 0 ;
2015-02-22 01:38:56 +00:00
WRITE ( SHIFT_LD , LOW ) ;
WRITE ( SHIFT_LD , HIGH ) ;
2015-04-28 02:11:25 +00:00
unsigned char tmp_buttons = 0 ;
for ( int8_t i = 0 ; i < 8 ; i + + ) {
newbutton > > = 1 ;
if ( READ ( SHIFT_OUT ) ) newbutton | = BIT ( 7 ) ;
2015-02-22 01:38:56 +00:00
WRITE ( SHIFT_CLK , HIGH ) ;
WRITE ( SHIFT_CLK , LOW ) ;
2013-07-14 13:35:54 +00:00
}
2015-04-28 02:11:25 +00:00
buttons = ~ newbutton ; //invert it, because a pressed switch produces a logical 0
# endif //!NEWPANEL
//manage encoder rotation
uint8_t enc = 0 ;
if ( buttons & EN_A ) enc | = B01 ;
if ( buttons & EN_B ) enc | = B10 ;
if ( enc ! = lastEncoderBits ) {
switch ( enc ) {
case encrot0 :
if ( lastEncoderBits = = encrot3 ) encoderDiff + + ;
else if ( lastEncoderBits = = encrot1 ) encoderDiff - - ;
break ;
case encrot1 :
if ( lastEncoderBits = = encrot0 ) encoderDiff + + ;
else if ( lastEncoderBits = = encrot2 ) encoderDiff - - ;
break ;
case encrot2 :
if ( lastEncoderBits = = encrot1 ) encoderDiff + + ;
else if ( lastEncoderBits = = encrot3 ) encoderDiff - - ;
break ;
case encrot3 :
if ( lastEncoderBits = = encrot2 ) encoderDiff + + ;
else if ( lastEncoderBits = = encrot0 ) encoderDiff - - ;
break ;
}
2012-12-12 10:47:03 +00:00
}
2015-04-28 02:11:25 +00:00
lastEncoderBits = enc ;
2015-02-22 01:38:56 +00:00
}
2014-03-03 21:01:27 +00:00
2015-04-28 02:11:25 +00:00
bool lcd_detected ( void ) {
2015-07-31 05:26:53 +00:00
# if (ENABLED(LCD_I2C_TYPE_MCP23017) || ENABLED(LCD_I2C_TYPE_MCP23008)) && ENABLED(DETECT_DEVICE)
2015-04-28 02:11:25 +00:00
return lcd . LcdDetected ( ) = = 1 ;
2015-04-20 09:11:13 +00:00
# else
2015-04-28 02:11:25 +00:00
return true ;
2015-04-20 09:11:13 +00:00
# endif
}
2015-04-28 02:11:25 +00:00
2015-06-14 22:12:02 +00:00
bool lcd_clicked ( ) { return LCD_CLICKED ; }
# endif // ULTIPANEL
2015-03-30 23:39:47 +00:00
/*********************************/
/** Number to string conversion **/
/*********************************/
2012-12-12 10:47:03 +00:00
char conv [ 8 ] ;
2015-03-30 23:39:47 +00:00
// Convert float to string with +123.4 format
char * ftostr3 ( const float & x ) {
2012-12-12 10:47:03 +00:00
return itostr3 ( ( int ) x ) ;
2011-12-12 18:34:37 +00:00
}
2015-03-30 23:39:47 +00:00
// Convert int to string with 12 format
char * itostr2 ( const uint8_t & x ) {
2011-12-12 18:34:37 +00:00
//sprintf(conv,"%5.1f",x);
2015-03-30 23:39:47 +00:00
int xx = x ;
conv [ 0 ] = ( xx / 10 ) % 10 + ' 0 ' ;
conv [ 1 ] = xx % 10 + ' 0 ' ;
conv [ 2 ] = 0 ;
2011-12-12 18:34:37 +00:00
return conv ;
}
2015-03-30 23:39:47 +00:00
// Convert float to string with +123.4 format
char * ftostr31 ( const float & x ) {
int xx = abs ( x * 10 ) ;
conv [ 0 ] = ( x > = 0 ) ? ' + ' : ' - ' ;
conv [ 1 ] = ( xx / 1000 ) % 10 + ' 0 ' ;
conv [ 2 ] = ( xx / 100 ) % 10 + ' 0 ' ;
conv [ 3 ] = ( xx / 10 ) % 10 + ' 0 ' ;
conv [ 4 ] = ' . ' ;
conv [ 5 ] = xx % 10 + ' 0 ' ;
conv [ 6 ] = 0 ;
2011-12-12 18:34:37 +00:00
return conv ;
}
2015-03-30 23:39:47 +00:00
// Convert float to string with 123.4 format, dropping sign
char * ftostr31ns ( const float & x ) {
int xx = abs ( x * 10 ) ;
conv [ 0 ] = ( xx / 1000 ) % 10 + ' 0 ' ;
conv [ 1 ] = ( xx / 100 ) % 10 + ' 0 ' ;
conv [ 2 ] = ( xx / 10 ) % 10 + ' 0 ' ;
conv [ 3 ] = ' . ' ;
conv [ 4 ] = xx % 10 + ' 0 ' ;
conv [ 5 ] = 0 ;
2013-03-19 19:13:23 +00:00
return conv ;
}
2015-03-30 23:39:47 +00:00
// Convert float to string with 123.4 format
char * ftostr32 ( const float & x ) {
long xx = abs ( x * 100 ) ;
conv [ 0 ] = x > = 0 ? ( xx / 10000 ) % 10 + ' 0 ' : ' - ' ;
conv [ 1 ] = ( xx / 1000 ) % 10 + ' 0 ' ;
conv [ 2 ] = ( xx / 100 ) % 10 + ' 0 ' ;
conv [ 3 ] = ' . ' ;
conv [ 4 ] = ( xx / 10 ) % 10 + ' 0 ' ;
conv [ 5 ] = xx % 10 + ' 0 ' ;
conv [ 6 ] = 0 ;
2011-12-12 18:34:37 +00:00
return conv ;
}
2014-12-29 01:43:14 +00:00
// Convert float to string with 1.234 format
2015-04-28 02:11:25 +00:00
char * ftostr43 ( const float & x ) {
2014-12-29 01:43:14 +00:00
long xx = x * 1000 ;
if ( xx > = 0 )
conv [ 0 ] = ( xx / 1000 ) % 10 + ' 0 ' ;
else
conv [ 0 ] = ' - ' ;
xx = abs ( xx ) ;
conv [ 1 ] = ' . ' ;
conv [ 2 ] = ( xx / 100 ) % 10 + ' 0 ' ;
conv [ 3 ] = ( xx / 10 ) % 10 + ' 0 ' ;
conv [ 4 ] = ( xx ) % 10 + ' 0 ' ;
conv [ 5 ] = 0 ;
return conv ;
}
2015-03-30 23:39:47 +00:00
// Convert float to string with 1.23 format
2015-04-28 02:11:25 +00:00
char * ftostr12ns ( const float & x ) {
2014-11-11 03:43:58 +00:00
long xx = x * 100 ;
xx = abs ( xx ) ;
conv [ 0 ] = ( xx / 100 ) % 10 + ' 0 ' ;
conv [ 1 ] = ' . ' ;
conv [ 2 ] = ( xx / 10 ) % 10 + ' 0 ' ;
conv [ 3 ] = ( xx ) % 10 + ' 0 ' ;
conv [ 4 ] = 0 ;
return conv ;
}
2015-03-30 23:39:47 +00:00
// Convert float to space-padded string with -_23.4_ format
2014-12-23 01:11:35 +00:00
char * ftostr32sp ( const float & x ) {
2014-12-08 09:43:44 +00:00
long xx = abs ( x * 100 ) ;
uint8_t dig ;
if ( x < 0 ) { // negative val = -_0
conv [ 0 ] = ' - ' ;
dig = ( xx / 1000 ) % 10 ;
conv [ 1 ] = dig ? ' 0 ' + dig : ' ' ;
}
else { // positive val = __0
dig = ( xx / 10000 ) % 10 ;
if ( dig ) {
conv [ 0 ] = ' 0 ' + dig ;
conv [ 1 ] = ' 0 ' + ( xx / 1000 ) % 10 ;
}
else {
conv [ 0 ] = ' ' ;
dig = ( xx / 1000 ) % 10 ;
conv [ 1 ] = dig ? ' 0 ' + dig : ' ' ;
}
}
conv [ 2 ] = ' 0 ' + ( xx / 100 ) % 10 ; // lsd always
dig = xx % 10 ;
if ( dig ) { // 2 decimal places
conv [ 5 ] = ' 0 ' + dig ;
2014-12-08 09:43:44 +00:00
conv [ 4 ] = ' 0 ' + ( xx / 10 ) % 10 ;
2014-12-08 09:43:44 +00:00
conv [ 3 ] = ' . ' ;
2014-12-07 04:59:06 +00:00
}
2014-12-08 09:43:44 +00:00
else { // 1 or 0 decimal place
dig = ( xx / 10 ) % 10 ;
if ( dig ) {
conv [ 4 ] = ' 0 ' + dig ;
conv [ 3 ] = ' . ' ;
}
else {
conv [ 3 ] = conv [ 4 ] = ' ' ;
}
conv [ 5 ] = ' ' ;
2014-12-07 04:59:06 +00:00
}
2014-12-08 09:43:44 +00:00
conv [ 6 ] = ' \0 ' ;
return conv ;
2014-12-07 04:59:06 +00:00
}
2015-03-30 23:39:47 +00:00
// Convert int to lj string with +123.0 format
char * itostr31 ( const int & x ) {
conv [ 0 ] = x > = 0 ? ' + ' : ' - ' ;
int xx = abs ( x ) ;
conv [ 1 ] = ( xx / 100 ) % 10 + ' 0 ' ;
conv [ 2 ] = ( xx / 10 ) % 10 + ' 0 ' ;
conv [ 3 ] = xx % 10 + ' 0 ' ;
conv [ 4 ] = ' . ' ;
conv [ 5 ] = ' 0 ' ;
conv [ 6 ] = 0 ;
2011-12-12 18:34:37 +00:00
return conv ;
}
2014-12-18 15:30:05 +00:00
// Convert int to rj string with 123 or -12 format
2015-03-30 23:39:47 +00:00
char * itostr3 ( const int & x ) {
2014-06-24 12:31:15 +00:00
int xx = x ;
if ( xx < 0 ) {
2015-03-30 23:39:47 +00:00
conv [ 0 ] = ' - ' ;
2014-06-24 12:31:15 +00:00
xx = - xx ;
2015-03-30 23:39:47 +00:00
}
2012-12-12 10:47:03 +00:00
else
2015-03-30 23:39:47 +00:00
conv [ 0 ] = xx > = 100 ? ( xx / 100 ) % 10 + ' 0 ' : ' ' ;
conv [ 1 ] = xx > = 10 ? ( xx / 10 ) % 10 + ' 0 ' : ' ' ;
conv [ 2 ] = xx % 10 + ' 0 ' ;
conv [ 3 ] = 0 ;
2011-12-12 18:34:37 +00:00
return conv ;
}
2014-12-28 06:26:14 +00:00
// Convert int to lj string with 123 format
2015-03-30 23:39:47 +00:00
char * itostr3left ( const int & xx ) {
if ( xx > = 100 ) {
conv [ 0 ] = ( xx / 100 ) % 10 + ' 0 ' ;
conv [ 1 ] = ( xx / 10 ) % 10 + ' 0 ' ;
conv [ 2 ] = xx % 10 + ' 0 ' ;
conv [ 3 ] = 0 ;
2012-12-12 10:47:03 +00:00
}
2015-03-30 23:39:47 +00:00
else if ( xx > = 10 ) {
conv [ 0 ] = ( xx / 10 ) % 10 + ' 0 ' ;
conv [ 1 ] = xx % 10 + ' 0 ' ;
conv [ 2 ] = 0 ;
2012-12-12 10:47:03 +00:00
}
2015-03-30 23:39:47 +00:00
else {
conv [ 0 ] = xx % 10 + ' 0 ' ;
conv [ 1 ] = 0 ;
2012-12-12 10:47:03 +00:00
}
return conv ;
}
2014-12-18 15:30:05 +00:00
// Convert int to rj string with 1234 format
char * itostr4 ( const int & xx ) {
conv [ 0 ] = xx > = 1000 ? ( xx / 1000 ) % 10 + ' 0 ' : ' ' ;
conv [ 1 ] = xx > = 100 ? ( xx / 100 ) % 10 + ' 0 ' : ' ' ;
conv [ 2 ] = xx > = 10 ? ( xx / 10 ) % 10 + ' 0 ' : ' ' ;
conv [ 3 ] = xx % 10 + ' 0 ' ;
conv [ 4 ] = 0 ;
2011-12-12 18:34:37 +00:00
return conv ;
}
2014-12-28 06:26:14 +00:00
// Convert float to rj string with 12345 format
2014-12-18 15:30:05 +00:00
char * ftostr5 ( const float & x ) {
long xx = abs ( x ) ;
conv [ 0 ] = xx > = 10000 ? ( xx / 10000 ) % 10 + ' 0 ' : ' ' ;
conv [ 1 ] = xx > = 1000 ? ( xx / 1000 ) % 10 + ' 0 ' : ' ' ;
conv [ 2 ] = xx > = 100 ? ( xx / 100 ) % 10 + ' 0 ' : ' ' ;
conv [ 3 ] = xx > = 10 ? ( xx / 10 ) % 10 + ' 0 ' : ' ' ;
conv [ 4 ] = xx % 10 + ' 0 ' ;
conv [ 5 ] = 0 ;
2012-12-12 10:47:03 +00:00
return conv ;
}
2014-12-28 06:26:14 +00:00
// Convert float to string with +1234.5 format
2015-03-30 23:39:47 +00:00
char * ftostr51 ( const float & x ) {
long xx = abs ( x * 10 ) ;
conv [ 0 ] = ( x > = 0 ) ? ' + ' : ' - ' ;
conv [ 1 ] = ( xx / 10000 ) % 10 + ' 0 ' ;
conv [ 2 ] = ( xx / 1000 ) % 10 + ' 0 ' ;
conv [ 3 ] = ( xx / 100 ) % 10 + ' 0 ' ;
conv [ 4 ] = ( xx / 10 ) % 10 + ' 0 ' ;
conv [ 5 ] = ' . ' ;
conv [ 6 ] = xx % 10 + ' 0 ' ;
conv [ 7 ] = 0 ;
2011-12-12 18:34:37 +00:00
return conv ;
}
2014-12-28 06:26:14 +00:00
// Convert float to string with +123.45 format
2015-03-30 23:39:47 +00:00
char * ftostr52 ( const float & x ) {
conv [ 0 ] = ( x > = 0 ) ? ' + ' : ' - ' ;
long xx = abs ( x * 100 ) ;
conv [ 1 ] = ( xx / 10000 ) % 10 + ' 0 ' ;
conv [ 2 ] = ( xx / 1000 ) % 10 + ' 0 ' ;
conv [ 3 ] = ( xx / 100 ) % 10 + ' 0 ' ;
conv [ 4 ] = ' . ' ;
conv [ 5 ] = ( xx / 10 ) % 10 + ' 0 ' ;
conv [ 6 ] = xx % 10 + ' 0 ' ;
conv [ 7 ] = 0 ;
2012-02-21 22:05:43 +00:00
return conv ;
}
2011-12-12 18:34:37 +00:00
2015-07-31 05:26:53 +00:00
# if ENABLED(MANUAL_BED_LEVELING)
2015-04-09 11:32:14 +00:00
static int _lcd_level_bed_position ;
2015-04-28 02:11:25 +00:00
/**
* MBL Wait for controller movement and clicks :
* - Movement adjusts the Z axis
* - Click saves the Z and goes to the next mesh point
*/
2015-04-09 11:32:14 +00:00
static void _lcd_level_bed ( ) {
if ( encoderPosition ! = 0 ) {
refresh_cmd_timeout ( ) ;
current_position [ Z_AXIS ] + = float ( ( int ) encoderPosition ) * MBL_Z_STEP ;
if ( min_software_endstops & & current_position [ Z_AXIS ] < Z_MIN_POS ) current_position [ Z_AXIS ] = Z_MIN_POS ;
if ( max_software_endstops & & current_position [ Z_AXIS ] > Z_MAX_POS ) current_position [ Z_AXIS ] = Z_MAX_POS ;
encoderPosition = 0 ;
2015-04-24 02:10:09 +00:00
line_to_current ( Z_AXIS ) ;
2015-04-13 01:07:08 +00:00
lcdDrawUpdate = 2 ;
2015-04-09 11:32:14 +00:00
}
if ( lcdDrawUpdate ) lcd_implementation_drawedit ( PSTR ( " Z " ) , ftostr43 ( current_position [ Z_AXIS ] ) ) ;
static bool debounce_click = false ;
if ( LCD_CLICKED ) {
if ( ! debounce_click ) {
debounce_click = true ;
2015-04-24 02:10:09 +00:00
int ix = _lcd_level_bed_position % MESH_NUM_X_POINTS ,
iy = _lcd_level_bed_position / MESH_NUM_X_POINTS ;
if ( iy & 1 ) ix = ( MESH_NUM_X_POINTS - 1 ) - ix ; // Zig zag
2015-04-09 11:32:14 +00:00
mbl . set_z ( ix , iy , current_position [ Z_AXIS ] ) ;
_lcd_level_bed_position + + ;
if ( _lcd_level_bed_position = = MESH_NUM_X_POINTS * MESH_NUM_Y_POINTS ) {
current_position [ Z_AXIS ] = MESH_HOME_SEARCH_Z ;
2015-04-24 02:10:09 +00:00
line_to_current ( Z_AXIS ) ;
2015-04-09 11:32:14 +00:00
mbl . active = 1 ;
2015-04-13 01:07:08 +00:00
enqueuecommands_P ( PSTR ( " G28 " ) ) ;
2015-04-09 11:32:14 +00:00
lcd_return_to_status ( ) ;
2015-04-24 02:10:09 +00:00
}
else {
2015-04-09 11:32:14 +00:00
current_position [ Z_AXIS ] = MESH_HOME_SEARCH_Z ;
2015-04-24 02:10:09 +00:00
line_to_current ( Z_AXIS ) ;
2015-04-09 11:32:14 +00:00
ix = _lcd_level_bed_position % MESH_NUM_X_POINTS ;
iy = _lcd_level_bed_position / MESH_NUM_X_POINTS ;
2015-04-24 02:10:09 +00:00
if ( iy & 1 ) ix = ( MESH_NUM_X_POINTS - 1 ) - ix ; // Zig zag
2015-04-09 11:32:14 +00:00
current_position [ X_AXIS ] = mbl . get_x ( ix ) ;
current_position [ Y_AXIS ] = mbl . get_y ( iy ) ;
2015-04-24 03:06:17 +00:00
line_to_current ( manual_feedrate [ X_AXIS ] < = manual_feedrate [ Y_AXIS ] ? X_AXIS : Y_AXIS ) ;
2015-04-13 01:07:08 +00:00
lcdDrawUpdate = 2 ;
2015-04-09 11:32:14 +00:00
}
2015-03-15 22:18:11 +00:00
}
2015-04-24 02:10:09 +00:00
}
else {
2015-04-09 11:32:14 +00:00
debounce_click = false ;
2015-03-15 22:18:11 +00:00
}
}
2015-04-09 11:32:14 +00:00
2015-04-28 02:11:25 +00:00
/**
* MBL Move to mesh starting point
*/
2015-04-09 11:32:14 +00:00
static void _lcd_level_bed_homing ( ) {
2015-04-13 01:07:08 +00:00
if ( lcdDrawUpdate ) lcd_implementation_drawedit ( PSTR ( " XYZ " ) , " Homing " ) ;
2015-04-24 02:10:09 +00:00
if ( axis_known_position [ X_AXIS ] & & axis_known_position [ Y_AXIS ] & & axis_known_position [ Z_AXIS ] ) {
2015-04-09 11:32:14 +00:00
current_position [ Z_AXIS ] = MESH_HOME_SEARCH_Z ;
plan_set_position ( current_position [ X_AXIS ] , current_position [ Y_AXIS ] , current_position [ Z_AXIS ] , current_position [ E_AXIS ] ) ;
current_position [ X_AXIS ] = MESH_MIN_X ;
current_position [ Y_AXIS ] = MESH_MIN_Y ;
2015-04-24 03:06:17 +00:00
line_to_current ( manual_feedrate [ X_AXIS ] < = manual_feedrate [ Y_AXIS ] ? X_AXIS : Y_AXIS ) ;
2015-04-09 11:32:14 +00:00
_lcd_level_bed_position = 0 ;
lcd_goto_menu ( _lcd_level_bed ) ;
}
2015-04-13 01:07:08 +00:00
lcdDrawUpdate = 2 ;
2015-03-15 22:18:11 +00:00
}
2015-04-09 11:32:14 +00:00
2015-04-28 02:11:25 +00:00
/**
* MBL entry - point
*/
2015-04-09 11:32:14 +00:00
static void lcd_level_bed ( ) {
2015-04-24 02:10:09 +00:00
axis_known_position [ X_AXIS ] = axis_known_position [ Y_AXIS ] = axis_known_position [ Z_AXIS ] = false ;
2015-04-09 11:32:14 +00:00
mbl . reset ( ) ;
2015-04-13 01:07:08 +00:00
enqueuecommands_P ( PSTR ( " G28 " ) ) ;
lcdDrawUpdate = 2 ;
2015-04-09 11:32:14 +00:00
lcd_goto_menu ( _lcd_level_bed_homing ) ;
}
2015-03-15 22:18:11 +00:00
# endif // MANUAL_BED_LEVELING
2015-04-09 11:32:14 +00:00
# endif // ULTRA_LCD