From 268d2634f0b1e3a6f6d34ff03fa969335600f681 Mon Sep 17 00:00:00 2001 From: Robert Pelnar Date: Mon, 16 Jul 2018 02:13:52 +0200 Subject: [PATCH] LCD menu optimalization - lcd and menu removed unused code and conditional translation --- Firmware/Configuration.h | 142 +- Firmware/ConfigurationStore.cpp | 25 +- Firmware/Configuration_adv.h | 9 +- Firmware/Firmware.ino | 22 +- Firmware/LiquidCrystal_Prusa.cpp | 5 +- Firmware/LiquidCrystal_Prusa.h | 2 +- Firmware/Marlin.h | 1 + Firmware/Marlin_main.cpp | 69 +- Firmware/cardreader.cpp | 1 + Firmware/lcd.cpp | 664 +++++++ Firmware/lcd.h | 240 +++ Firmware/menu.cpp | 270 +++ Firmware/menu.h | 99 + Firmware/pins_Einsy_1_0.h | 4 - Firmware/pins_Rambo_1_0.h | 4 - Firmware/pins_Rambo_1_3.h | 4 - Firmware/planner.cpp | 4 +- Firmware/stepper.cpp | 4 +- Firmware/temperature.cpp | 5 +- Firmware/ultralcd.cpp | 1677 ++++++++--------- Firmware/ultralcd.h | 77 +- .../ultralcd_implementation_hitachi_HD44780.h | 1361 ------------- Firmware/util.cpp | 2 +- .../variants/1_75mm_MK25-RAMBo10a-E3Dv6full.h | 1 - .../variants/1_75mm_MK25-RAMBo13a-E3Dv6full.h | 1 - .../variants/1_75mm_MK3-EINSy10a-E3Dv6full.h | 1 - 26 files changed, 2134 insertions(+), 2560 deletions(-) create mode 100644 Firmware/lcd.cpp create mode 100644 Firmware/lcd.h create mode 100644 Firmware/menu.cpp create mode 100644 Firmware/menu.h delete mode 100644 Firmware/ultralcd_implementation_hitachi_HD44780.h diff --git a/Firmware/Configuration.h b/Firmware/Configuration.h index a17b0e76..3ccaf590 100644 --- a/Firmware/Configuration.h +++ b/Firmware/Configuration.h @@ -621,154 +621,18 @@ your extruder heater takes 2 minutes to hit the target on heating. #define HOST_KEEPALIVE_INTERVAL 2 // Number of seconds between "busy" messages. Set with M113. //LCD and SD support -#define ULTRA_LCD //general LCD support, also 16x2 #define SDSUPPORT // Enable SD Card Support in Hardware Console //#define SDSLOW // Use slower SD transfer mode (not normally needed - uncomment if you're getting volume init error) #define SD_CHECK_AND_RETRY // Use CRC checks and retries on the SD communication #define ENCODER_PULSES_PER_STEP 4 // Increase if you have a high resolution encoder //#define ENCODER_STEPS_PER_MENU_ITEM 1 // Set according to ENCODER_PULSES_PER_STEP or your liking -//#define ULTIMAKERCONTROLLER //as available from the Ultimaker online store. -//#define ULTIPANEL //the UltiPanel as on Thingiverse -//#define LCD_FEEDBACK_FREQUENCY_HZ 1000 // this is the tone frequency the buzzer plays when on UI feedback. ie Screen Click -//#define LCD_FEEDBACK_FREQUENCY_DURATION_MS 100 // the duration the buzzer plays the UI feedback sound. ie Screen Click - -// The MaKr3d Makr-Panel with graphic controller and SD support -// http://reprap.org/wiki/MaKr3d_MaKrPanel -//#define MAKRPANEL // The RepRapDiscount Smart Controller (white PCB) // http://reprap.org/wiki/RepRapDiscount_Smart_Controller #define REPRAP_DISCOUNT_SMART_CONTROLLER - -// The GADGETS3D G3D LCD/SD Controller (blue PCB) -// http://reprap.org/wiki/RAMPS_1.3/1.4_GADGETS3D_Shield_with_Panel -//#define G3D_PANEL - -// The RepRapWorld REPRAPWORLD_KEYPAD v1.1 -// http://reprapworld.com/?products_details&products_id=202&cPath=1591_1626 -//#define REPRAPWORLD_KEYPAD -//#define REPRAPWORLD_KEYPAD_MOVE_STEP 10.0 // how much should be moved when a key is pressed, eg 10.0 means 10mm per click - -// The Elefu RA Board Control Panel -// http://www.elefu.com/index.php?route=product/product&product_id=53 -// REMEMBER TO INSTALL LiquidCrystal_I2C.h in your ARDUINO library folder: https://github.com/kiyoshigawa/LiquidCrystal_I2C -//#define RA_CONTROL_PANEL - -//automatic expansion -#if defined (MAKRPANEL) - #define SDSUPPORT - #define ULTIPANEL - #define NEWPANEL - #define DEFAULT_LCD_CONTRAST 17 -#endif - -#if defined(ULTIMAKERCONTROLLER) || defined(REPRAP_DISCOUNT_SMART_CONTROLLER) || defined(G3D_PANEL) - #define ULTIPANEL - #define NEWPANEL -#endif - -#if defined(REPRAPWORLD_KEYPAD) - #define NEWPANEL - #define ULTIPANEL -#endif -#if defined(RA_CONTROL_PANEL) - #define ULTIPANEL - #define NEWPANEL - #define LCD_I2C_TYPE_PCA8574 - #define LCD_I2C_ADDRESS 0x27 // I2C Address of the port expander -#endif - -//I2C PANELS - -//#define LCD_I2C_SAINSMART_YWROBOT -#ifdef LCD_I2C_SAINSMART_YWROBOT - // This uses the LiquidCrystal_I2C library ( https://bitbucket.org/fmalpartida/new-LiquidCrystal_Prusa/wiki/Home ) - // Make sure it is placed in the Arduino libraries directory. - #define LCD_I2C_TYPE_PCF8575 - #define LCD_I2C_ADDRESS 0x27 // I2C Address of the port expander - #define NEWPANEL - #define ULTIPANEL -#endif - -// PANELOLU2 LCD with status LEDs, separate encoder and click inputs -//#define LCD_I2C_PANELOLU2 -#ifdef LCD_I2C_PANELOLU2 - // This uses the LiquidTWI2 library v1.2.3 or later ( https://github.com/lincomatic/LiquidTWI2 ) - // Make sure the LiquidTWI2 directory is placed in the Arduino or Sketchbook libraries subdirectory. - // (v1.2.3 no longer requires you to define PANELOLU in the LiquidTWI2.h library header file) - // Note: The PANELOLU2 encoder click input can either be directly connected to a pin - // (if BTN_ENC defined to != -1) or read through I2C (when BTN_ENC == -1). - #define LCD_I2C_TYPE_MCP23017 - #define LCD_I2C_ADDRESS 0x20 // I2C Address of the port expander - #define LCD_USE_I2C_BUZZER //comment out to disable buzzer on LCD - #define NEWPANEL - #define ULTIPANEL - - #ifndef ENCODER_PULSES_PER_STEP - #define ENCODER_PULSES_PER_STEP 4 - #endif - - #ifndef ENCODER_STEPS_PER_MENU_ITEM - #define ENCODER_STEPS_PER_MENU_ITEM 2 - #endif - - - #ifdef LCD_USE_I2C_BUZZER - #define LCD_FEEDBACK_FREQUENCY_HZ 1000 - #define LCD_FEEDBACK_FREQUENCY_DURATION_MS 100 - #endif - -#endif - -// Panucatt VIKI LCD with status LEDs, integrated click & L/R/U/P buttons, separate encoder inputs -//#define LCD_I2C_VIKI -#ifdef LCD_I2C_VIKI - // This uses the LiquidTWI2 library v1.2.3 or later ( https://github.com/lincomatic/LiquidTWI2 ) - // Make sure the LiquidTWI2 directory is placed in the Arduino or Sketchbook libraries subdirectory. - // Note: The pause/stop/resume LCD button pin should be connected to the Arduino - // BTN_ENC pin (or set BTN_ENC to -1 if not used) - #define LCD_I2C_TYPE_MCP23017 - #define LCD_I2C_ADDRESS 0x20 // I2C Address of the port expander - #define LCD_USE_I2C_BUZZER //comment out to disable buzzer on LCD (requires LiquidTWI2 v1.2.3 or later) - #define NEWPANEL - #define ULTIPANEL -#endif - -// Shift register panels -// --------------------- -// 2 wire Non-latching LCD SR from: -// https://bitbucket.org/fmalpartida/new-LiquidCrystal_Prusa/wiki/schematics#!shiftregister-connection - -//#define SAV_3DLCD -#ifdef SAV_3DLCD - #define SR_LCD_2W_NL // Non latching 2 wire shiftregister - #define NEWPANEL - #define ULTIPANEL -#endif - - -#ifdef ULTIPANEL -// #define NEWPANEL //enable this if you have a click-encoder panel - #define SDSUPPORT - #define ULTRA_LCD - #ifdef DOGLCD // Change number of lines to match the DOG graphic display - #define LCD_WIDTH 20 - #define LCD_HEIGHT 5 - #else - #define LCD_WIDTH 20 - #define LCD_HEIGHT 4 - #endif -#else //no panel but just LCD - #ifdef ULTRA_LCD - #ifdef DOGLCD // Change number of lines to match the 128x64 graphics display - #define LCD_WIDTH 20 - #define LCD_HEIGHT 5 - #else - #define LCD_WIDTH 16 - #define LCD_HEIGHT 2 - #endif - #endif -#endif +#define SDSUPPORT +#define LCD_WIDTH 20 +#define LCD_HEIGHT 4 // Increase the FAN pwm frequency. Removes the PWM noise but increases heating in the FET/Arduino diff --git a/Firmware/ConfigurationStore.cpp b/Firmware/ConfigurationStore.cpp index a48c3934..89312ab9 100644 --- a/Firmware/ConfigurationStore.cpp +++ b/Firmware/ConfigurationStore.cpp @@ -68,13 +68,6 @@ void Config_StoreSettings(uint16_t offset, uint8_t level) EEPROM_WRITE_VAR(i,max_jerk[Z_AXIS]); EEPROM_WRITE_VAR(i,max_jerk[E_AXIS]); EEPROM_WRITE_VAR(i,add_homing); - #ifndef ULTIPANEL - int plaPreheatHotendTemp = PLA_PREHEAT_HOTEND_TEMP, plaPreheatHPBTemp = PLA_PREHEAT_HPB_TEMP, plaPreheatFanSpeed = PLA_PREHEAT_FAN_SPEED; - int absPreheatHotendTemp = ABS_PREHEAT_HOTEND_TEMP, absPreheatHPBTemp = ABS_PREHEAT_HPB_TEMP, absPreheatFanSpeed = ABS_PREHEAT_FAN_SPEED; - - - - #endif /* EEPROM_WRITE_VAR(i,plaPreheatHotendTemp); EEPROM_WRITE_VAR(i,plaPreheatHPBTemp); EEPROM_WRITE_VAR(i,plaPreheatFanSpeed); @@ -100,10 +93,7 @@ void Config_StoreSettings(uint16_t offset, uint8_t level) EEPROM_WRITE_VAR(i, bedKi); EEPROM_WRITE_VAR(i, bedKd); #endif - #ifndef DOGLCD - int lcd_contrast = 32; - #endif - EEPROM_WRITE_VAR(i,lcd_contrast); +// EEPROM_WRITE_VAR(i,lcd_contrast); #ifdef FWRETRACT EEPROM_WRITE_VAR(i,autoretract_enabled); EEPROM_WRITE_VAR(i,retract_length); @@ -247,11 +237,6 @@ bool Config_RetrieveSettings(uint16_t offset, uint8_t level) if (max_jerk[X_AXIS] > DEFAULT_XJERK) max_jerk[X_AXIS] = DEFAULT_XJERK; if (max_jerk[Y_AXIS] > DEFAULT_YJERK) max_jerk[Y_AXIS] = DEFAULT_YJERK; EEPROM_READ_VAR(i,add_homing); - #ifndef ULTIPANEL - int plaPreheatHotendTemp, plaPreheatHPBTemp, plaPreheatFanSpeed; - int absPreheatHotendTemp, absPreheatHPBTemp, absPreheatFanSpeed; - - #endif /* EEPROM_READ_VAR(i,plaPreheatHotendTemp); EEPROM_READ_VAR(i,plaPreheatHPBTemp); @@ -275,10 +260,7 @@ bool Config_RetrieveSettings(uint16_t offset, uint8_t level) EEPROM_READ_VAR(i, bedKi); EEPROM_READ_VAR(i, bedKd); #endif - #ifndef DOGLCD - int lcd_contrast; - #endif - EEPROM_READ_VAR(i,lcd_contrast); +// EEPROM_READ_VAR(i,lcd_contrast); #ifdef FWRETRACT EEPROM_READ_VAR(i,autoretract_enabled); @@ -363,9 +345,6 @@ void Config_ResetDefault() #ifdef ENABLE_AUTO_BED_LEVELING zprobe_zoffset = -Z_PROBE_OFFSET_FROM_EXTRUDER; #endif -#ifdef DOGLCD - lcd_contrast = DEFAULT_LCD_CONTRAST; -#endif #ifdef PIDTEMP Kp = DEFAULT_Kp; Ki = scalePID_i(DEFAULT_Ki); diff --git a/Firmware/Configuration_adv.h b/Firmware/Configuration_adv.h index 4f3e3894..95130287 100644 --- a/Firmware/Configuration_adv.h +++ b/Firmware/Configuration_adv.h @@ -178,9 +178,7 @@ //Comment to disable setting feedrate multiplier via encoder -#ifdef ULTIPANEL - #define ULTIPANEL_FEEDMULTIPLY -#endif +#define ULTIPANEL_FEEDMULTIPLY // minimum time in microseconds that a movement needs to take if the buffer is emptied. #define DEFAULT_MINSEGMENTTIME 20000 @@ -328,10 +326,7 @@ const unsigned int dropsegments=5; //everything with less than this number of st // in the pins.h file. When using a push button pulling the pin to ground this will need inverted. This setting should // be commented out otherwise #define SDCARDDETECTINVERTED - -#ifdef ULTIPANEL - #undef SDCARDDETECTINVERTED -#endif +#undef SDCARDDETECTINVERTED // Power Signal Control Definitions // By default use ATX definition diff --git a/Firmware/Firmware.ino b/Firmware/Firmware.ino index 555f5f0a..af7c11c1 100644 --- a/Firmware/Firmware.ino +++ b/Firmware/Firmware.ino @@ -33,24 +33,4 @@ #include "Configuration.h" #include "pins.h" -#ifdef ULTRA_LCD - #if defined(LCD_I2C_TYPE_PCF8575) - #include - #include - #elif defined(LCD_I2C_TYPE_MCP23017) || defined(LCD_I2C_TYPE_MCP23008) - #include - #include - #elif defined(DOGLCD) - #include // library for graphics LCD by Oli Kraus (https://code.google.com/p/u8glib/) - #else - #include "LiquidCrystal_Prusa.h" // library for character LCD - #endif -#endif - -#if defined(DIGIPOTSS_PIN) && DIGIPOTSS_PIN > -1 -#include -#endif - -#if defined(DIGIPOT_I2C) - #include -#endif +#include "LiquidCrystal_Prusa.h" // library for character LCD diff --git a/Firmware/LiquidCrystal_Prusa.cpp b/Firmware/LiquidCrystal_Prusa.cpp index e06f8fa2..92f66634 100644 --- a/Firmware/LiquidCrystal_Prusa.cpp +++ b/Firmware/LiquidCrystal_Prusa.cpp @@ -341,11 +341,12 @@ void LiquidCrystal_Prusa::noAutoscroll(void) { // Allows us to fill the first 8 CGRAM locations // with custom characters -void LiquidCrystal_Prusa::createChar(uint8_t location, uint8_t charmap[]) { +void LiquidCrystal_Prusa::createChar_P(uint8_t location, const uint8_t* charmap) +{ location &= 0x7; // we only have 8 locations 0-7 command(LCD_SETCGRAMADDR | (location << 3)); for (int i=0; i<8; i++) - send(charmap[i], HIGH); + send(pgm_read_byte(&charmap[i]), HIGH); } /*********** mid level commands, for sending data/cmds */ diff --git a/Firmware/LiquidCrystal_Prusa.h b/Firmware/LiquidCrystal_Prusa.h index 77acaa91..3d5aa82e 100644 --- a/Firmware/LiquidCrystal_Prusa.h +++ b/Firmware/LiquidCrystal_Prusa.h @@ -80,7 +80,7 @@ public: void autoscroll(); void noAutoscroll(); - void createChar(uint8_t, uint8_t[]); + void createChar_P(uint8_t, const uint8_t*); void setCursor(uint8_t, uint8_t); // virtual size_t write(uint8_t); size_t write(uint8_t); diff --git a/Firmware/Marlin.h b/Firmware/Marlin.h index 35cce09f..ec8535f9 100644 --- a/Firmware/Marlin.h +++ b/Firmware/Marlin.h @@ -64,6 +64,7 @@ extern FILE _lcdout; #define lcdout (&_lcdout) +#include "lcd.h" extern FILE _uartout; #define uartout (&_uartout) diff --git a/Firmware/Marlin_main.cpp b/Firmware/Marlin_main.cpp index 5371e0b1..e5a232a7 100644 --- a/Firmware/Marlin_main.cpp +++ b/Firmware/Marlin_main.cpp @@ -58,8 +58,11 @@ #endif #include "printers.h" + +#include "lcd.h" +#include "menu.h" #include "ultralcd.h" -#include "Configuration_prusa.h" + #include "planner.h" #include "stepper.h" #include "temperature.h" @@ -167,7 +170,7 @@ // G92 - Set current position to coordinates given // M Codes -// M0 - Unconditional stop - Wait for user to press a button on the LCD (Only if ULTRA_LCD is enabled) +// M0 - Unconditional stop - Wait for user to press a button on the LCD // M1 - Same as M0 // M17 - Enable/Power all stepper motors // M18 - Disable all stepper motors; same as M84 @@ -431,13 +434,11 @@ int fanSpeed=0; float retract_recover_feedrate = RETRACT_RECOVER_FEEDRATE; #endif -#ifdef ULTIPANEL #ifdef PS_DEFAULT_OFF bool powersupply = false; #else bool powersupply = true; #endif -#endif bool cancel_heatup = false ; @@ -2022,7 +2023,7 @@ void loop() manage_heater(); isPrintPaused ? manage_inactivity(true) : manage_inactivity(false); checkHitEndstops(); - lcd_update(); + lcd_update(0); #ifdef PAT9125 fsensor_update(); #endif //PAT9125 @@ -3487,7 +3488,7 @@ void process_commands() cnt++; manage_heater(); manage_inactivity(true); - //lcd_update(); + //lcd_update(0); if(cnt==0) { #if BEEPER > 0 @@ -3512,11 +3513,6 @@ void process_commands() counterBeep++; #else - #if !defined(LCD_FEEDBACK_FREQUENCY_HZ) || !defined(LCD_FEEDBACK_FREQUENCY_DURATION_MS) - lcd_buzz(1000/6,100); - #else - lcd_buzz(LCD_FEEDBACK_FREQUENCY_DURATION_MS,LCD_FEEDBACK_FREQUENCY_HZ); - #endif #endif } } @@ -3653,7 +3649,7 @@ void process_commands() while(millis() < codenum) { manage_heater(); manage_inactivity(); - lcd_update(); + lcd_update(0); } break; #ifdef FWRETRACT @@ -4663,7 +4659,6 @@ void process_commands() } else switch((int)code_value()) { -#ifdef ULTIPANEL case 0: // M0 - Unconditional stop - Wait for user button press on LCD case 1: // M1 - Conditional stop - Wait for user button press on LCD @@ -4699,18 +4694,16 @@ void process_commands() while(millis() < codenum && !lcd_clicked()){ manage_heater(); manage_inactivity(true); - lcd_update(); + lcd_update(0); } KEEPALIVE_STATE(IN_HANDLER); lcd_ignore_click(false); }else{ - if (!lcd_detected()) - break; KEEPALIVE_STATE(PAUSED_FOR_USER); while(!lcd_clicked()){ manage_heater(); manage_inactivity(true); - lcd_update(); + lcd_update(0); } KEEPALIVE_STATE(IN_HANDLER); } @@ -4720,7 +4713,6 @@ void process_commands() LCD_MESSAGERPGM(_T(WELCOME_MSG)); } break; -#endif case 17: LCD_MESSAGERPGM(_i("No move."));////MSG_NO_MOVE c=0 r=0 enable_x(); @@ -5442,7 +5434,7 @@ Sigma_Exit: } manage_heater(); manage_inactivity(); - lcd_update(); + lcd_update(0); } LCD_MESSAGERPGM(_T(MSG_BED_DONE)); KEEPALIVE_STATE(IN_HANDLER); @@ -5479,11 +5471,9 @@ Sigma_Exit: WRITE(SUICIDE_PIN, HIGH); #endif - #ifdef ULTIPANEL powersupply = true; LCD_MESSAGERPGM(_T(WELCOME_MSG)); - lcd_update(); - #endif + lcd_update(0); break; #endif @@ -5503,11 +5493,9 @@ Sigma_Exit: SET_OUTPUT(PS_ON_PIN); WRITE(PS_ON_PIN, PS_ON_ASLEEP); #endif - #ifdef ULTIPANEL powersupply = false; LCD_MESSAGERPGM(CAT4(CUSTOM_MENDEL_NAME,PSTR(" "),MSG_OFF,PSTR("."))); - lcd_update(); - #endif + lcd_update(0); break; case 82: @@ -5967,7 +5955,7 @@ Sigma_Exit: while(digitalRead(pin_number) != target){ manage_heater(); manage_inactivity(); - lcd_update(); + lcd_update(0); } } } @@ -6025,10 +6013,6 @@ Sigma_Exit: tone(BEEPER, beepS); delay(beepP); noTone(BEEPER); - #elif defined(ULTRALCD) - lcd_buzz(beepS, beepP); - #elif defined(LCD_USE_I2C_BUZZER) - lcd_buzz(beepP, beepS); #endif } else @@ -6117,18 +6101,6 @@ Sigma_Exit: #endif //chdk end if } break; -#ifdef DOGLCD - case 250: // M250 Set LCD contrast value: C (value 0..63) - { - if (code_seen('C')) { - lcd_setcontrast( ((int)code_value())&63 ); - } - SERIAL_PROTOCOLPGM("lcd contrast value: "); - SERIAL_PROTOCOL(lcd_contrast); - SERIAL_PROTOCOLLN(""); - } - break; -#endif #ifdef PREVENT_DANGEROUS_EXTRUDE case 302: // allow cold extrudes, or set the minimum extrude temperature { @@ -6355,11 +6327,6 @@ Sigma_Exit: counterBeep++; #else -#if !defined(LCD_FEEDBACK_FREQUENCY_HZ) || !defined(LCD_FEEDBACK_FREQUENCY_DURATION_MS) - lcd_buzz(1000 / 6, 100); -#else - lcd_buzz(LCD_FEEDBACK_FREQUENCY_DURATION_MS, LCD_FEEDBACK_FREQUENCY_HZ); -#endif #endif } @@ -6757,7 +6724,7 @@ Sigma_Exit: } manage_heater(); manage_inactivity(); - lcd_update(); + lcd_update(0); } LCD_MESSAGERPGM(_T(MSG_OK)); @@ -7778,7 +7745,7 @@ void kill(const char *full_screen_message, unsigned char id) // FMC small patch to update the LCD before ending sei(); // enable interrupts - for ( int i=5; i--; lcd_update()) + for ( int i=5; i--; lcd_update(0)) { delay(200); } @@ -7953,7 +7920,7 @@ void delay_keep_alive(unsigned int ms) manage_heater(); // Manage inactivity, but don't disable steppers on timeout. manage_inactivity(true); - lcd_update(); + lcd_update(0); if (ms == 0) break; else if (ms >= 50) { @@ -8005,7 +7972,7 @@ void wait_for_heater(long codenum) { } manage_heater(); manage_inactivity(); - lcd_update(); + lcd_update(0); #ifdef TEMP_RESIDENCY_TIME /* start/restart the TEMP_RESIDENCY_TIME timer whenever we reach target temp for the first time or when current temp falls outside the hysteresis after target temp was reached */ diff --git a/Firmware/cardreader.cpp b/Firmware/cardreader.cpp index 124ca2e0..3080e475 100644 --- a/Firmware/cardreader.cpp +++ b/Firmware/cardreader.cpp @@ -4,6 +4,7 @@ #include "stepper.h" #include "temperature.h" #include "language.h" +#include "lcd.h" #ifdef SDSUPPORT diff --git a/Firmware/lcd.cpp b/Firmware/lcd.cpp new file mode 100644 index 00000000..fab6de3a --- /dev/null +++ b/Firmware/lcd.cpp @@ -0,0 +1,664 @@ +//menu.cpp + +#include "lcd.h" +#include +#include +#include +#include "Timer.h" + +extern FILE _lcdout; +#define lcdout (&_lcdout) + +uint8_t lcd_draw_update = 2; +int32_t lcd_encoder = 0; +uint8_t lcd_encoder_bits = 0; +int8_t lcd_encoder_diff = 0; + +uint8_t lcd_buttons = 0; +uint8_t lcd_button_pressed = 0; +uint8_t lcd_update_enabled = 1; +uint32_t lcd_timeoutToStatus = 0; + +uint32_t lcd_next_update_millis = 0; +uint8_t lcd_status_update_delay = 0; + +uint8_t lcd_long_press_active = 0; + +lcd_longpress_func_t lcd_longpress_func = 0; + +lcd_charsetup_func_t lcd_charsetup_func = 0; + +lcd_lcdupdate_func_t lcd_lcdupdate_func = 0; + +uint32_t lcd_button_blanking_time = millis(); +ShortTimer longPressTimer; + + +uint8_t lcd_clicked(void) +{ + bool clicked = LCD_CLICKED; + if(clicked) lcd_button_pressed = 1; + return clicked; +} + +void lcd_set_cursor(uint8_t c, uint8_t r) +{ + lcd_printf_P(PSTR("\x1b[%hhu;%hhuH"), r, c); +} + +void lcd_implementation_quick_feedback(void) +{ + SET_OUTPUT(BEEPER); + for(int8_t i = 0; i < 10; i++) + { + WRITE(BEEPER,HIGH); + delayMicroseconds(100); + WRITE(BEEPER,LOW); + delayMicroseconds(100); + } +} + +void lcd_quick_feedback(void) +{ + lcd_draw_update = 2; + lcd_button_pressed = false; + lcd_implementation_quick_feedback(); +} + +int lcd_puts_P(const char* str) +{ + return fputs_P(str, lcdout); +} + +int lcd_putc(int c) +{ + return fputc(c, lcdout); +} + +int lcd_printf_P(const char* format, ...) +{ + va_list args; + va_start(args, format); + int ret = vfprintf_P(lcdout, format, args); + va_end(args); + return ret; +} + + + + + + + + + + +void lcd_update(uint8_t lcdDrawUpdateOverride) +{ + if (lcd_draw_update < lcdDrawUpdateOverride) + lcd_draw_update = lcdDrawUpdateOverride; + if (!lcd_update_enabled) + return; + lcd_buttons_update(); + if (lcd_lcdupdate_func) + lcd_lcdupdate_func(); +} + +void lcd_update_enable(uint8_t enabled) +{ + if (lcd_update_enabled != enabled) + { + lcd_update_enabled = enabled; + if (enabled) + { // Reset encoder position. This is equivalent to re-entering a menu. + lcd_encoder = 0; + lcd_encoder_diff = 0; + // Enabling the normal LCD update procedure. + // Reset the timeout interval. + lcd_timeoutToStatus = millis() + LCD_TIMEOUT_TO_STATUS; + // Force the keypad update now. + lcd_next_update_millis = millis() - 1; + // Full update. + lcd_implementation_clear(); + if (lcd_charsetup_func) + lcd_charsetup_func(); + lcd_update(2); + } else + { + // Clear the LCD always, or let it to the caller? + } + } +} + +void lcd_buttons_update(void) +{ + static bool _lock = false; + if (_lock) return; + _lock = true; + uint8_t newbutton = 0; + if (READ(BTN_EN1) == 0) newbutton |= EN_A; + if (READ(BTN_EN2) == 0) newbutton |= EN_B; + if (lcd_update_enabled) + { //if we are in non-modal mode, long press can be used and short press triggers with button release + if (READ(BTN_ENC) == 0) + { //button is pressed + lcd_timeoutToStatus = millis() + LCD_TIMEOUT_TO_STATUS; + if (millis() > lcd_button_blanking_time) + { + lcd_button_blanking_time = millis() + BUTTON_BLANKING_TIME; + if ((lcd_button_pressed == 0) && (lcd_long_press_active == 0)) + { + longPressTimer.start(); + lcd_button_pressed = 1; + } + else + { + if (longPressTimer.expired(LONG_PRESS_TIME)) + { + lcd_long_press_active = 1; + if (lcd_longpress_func) + lcd_longpress_func(); + } + } + } + } + else + { //button not pressed + if (lcd_button_pressed) + { //button was released + lcd_button_blanking_time = millis() + BUTTON_BLANKING_TIME; + if (lcd_long_press_active == 0) + { //button released before long press gets activated + newbutton |= EN_C; + } + //else if (menu_menu == lcd_move_z) lcd_quick_feedback(); + //lcd_button_pressed is set back to false via lcd_quick_feedback function + } + else + lcd_long_press_active = 0; + } + } + else + { //we are in modal mode + if (READ(BTN_ENC) == 0) + newbutton |= EN_C; + } + + lcd_buttons = newbutton; + //manage encoder rotation + uint8_t enc = 0; + if (lcd_buttons & EN_A) enc |= B01; + if (lcd_buttons & EN_B) enc |= B10; + if (enc != lcd_encoder_bits) + { + switch (enc) + { + case encrot0: + if (lcd_encoder_bits == encrot3) + lcd_encoder_diff++; + else if (lcd_encoder_bits == encrot1) + lcd_encoder_diff--; + break; + case encrot1: + if (lcd_encoder_bits == encrot0) + lcd_encoder_diff++; + else if (lcd_encoder_bits == encrot2) + lcd_encoder_diff--; + break; + case encrot2: + if (lcd_encoder_bits == encrot1) + lcd_encoder_diff++; + else if (lcd_encoder_bits == encrot3) + lcd_encoder_diff--; + break; + case encrot3: + if (lcd_encoder_bits == encrot2) + lcd_encoder_diff++; + else if (lcd_encoder_bits == encrot0) + lcd_encoder_diff--; + break; + } + } + lcd_encoder_bits = enc; + _lock = false; +} + + + + + + +LCD_CLASS lcd(LCD_PINS_RS, LCD_PINS_ENABLE, LCD_PINS_D4, LCD_PINS_D5,LCD_PINS_D6,LCD_PINS_D7); //RS,Enable,D4,D5,D6,D7 + + +void lcd_implementation_init(void) +{ + lcd.begin(LCD_WIDTH, LCD_HEIGHT); + lcd_set_custom_characters(); + lcd.clear(); +} + + +void lcd_implementation_init_noclear(void) +{ + lcd.begin_noclear(LCD_WIDTH, LCD_HEIGHT); + lcd_set_custom_characters(); +} + + +void lcd_implementation_nodisplay(void) +{ + lcd.noDisplay(); +} +void lcd_implementation_display(void) +{ + lcd.display(); +} + +void lcd_implementation_clear(void) +{ + lcd.clear(); +} +/* Arduino < 1.0.0 is missing a function to print PROGMEM strings, so we need to implement our own */ +void lcd_printPGM(const char* str) +{ + char c; + while((c = pgm_read_byte(str++)) != '\0') + { + lcd.write(c); + } +} + +void lcd_print_at_PGM(uint8_t x, uint8_t y, const char* str) +{ + lcd.setCursor(x, y); + char c; + while((c = pgm_read_byte(str++)) != '\0') + { + lcd.write(c); + } +} + +void lcd_implementation_write(char c) +{ + lcd.write(c); +} + +void lcd_implementation_print(int8_t i) +{ + lcd.print(i); +} + +void lcd_implementation_print_at(uint8_t x, uint8_t y, int8_t i) +{ + lcd.setCursor(x, y); + lcd.print(i); +} + +void lcd_implementation_print(int i) +{ + lcd.print(i); +} + +void lcd_implementation_print_at(uint8_t x, uint8_t y, int i) +{ + lcd.setCursor(x, y); + lcd.print(i); +} + +void lcd_implementation_print(float f) +{ + lcd.print(f); +} + +void lcd_implementation_print(const char *str) +{ + lcd.print(str); +} + +void lcd_implementation_print_at(uint8_t x, uint8_t y, const char *str) +{ + lcd.setCursor(x, y); + lcd.print(str); +} + + + + + + + + + + + + + + + + + + +void lcd_implementation_drawmenu_generic(uint8_t row, const char* pstr, char pre_char, char post_char) +{ + char c; + //Use all characters in narrow LCDs + #if LCD_WIDTH < 20 + uint8_t n = LCD_WIDTH - 1 - 1; + #else + uint8_t n = LCD_WIDTH - 1 - 2; + #endif + lcd.setCursor(0, row); + lcd.print(pre_char); + while( ((c = pgm_read_byte(pstr)) != '\0') && (n>0) ) + { + lcd.print(c); + pstr++; + n--; + } + while(n--) + lcd.print(' '); + lcd.print(post_char); + lcd.print(' '); +} + +void lcd_implementation_drawmenu_generic_RAM(uint8_t row, const char* str, char pre_char, char post_char) +{ + char c; + //Use all characters in narrow LCDs + #if LCD_WIDTH < 20 + uint8_t n = LCD_WIDTH - 1 - 1; + #else + uint8_t n = LCD_WIDTH - 1 - 2; + #endif + lcd.setCursor(0, row); + lcd.print(pre_char); + while( ((c = *str) != '\0') && (n>0) ) + { + lcd.print(c); + str++; + n--; + } + while(n--) + lcd.print(' '); + lcd.print(post_char); + lcd.print(' '); +} + +void lcd_implementation_drawmenu_setting_edit_generic(uint8_t row, const char* pstr, char pre_char, char* data) +{ + char c; + //Use all characters in narrow LCDs + #if LCD_WIDTH < 20 + uint8_t n = LCD_WIDTH - 1 - 1 - strlen(data); + #else + uint8_t n = LCD_WIDTH - 1 - 2 - strlen(data); + #endif + lcd.setCursor(0, row); + lcd.print(pre_char); + while( ((c = pgm_read_byte(pstr)) != '\0') && (n>0) ) + { + lcd.print(c); + pstr++; + n--; + } + lcd.print(':'); + while(n--) + lcd.print(' '); + lcd.print(data); +} +void lcd_implementation_drawmenu_setting_edit_generic_P(uint8_t row, const char* pstr, char pre_char, const char* data) +{ + char c; + //Use all characters in narrow LCDs + #if LCD_WIDTH < 20 + uint8_t n = LCD_WIDTH - 1 - 1 - strlen_P(data); + #else + uint8_t n = LCD_WIDTH - 1 - 2 - strlen_P(data); + #endif + lcd.setCursor(0, row); + lcd.print(pre_char); + while( ((c = pgm_read_byte(pstr)) != '\0') && (n>0) ) + { + lcd.print(c); + pstr++; + n--; + } + lcd.print(':'); + while(n--) + lcd.print(' '); + lcd_printPGM(data); +} + + + + + + +void lcd_implementation_drawedit(const char* pstr, char* value) +{ + lcd.setCursor(1, 1); + lcd_printPGM(pstr); + lcd.print(':'); + #if LCD_WIDTH < 20 + lcd.setCursor(LCD_WIDTH - strlen(value), 1); + #else + lcd.setCursor(LCD_WIDTH -1 - strlen(value), 1); + #endif + lcd.print(value); +} + +void lcd_implementation_drawedit_2(const char* pstr, char* value) +{ + lcd.setCursor(0, 1); + lcd_printPGM(pstr); + lcd.print(':'); + + lcd.setCursor((LCD_WIDTH - strlen(value))/2, 3); + + lcd.print(value); + lcd.print(" mm"); +} + + + + +//////////////////////////////////////////////////////////////////////////////// +// Custom character data + +const uint8_t lcd_chardata_bedTemp[8] PROGMEM = { + B00000, + B11111, + B10101, + B10001, + B10101, + B11111, + B00000, + B00000}; //thanks Sonny Mounicou + +const uint8_t lcd_chardata_degree[8] PROGMEM = { + B01100, + B10010, + B10010, + B01100, + B00000, + B00000, + B00000, + B00000}; + +const uint8_t lcd_chardata_thermometer[8] PROGMEM = { + B00100, + B01010, + B01010, + B01010, + B01010, + B10001, + B10001, + B01110}; + +const uint8_t lcd_chardata_uplevel[8] PROGMEM = { + B00100, + B01110, + B11111, + B00100, + B11100, + B00000, + B00000, + B00000}; //thanks joris + +const uint8_t lcd_chardata_refresh[8] PROGMEM = { + B00000, + B00110, + B11001, + B11000, + B00011, + B10011, + B01100, + B00000}; //thanks joris + +const uint8_t lcd_chardata_folder[8] PROGMEM = { + B00000, + B11100, + B11111, + B10001, + B10001, + B11111, + B00000, + B00000}; //thanks joris + +const uint8_t lcd_chardata_feedrate[8] PROGMEM = { + B11100, + B10000, + B11000, + B10111, + B00101, + B00110, + B00101, + B00000}; //thanks Sonny Mounicou + +/*const uint8_t lcd_chardata_feedrate[8] PROGMEM = { + B11100, + B10100, + B11000, + B10100, + B00000, + B00111, + B00010, + B00010};*/ + +/*const uint8_t lcd_chardata_feedrate[8] PROGMEM = { + B01100, + B10011, + B00000, + B01100, + B10011, + B00000, + B01100, + B10011};*/ + +/*const uint8_t lcd_chardata_feedrate[8] PROGMEM = { + B00000, + B00100, + B10010, + B01001, + B10010, + B00100, + B00000, + B00000};*/ + +const uint8_t lcd_chardata_clock[8] PROGMEM = { + B00000, + B01110, + B10011, + B10101, + B10001, + B01110, + B00000, + B00000}; //thanks Sonny Mounicou + +const uint8_t lcd_chardata_arrup[8] PROGMEM = { + B00100, + B01110, + B11111, + B00000, + B00000, + B00000, + B00000, + B00000}; + +const uint8_t lcd_chardata_arrdown[8] PROGMEM = { + B00000, + B00000, + B00000, + B00000, + B00000, + B10001, + B01010, + B00100}; + + + +void lcd_set_custom_characters(void) +{ + lcd.createChar_P(LCD_STR_BEDTEMP[0], lcd_chardata_bedTemp); + lcd.createChar_P(LCD_STR_DEGREE[0], lcd_chardata_degree); + lcd.createChar_P(LCD_STR_THERMOMETER[0], lcd_chardata_thermometer); + lcd.createChar_P(LCD_STR_UPLEVEL[0], lcd_chardata_uplevel); + lcd.createChar_P(LCD_STR_REFRESH[0], lcd_chardata_refresh); + lcd.createChar_P(LCD_STR_FOLDER[0], lcd_chardata_folder); + lcd.createChar_P(LCD_STR_FEEDRATE[0], lcd_chardata_feedrate); + lcd.createChar_P(LCD_STR_CLOCK[0], lcd_chardata_clock); + //lcd.createChar_P(LCD_STR_ARROW_UP[0], lcd_chardata_arrup); + //lcd.createChar_P(LCD_STR_ARROW_DOWN[0], lcd_chardata_arrdown); +} + +void lcd_set_custom_characters_arrows(void) +{ + lcd.createChar_P(1, lcd_chardata_arrdown); +} + +const uint8_t lcd_chardata_progress[8] PROGMEM = { + B11111, + B11111, + B11111, + B11111, + B11111, + B11111, + B11111, + B11111}; + +void lcd_set_custom_characters_progress(void) +{ + lcd.createChar_P(1, lcd_chardata_progress); +} + +const uint8_t lcd_chardata_arr2down[8] PROGMEM = { + B00000, + B00000, + B10001, + B01010, + B00100, + B10001, + B01010, + B00100}; + +const uint8_t lcd_chardata_confirm[8] PROGMEM = { + B00000, + B00001, + B00011, + B10110, + B11100, + B01000, + B00000}; + +void lcd_set_custom_characters_nextpage(void) +{ + lcd.createChar_P(1, lcd_chardata_arr2down); + lcd.createChar_P(2, lcd_chardata_confirm); +} + +void lcd_set_custom_characters_degree(void) +{ + lcd.createChar_P(1, lcd_chardata_degree); +} + diff --git a/Firmware/lcd.h b/Firmware/lcd.h new file mode 100644 index 00000000..2af5dd94 --- /dev/null +++ b/Firmware/lcd.h @@ -0,0 +1,240 @@ +//lcd.h +#ifndef _LCD_H +#define _LCD_H + +#include + + +#define LCD_UPDATE_INTERVAL 100 +#define LCD_TIMEOUT_TO_STATUS 30000 + + +typedef void (*lcd_longpress_func_t)(void); + +typedef void (*lcd_charsetup_func_t)(void); + +typedef void (*lcd_lcdupdate_func_t)(void); + +//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) +extern uint8_t lcd_draw_update; + +extern int32_t lcd_encoder; + +extern uint8_t lcd_encoder_bits; + +// lcd_encoder_diff is updated from interrupt context and added to lcd_encoder every LCD update +extern int8_t lcd_encoder_diff; + +//the last checked lcd_buttons in a bit array. +extern uint8_t lcd_buttons; + +extern uint8_t lcd_button_pressed; + +extern uint8_t lcd_update_enabled; + +extern uint32_t lcd_timeoutToStatus; + +extern uint32_t lcd_next_update_millis; + +extern uint8_t lcd_status_update_delay; + +extern uint8_t lcd_long_press_active; + +extern lcd_longpress_func_t lcd_longpress_func; + +extern lcd_charsetup_func_t lcd_charsetup_func; + +extern lcd_lcdupdate_func_t lcd_lcdupdate_func; + +extern uint8_t lcd_clicked(void); + +extern void lcd_set_cursor(uint8_t c, uint8_t r); + +extern void lcd_implementation_quick_feedback(void); + +//Cause an LCD refresh, and give the user visual or audible feedback that something has happened +extern void lcd_quick_feedback(void); + +extern int lcd_puts_P(const char* str); +extern int lcd_putc(int c); +extern int lcd_printf_P(const char* format, ...); + + + + + + +extern void lcd_update(uint8_t lcdDrawUpdateOverride); + +extern void lcd_update_enable(uint8_t enabled); + +extern void lcd_buttons_update(void); + + + + + + + + + + + + + + + + + + + + + + + + + + + +#include "Configuration_prusa.h" +#include "Marlin.h" + + + +/** +* Implementation of the LCD display routines for a Hitachi HD44780 display. These are common LCD character displays. +* When selecting the Russian language, a slightly different LCD implementation is used to handle UTF8 characters. +**/ + + +//////////////////////////////////// +// Setup button and encode mappings for each panel (into 'lcd_buttons' variable +// +// This is just to map common functions (across different panels) onto the same +// macro name. The mapping is independent of whether the button is directly connected or +// via a shift/i2c register. + +#define BLEN_B 1 +#define BLEN_A 0 +#define EN_B (1<', wfac_to_str5(*(data))) +#define lcd_implementation_drawmenu_setting_edit_wfac(row, pstr, pstr2, data, minValue, maxValue) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, ' ', wfac_to_str5(*(data))) +#define lcd_implementation_drawmenu_setting_edit_mres_selected(row, pstr, pstr2, data, minValue, maxValue) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, '>', mres_to_str3(*(data))) +#define lcd_implementation_drawmenu_setting_edit_mres(row, pstr, pstr2, data, minValue, maxValue) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, ' ', mres_to_str3(*(data))) +#define lcd_implementation_drawmenu_setting_edit_byte3_selected(row, pstr, pstr2, data, minValue, maxValue) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, '>', itostr3((uint8_t)*(data))) +#define lcd_implementation_drawmenu_setting_edit_byte3(row, pstr, pstr2, data, minValue, maxValue) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, ' ', itostr3((uint8_t)*(data))) +#define lcd_implementation_drawmenu_setting_edit_int3_selected(row, pstr, pstr2, data, minValue, maxValue) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, '>', itostr3(*(data))) +#define lcd_implementation_drawmenu_setting_edit_int3(row, pstr, pstr2, data, minValue, maxValue) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, ' ', itostr3(*(data))) +#define lcd_implementation_drawmenu_setting_edit_float3_selected(row, pstr, pstr2, data, minValue, maxValue) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, '>', ftostr3(*(data))) +#define lcd_implementation_drawmenu_setting_edit_float3(row, pstr, pstr2, data, minValue, maxValue) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, ' ', ftostr3(*(data))) +#define lcd_implementation_drawmenu_setting_edit_float32_selected(row, pstr, pstr2, data, minValue, maxValue) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, '>', ftostr32(*(data))) +#define lcd_implementation_drawmenu_setting_edit_float32(row, pstr, pstr2, data, minValue, maxValue) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, ' ', ftostr32(*(data))) +#define lcd_implementation_drawmenu_setting_edit_float43_selected(row, pstr, pstr2, data, minValue, maxValue) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, '>', ftostr43(*(data))) +#define lcd_implementation_drawmenu_setting_edit_float43(row, pstr, pstr2, data, minValue, maxValue) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, ' ', ftostr43(*(data))) +#define lcd_implementation_drawmenu_setting_edit_float5_selected(row, pstr, pstr2, data, minValue, maxValue) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, '>', ftostr5(*(data))) +#define lcd_implementation_drawmenu_setting_edit_float5(row, pstr, pstr2, data, minValue, maxValue) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, ' ', ftostr5(*(data))) +#define lcd_implementation_drawmenu_setting_edit_float52_selected(row, pstr, pstr2, data, minValue, maxValue) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, '>', ftostr52(*(data))) +#define lcd_implementation_drawmenu_setting_edit_float52(row, pstr, pstr2, data, minValue, maxValue) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, ' ', ftostr52(*(data))) +#define lcd_implementation_drawmenu_setting_edit_float51_selected(row, pstr, pstr2, data, minValue, maxValue) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, '>', ftostr51(*(data))) +#define lcd_implementation_drawmenu_setting_edit_float51(row, pstr, pstr2, data, minValue, maxValue) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, ' ', ftostr51(*(data))) +#define lcd_implementation_drawmenu_setting_edit_long5_selected(row, pstr, pstr2, data, minValue, maxValue) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, '>', ftostr5(*(data))) +#define lcd_implementation_drawmenu_setting_edit_long5(row, pstr, pstr2, data, minValue, maxValue) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, ' ', ftostr5(*(data))) +#define lcd_implementation_drawmenu_setting_edit_bool_selected(row, pstr, pstr2, data) lcd_implementation_drawmenu_setting_edit_generic_P(row, pstr, '>', (*(data))?PSTR(MSG_ON):PSTR(MSG_OFF)) +#define lcd_implementation_drawmenu_setting_edit_bool(row, pstr, pstr2, data) lcd_implementation_drawmenu_setting_edit_generic_P(row, pstr, ' ', (*(data))?PSTR(MSG_ON):PSTR(MSG_OFF)) + +//Add version for callback functions +#define lcd_implementation_drawmenu_setting_edit_callback_int3_selected(row, pstr, pstr2, data, minValue, maxValue, callback) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, '>', itostr3(*(data))) +#define lcd_implementation_drawmenu_setting_edit_callback_int3(row, pstr, pstr2, data, minValue, maxValue, callback) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, ' ', itostr3(*(data))) +#define lcd_implementation_drawmenu_setting_edit_callback_float3_selected(row, pstr, pstr2, data, minValue, maxValue, callback) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, '>', ftostr3(*(data))) +#define lcd_implementation_drawmenu_setting_edit_callback_float3(row, pstr, pstr2, data, minValue, maxValue, callback) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, ' ', ftostr3(*(data))) +#define lcd_implementation_drawmenu_setting_edit_callback_float32_selected(row, pstr, pstr2, data, minValue, maxValue, callback) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, '>', ftostr32(*(data))) +#define lcd_implementation_drawmenu_setting_edit_callback_float32(row, pstr, pstr2, data, minValue, maxValue, callback) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, ' ', ftostr32(*(data))) +#define lcd_implementation_drawmenu_setting_edit_callback_float43_selected(row, pstr, pstr2, data, minValue, maxValue, callback) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, '>', ftostr43(*(data))) +#define lcd_implementation_drawmenu_setting_edit_callback_float43(row, pstr, pstr2, data, minValue, maxValue, callback) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, ' ', ftostr43(*(data))) +#define lcd_implementation_drawmenu_setting_edit_callback_float5_selected(row, pstr, pstr2, data, minValue, maxValue, callback) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, '>', ftostr5(*(data))) +#define lcd_implementation_drawmenu_setting_edit_callback_float5(row, pstr, pstr2, data, minValue, maxValue, callback) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, ' ', ftostr5(*(data))) +#define lcd_implementation_drawmenu_setting_edit_callback_float52_selected(row, pstr, pstr2, data, minValue, maxValue, callback) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, '>', ftostr52(*(data))) +#define lcd_implementation_drawmenu_setting_edit_callback_float52(row, pstr, pstr2, data, minValue, maxValue, callback) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, ' ', ftostr52(*(data))) +#define lcd_implementation_drawmenu_setting_edit_callback_float51_selected(row, pstr, pstr2, data, minValue, maxValue, callback) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, '>', ftostr51(*(data))) +#define lcd_implementation_drawmenu_setting_edit_callback_float51(row, pstr, pstr2, data, minValue, maxValue, callback) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, ' ', ftostr51(*(data))) +#define lcd_implementation_drawmenu_setting_edit_callback_long5_selected(row, pstr, pstr2, data, minValue, maxValue, callback) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, '>', ftostr5(*(data))) +#define lcd_implementation_drawmenu_setting_edit_callback_long5(row, pstr, pstr2, data, minValue, maxValue, callback) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, ' ', ftostr5(*(data))) +#define lcd_implementation_drawmenu_setting_edit_callback_bool_selected(row, pstr, pstr2, data, callback) lcd_implementation_drawmenu_setting_edit_generic_P(row, pstr, '>', (*(data))?PSTR(MSG_ON):PSTR(MSG_OFF)) +#define lcd_implementation_drawmenu_setting_edit_callback_bool(row, pstr, pstr2, data, callback) lcd_implementation_drawmenu_setting_edit_generic_P(row, pstr, ' ', (*(data))?PSTR(MSG_ON):PSTR(MSG_OFF)) + + +extern void lcd_implementation_drawedit(const char* pstr, char* value); +extern void lcd_implementation_drawedit_2(const char* pstr, char* value); + + + +#endif //_LCD_H diff --git a/Firmware/menu.cpp b/Firmware/menu.cpp new file mode 100644 index 00000000..13a97d67 --- /dev/null +++ b/Firmware/menu.cpp @@ -0,0 +1,270 @@ +//menu.cpp + +#include "menu.h" +#include +#include +#include +#include +#include "lcd.h" + + + +extern int32_t lcd_encoder; + + +menu_record_t menu_stack[MENU_DEPTH_MAX]; + +uint8_t menu_data[MENU_DATA_SIZE]; + +uint8_t menu_depth = 0; + +uint8_t menu_line = 0; +uint8_t menu_item = 0; +uint8_t menu_row = 0; +uint8_t menu_top = 0; + +uint8_t menu_clicked = 0; + +menu_func_t menu_menu = 0; + + +void menu_goto(menu_func_t menu, const uint32_t encoder, const bool feedback, bool reset_menu_state) +{ + asm("cli"); + if (menu_menu != menu) + { + menu_menu = menu; + lcd_encoder = encoder; + asm("sei"); + if (reset_menu_state) + { + // Resets the global shared C union. + // This ensures, that the menu entered will find out, that it shall initialize itself. + memset(&menu_data, 0, sizeof(menu_data)); + } + if (feedback) lcd_quick_feedback(); + } + else + asm("sei"); +} + +void menu_start(void) +{ + if (lcd_encoder > 0x8000) lcd_encoder = 0; + if (lcd_encoder < 0) lcd_encoder = 0; + if (lcd_encoder < menu_top) + menu_top = lcd_encoder; + menu_line = menu_top; + menu_clicked = LCD_CLICKED; +} + +void menu_end(void) +{ + if (lcd_encoder >= menu_item) + lcd_encoder = menu_item - 1; + if (((uint8_t)lcd_encoder) >= menu_top + LCD_HEIGHT) + { + menu_top = lcd_encoder - LCD_HEIGHT + 1; + lcd_draw_update = 1; + menu_line = menu_top - 1; + menu_row = -1; + } +} + +void menu_back(void) +{ + if (menu_depth > 0) menu_goto(menu_stack[--menu_depth].menu, menu_stack[menu_depth].position, true, true); +} + +void menu_back_if_clicked(void) +{ + if (lcd_clicked()) + menu_back(); +} + +void menu_back_if_clicked_fb(void) +{ + if (lcd_clicked()) + { + lcd_quick_feedback(); + menu_back(); + } +} + +void menu_submenu(menu_func_t submenu) +{ + if (menu_depth <= MENU_DEPTH_MAX) + { + menu_stack[menu_depth].menu = menu_menu; + menu_stack[menu_depth++].position = lcd_encoder; + menu_goto(submenu, 0, true, true); + } +} + +uint8_t menu_item_ret(void) +{ + lcd_implementation_quick_feedback(); + lcd_draw_update = 2; + lcd_button_pressed = false; + return 1; +} + +/* +int menu_item_printf_P(char type_char, const char* format, ...) +{ + va_list args; + va_start(args, format); + int ret = 0; + lcd_set_cursor(0, menu_row); + if (lcd_encoder == menu_item) + lcd.print('>'); + else + lcd.print(' '); + int cnt = vfprintf_P(lcdout, format, args); + for (int i = cnt; i < 18; i++) + lcd.print(' '); + lcd.print(type_char); + va_end(args); + return ret; +} +*/ +int menu_draw_item_puts_P(char type_char, const char* str) +{ + lcd_set_cursor(0, menu_row); + int cnt = lcd_printf_P(PSTR("%c%-18S%c"), (lcd_encoder == menu_item)?'>':' ', str, type_char); + return cnt; +} +/* +int menu_draw_item_puts_P_int16(char type_char, const char* str, int16_t val, ) +{ + lcd_set_cursor(0, menu_row); + int cnt = lcd_printf_P(PSTR("%c%-18S%c"), (lcd_encoder == menu_item)?'>':' ', str, type_char); + return cnt; +} +*/ +void menu_item_dummy(void) +{ + menu_item++; +} + +uint8_t menu_item_text_P(const char* str) +{ + if (menu_item == menu_line) + { + if (lcd_draw_update) menu_draw_item_puts_P(' ', str); + if (menu_clicked && (lcd_encoder == menu_item)) + return menu_item_ret(); + } + menu_item++; + return 0; +} + +uint8_t menu_item_submenu_P(const char* str, menu_func_t submenu) +{ + if (menu_item == menu_line) + { + if (lcd_draw_update) menu_draw_item_puts_P(LCD_STR_ARROW_RIGHT[0], str); + if (menu_clicked && (lcd_encoder == menu_item)) + { + menu_submenu(submenu); + return menu_item_ret(); + } + } + menu_item++; + return 0; +} + +uint8_t menu_item_back_P(const char* str) +{ + if (menu_item == menu_line) + { + if (lcd_draw_update) menu_draw_item_puts_P(LCD_STR_UPLEVEL[0], str); + if (menu_clicked && (lcd_encoder == menu_item)) + { + menu_back(); + return menu_item_ret(); + } + } + menu_item++; + return 0; +} + +uint8_t menu_item_function_P(const char* str, menu_func_t func) +{ + if (menu_item == menu_line) + { + if (lcd_draw_update) menu_draw_item_puts_P(' ', str); + if (menu_clicked && (lcd_encoder == menu_item)) + { + menu_clicked = false; + if (func) func(); + return menu_item_ret(); + } + } + menu_item++; + return 0; +} + +uint8_t menu_item_gcode_P(const char* str, const char* str_gcode) +{ + if (menu_item == menu_line) + { + if (lcd_draw_update) menu_draw_item_puts_P(' ', str); + if (menu_clicked && (lcd_encoder == menu_item)) + { + if (str_gcode) enquecommand_P(str_gcode); + return menu_item_ret(); + } + } + menu_item++; + return 0; +} + +const char menu_fmt_int3[] PROGMEM = "%c%S:\x1b[%hhu;16H%3d"; + +#define _menu_data (*((menu_data_edit_t*)menu_data)) +void _menu_edit_int3(void) +{ + if (lcd_draw_update) + { + if (lcd_encoder < _menu_data.minEditValue) lcd_encoder = _menu_data.minEditValue; + if (lcd_encoder > _menu_data.maxEditValue) lcd_encoder = _menu_data.maxEditValue; + lcd_set_cursor(0, 1); + lcd_printf_P(menu_fmt_int3, ' ', _menu_data.editLabel, (uint8_t)1, (int)lcd_encoder); + } + if (LCD_CLICKED) + { + *((int*)(_menu_data.editValue)) = (int)lcd_encoder; + menu_back(); + } +} + +uint8_t menu_item_edit_int3(const char* str, int16_t* pval, int16_t min_val, int16_t max_val) +{ + if (menu_item == menu_line) + { + if (lcd_draw_update) + { + lcd_set_cursor(0, menu_row); + lcd_printf_P(menu_fmt_int3, (lcd_encoder == menu_item)?'>':' ', str, menu_row, *pval); + } + if (menu_clicked && (lcd_encoder == menu_item)) + { + menu_submenu(_menu_edit_int3); + _menu_data.editLabel = str; + _menu_data.editValue = pval; + _menu_data.minEditValue = min_val; + _menu_data.maxEditValue = max_val; + lcd_encoder = *pval; + return menu_item_ret(); + } + } + menu_item++; + return 0; +} +#undef _menu_data + + + + + diff --git a/Firmware/menu.h b/Firmware/menu.h new file mode 100644 index 00000000..b0ec6296 --- /dev/null +++ b/Firmware/menu.h @@ -0,0 +1,99 @@ +//menu.h +#ifndef _MENU_H +#define _MENU_H + +#include + +#define MENU_DEPTH_MAX 4 +#define MENU_DATA_SIZE 32 + +//Function pointer to menu functions. +typedef void (*menu_func_t)(void); + +typedef struct +{ + menu_func_t menu; + uint8_t position; +} menu_record_t; + +typedef struct +{ + //Variables used when editing values. + const char* editLabel; + void* editValue; + int32_t minEditValue; + int32_t maxEditValue; +} menu_data_edit_t; + +extern menu_record_t menu_stack[MENU_DEPTH_MAX]; + +extern uint8_t menu_data[MENU_DATA_SIZE]; + +extern uint8_t menu_depth; + +extern uint8_t menu_line; +extern uint8_t menu_item; +extern uint8_t menu_row; +; +//scroll offset in the current menu +extern uint8_t menu_top; + +extern uint8_t menu_clicked; + +//function pointer to the currently active menu +extern menu_func_t menu_menu; + + + +extern void menu_goto(menu_func_t menu, const uint32_t encoder, const bool feedback, bool reset_menu_state); + +#define MENU_BEGIN() menu_start(); for(menu_row = 0; menu_row < LCD_HEIGHT; menu_row++, menu_line++) { menu_item = 0; +void menu_start(void); + +#define MENU_END() menu_end(); } +extern void menu_end(void); + +extern void menu_back(void); + +extern void menu_back_if_clicked(void); + +extern void menu_back_if_clicked_fb(void); + +extern void menu_submenu(menu_func_t submenu); + +extern uint8_t menu_item_ret(void); + +//int menu_item_printf_P(char type_char, const char* format, ...); + +extern int menu_draw_item_puts_P(char type_char, const char* str); + +//int menu_draw_item_puts_P_int16(char type_char, const char* str, int16_t val, ); + +#define MENU_ITEM_DUMMY() menu_item_dummy() +extern void menu_item_dummy(void); + +#define MENU_ITEM_TEXT_P(str) do { if (menu_item_text_P(str)) return; } while (0) +extern uint8_t menu_item_text_P(const char* str); + +#define MENU_ITEM_SUBMENU_P(str, submenu) do { if (menu_item_submenu_P(str, submenu)) return; } while (0) +extern uint8_t menu_item_submenu_P(const char* str, menu_func_t submenu); + +#define MENU_ITEM_BACK_P(str) do { if (menu_item_back_P(str)) return; } while (0) +extern uint8_t menu_item_back_P(const char* str); + +#define MENU_ITEM_FUNCTION_P(str, func) do { if (menu_item_function_P(str, func)) return; } while (0) +extern uint8_t menu_item_function_P(const char* str, menu_func_t func); + +#define MENU_ITEM_GCODE_P(str, str_gcode) do { if (menu_item_gcode_P(str, str_gcode)) return; } while (0) +extern uint8_t menu_item_gcode_P(const char* str, const char* str_gcode); + + +extern const char menu_fmt_int3[]; + +extern void _menu_edit_int3(void); + +#define MENU_ITEM_EDIT_int3_P(str, pval, minval, maxval) do { if (menu_item_edit_int3(str, pval, minval, maxval)) return; } while (0) +//#define MENU_ITEM_EDIT_int3_P(str, pval, minval, maxval) MENU_ITEM_EDIT(int3, str, pval, minval, maxval) +extern uint8_t menu_item_edit_int3(const char* str, int16_t* pval, int16_t min_val, int16_t max_val); + +#endif //_MENU_H diff --git a/Firmware/pins_Einsy_1_0.h b/Firmware/pins_Einsy_1_0.h index 0382a090..f1c514c7 100644 --- a/Firmware/pins_Einsy_1_0.h +++ b/Firmware/pins_Einsy_1_0.h @@ -95,11 +95,9 @@ #define KILL_PIN -1 // 80 with Smart Controller LCD #define SUICIDE_PIN -1 // PIN that has to be turned on right after start, to keep power flowing. -#ifdef ULTRA_LCD //#define KILL_PIN 32 -#ifdef NEWPANEL //#define LCD_PWM_PIN -1//32 // lcd backlight brightnes pwm control pin //#define LCD_PWM_MAX 0x0f // lcd pwm maximum value (0x07=64Hz, 0x0f=32Hz, 0x1f=16Hz) @@ -122,8 +120,6 @@ #define TACH_0 79 // !!! changed from 81 (EINY03) #define TACH_1 80 -#endif //NEWPANEL -#endif //ULTRA_LCD // Support for an 8 bit logic analyzer, for example the Saleae. // Channels 0-2 are fast, they could generate 2.667Mhz waveform with a software loop. diff --git a/Firmware/pins_Rambo_1_0.h b/Firmware/pins_Rambo_1_0.h index b06b4f73..1e3a142c 100644 --- a/Firmware/pins_Rambo_1_0.h +++ b/Firmware/pins_Rambo_1_0.h @@ -83,11 +83,9 @@ #define SUICIDE_PIN -1 // PIN that has to be turned on right after start, to keep power flowing. #define TACH_0 30 // noctua extruder fan -#ifdef ULTRA_LCD //#define KILL_PIN 32 -#ifdef NEWPANEL #define BEEPER 78 // Beeper on AUX-4 #define LCD_PINS_RS 38 @@ -105,8 +103,6 @@ #define SDCARDDETECT 72 -#endif //NEWPANEL -#endif //ULTRA_LCD // Support for an 8 bit logic analyzer, for example the Saleae. // Channels 0-2 are fast, they could generate 2.667Mhz waveform with a software loop. diff --git a/Firmware/pins_Rambo_1_3.h b/Firmware/pins_Rambo_1_3.h index 4c808c73..a9a6b390 100644 --- a/Firmware/pins_Rambo_1_3.h +++ b/Firmware/pins_Rambo_1_3.h @@ -83,11 +83,9 @@ #define SUICIDE_PIN -1 // PIN that has to be turned on right after start, to keep power flowing. #define TACH_0 30 // noctua extruder fan -#ifdef ULTRA_LCD //#define KILL_PIN 32 -#ifdef NEWPANEL #define BEEPER 84 // Beeper on AUX-4 #define LCD_PINS_RS 82 @@ -105,8 +103,6 @@ #define SDCARDDETECT 15 -#endif //NEWPANEL -#endif //ULTRA_LCD // Support for an 8 bit logic analyzer, for example the Saleae. // Channels 0-2 are fast, they could generate 2.667Mhz waveform with a software loop. diff --git a/Firmware/planner.cpp b/Firmware/planner.cpp index c88a0a83..e1cd09b7 100644 --- a/Firmware/planner.cpp +++ b/Firmware/planner.cpp @@ -646,10 +646,10 @@ void plan_buffer_line(float x, float y, float z, const float &e, float feed_rate manage_heater(); // Vojtech: Don't disable motors inside the planner! manage_inactivity(false); - lcd_update(); + lcd_update(0); } while (block_buffer_tail == next_buffer_head); if (waiting_inside_plan_buffer_line_print_aborted) { - // Inside the lcd_update() routine the print has been aborted. + // Inside the lcd_update(0) routine the print has been aborted. // Cancel the print, do not plan the current line this routine is waiting on. #ifdef PLANNER_DIAGNOSTICS planner_update_queue_min_counter(); diff --git a/Firmware/stepper.cpp b/Firmware/stepper.cpp index 90a49c6b..cd14c501 100644 --- a/Firmware/stepper.cpp +++ b/Firmware/stepper.cpp @@ -1325,13 +1325,13 @@ void st_synchronize() if (!tmc2130_update_sg()) { manage_inactivity(true); - lcd_update(); + lcd_update(0); } #else //TMC2130 manage_heater(); // Vojtech: Don't disable motors inside the planner! manage_inactivity(true); - lcd_update(); + lcd_update(0); #endif //TMC2130 } } diff --git a/Firmware/temperature.cpp b/Firmware/temperature.cpp index 83ead13b..232aeee7 100644 --- a/Firmware/temperature.cpp +++ b/Firmware/temperature.cpp @@ -30,6 +30,7 @@ #include "Marlin.h" +#include "lcd.h" #include "ultralcd.h" #include "temperature.h" #include "cardreader.h" @@ -403,7 +404,7 @@ unsigned long watchmillis[EXTRUDERS] = ARRAY_BY_EXTRUDERS(0,0,0); pid_cycle = 0; return; } - lcd_update(); + lcd_update(0); } } @@ -1332,7 +1333,7 @@ void temp_runaway_stop(bool isPreheat, bool isBed) disable_e1(); disable_e2(); manage_heater(); - lcd_update(); + lcd_update(0); WRITE(BEEPER, HIGH); delayMicroseconds(500); WRITE(BEEPER, LOW); diff --git a/Firmware/ultralcd.cpp b/Firmware/ultralcd.cpp index 132f3486..c2ecfeaa 100644 --- a/Firmware/ultralcd.cpp +++ b/Firmware/ultralcd.cpp @@ -1,7 +1,6 @@ #include "temperature.h" #include "ultralcd.h" #include "fsensor.h" -#ifdef ULTRA_LCD #include "Marlin.h" #include "language.h" #include "cardreader.h" @@ -11,6 +10,10 @@ #include #include "Timer.h" + +#include "lcd.h" +#include "menu.h" + #include "util.h" #include "mesh_bed_leveling.h" //#include "Configuration.h" @@ -27,7 +30,6 @@ #endif //TMC2130 -int8_t encoderDiff; /* encoderDiff is updated from interrupt context and added to encoderPosition every LCD update */ extern int lcd_change_fil_state; extern bool fans_check_enabled; @@ -38,9 +40,9 @@ extern bool fsensor_not_responding; extern bool fsensor_enabled; #endif //PAT9125 -//Function pointer to menu functions. +int scrollstuff = 0; +char longFilenameOLD[LONG_FILENAME_LENGTH]; -typedef void (*menu_func_t)(void); static void lcd_sd_updir(); @@ -126,26 +128,8 @@ union MenuData // State of the currently active menu. // C Union manages sharing of the static memory by all the menus. -union MenuData menuData = { 0 }; - -union Data -{ - byte b[2]; - int value; -}; - -#define MENU_DEPTH_MAX 4 - - -typedef struct -{ - menu_func_t menu; - uint8_t position; -} menu_record_t; - -menu_record_t menu_stack[MENU_DEPTH_MAX]; - -uint8_t menu_depth = 0; +//union MenuData menuData = { 0 }; +#define menuData (*((MenuData*)menu_data)) int8_t ReInitLCD = 0; @@ -189,17 +173,11 @@ bool printer_connected = true; unsigned long display_time; //just timer for showing pid finished message on lcd; float pid_temp = DEFAULT_PID_TEMP; -bool long_press_active = false; -static ShortTimer longPressTimer; -unsigned long button_blanking_time = millis(); -bool button_pressed = false; bool menuExiting = false; -#ifdef ULTIPANEL static float manual_feedrate[] = MANUAL_FEEDRATE; -#endif // ULTIPANEL /* !Configuration settings */ @@ -207,7 +185,6 @@ uint8_t lcd_status_message_level; char lcd_status_message[LCD_WIDTH + 1] = ""; //////WELCOME! unsigned char firstrun = 1; -#include "ultralcd_implementation_hitachi_HD44780.h" static const char separator[] PROGMEM = "--------------------"; @@ -219,7 +196,6 @@ static const char* lcd_display_message_fullscreen_nonBlocking_P(const char *msg, /* Different menus */ static void lcd_status_screen(); -#ifdef ULTIPANEL extern bool powersupply; static void lcd_main_menu(); static void lcd_tune_menu(); @@ -249,9 +225,6 @@ static void lcd_menu_fails_stats(); void lcd_finishstatus(); -#ifdef DOGLCD -static void lcd_set_contrast(); -#endif static void lcd_control_retract_menu(); static void lcd_sdcard_menu(); @@ -259,7 +232,6 @@ static void lcd_sdcard_menu(); static void lcd_delta_calibrate_menu(); #endif // DELTA_CALIBRATION_MENU -static void lcd_quick_feedback();//Cause an LCD refresh, and give the user visual or audible feedback that something has happened /* Different types of actions that can be used in menu items. */ static void menu_action_sdfile(const char* filename, char* longFilename); @@ -280,23 +252,18 @@ static void menu_action_setting_edit_long5(const char* pstr, unsigned long* ptr, #define ENCODER_FEEDRATE_DEADZONE 10 -uint8_t menu_line = 0; -uint8_t menu_item = 0; -uint8_t menu_row = 0; - -bool wasClicked = false; #define MENU_ITEM(type, label, args...) do { \ if (menu_item == menu_line) { \ - if (lcdDrawUpdate) { \ + if (lcd_draw_update) { \ const char* _label_pstr = (label); \ - if (encoderPosition == menu_item) { \ + if (lcd_encoder == menu_item) { \ lcd_implementation_drawmenu_ ## type ## _selected (menu_row, _label_pstr , ## args ); \ }else{\ lcd_implementation_drawmenu_ ## type (menu_row, _label_pstr , ## args ); \ }\ }\ - if (wasClicked && (encoderPosition == menu_item)) {\ + if (menu_clicked && (lcd_encoder == menu_item)) {\ lcd_quick_feedback(); \ menu_action_ ## type ( args ); \ return;\ @@ -307,29 +274,12 @@ bool wasClicked = false; #define MENU_ITEM_EDIT(type, label, args...) MENU_ITEM(setting_edit_ ## type, label, (label) , ## args ) -/** Used variables to keep track of the menu */ -#ifndef REPRAPWORLD_KEYPAD -volatile uint8_t buttons;//Contains the bits of the currently pressed buttons. -#else -volatile uint8_t buttons_reprapworld_keypad; // to store the reprapworld_keypad shift register values -#endif -#ifdef LCD_HAS_SLOW_BUTTONS -volatile uint8_t slow_buttons;//Contains the bits of the currently pressed buttons. -#endif -uint8_t currentMenuViewOffset; /* scroll offset in the current menu */ -uint8_t lastEncoderBits; -int32_t encoderPosition; #if (SDCARDDETECT > 0) bool lcd_oldcardstatus; #endif -#endif //ULTIPANEL -menu_func_t menu_menu = lcd_status_screen; /* function pointer to the currently active menu */ -uint32_t lcd_next_update_millis; -uint8_t lcd_status_update_delay; bool ignore_click = false; bool wait_for_unclick; -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) */ // place-holders for Ki and Kd edits #ifdef PIDTEMP @@ -337,253 +287,213 @@ uint8_t lcdDrawUpdate = 2; /* Set to none-zero when the LCD nee #endif -static void lcd_goto_menu(menu_func_t menu, const uint32_t encoder = 0, const bool feedback = true, bool reset_menu_state = true) -{ - asm("cli"); - if (menu_menu != menu) + + + + + + + + +static inline void lcd_print_percent_done() { + if (is_usb_printing) { - menu_menu = menu; - encoderPosition = encoder; - asm("sei"); - if (reset_menu_state) - { - // Resets the global shared C union. - // This ensures, that the menu entered will find out, that it shall initialize itself. - memset(&menuData, 0, sizeof(menuData)); - } - if (feedback) lcd_quick_feedback(); + lcd_printPGM(PSTR("USB")); + } + else if(IS_SD_PRINTING) + { + lcd_printPGM(PSTR("SD")); } else - asm("sei"); -} - - -//////////////////////////////////////////////////////////////////////////////// -// New Menu implementation - -#include - - -int lcd_puts_P(const char* str) -{ - return fputs_P(str, lcdout); -} - -int lcd_putc(int c) -{ - return fputc(c, lcdout); -} - -int lcd_printf_P(const char* format, ...) -{ - va_list args; - va_start(args, format); - int ret = vfprintf_P(lcdout, format, args); - va_end(args); - return ret; -} - -#define MENU_BEGIN() menu_start(); for(menu_row = 0; menu_row < LCD_HEIGHT; menu_row++, menu_line++) { menu_item = 0; -void menu_start(void) -{ - if (encoderPosition > 0x8000) encoderPosition = 0; - if (encoderPosition < 0) encoderPosition = 0; - if (encoderPosition < currentMenuViewOffset) - currentMenuViewOffset = encoderPosition; - menu_line = currentMenuViewOffset; - wasClicked = LCD_CLICKED; -} - -#define MENU_END() menu_end(); } -void menu_end(void) -{ - if (encoderPosition >= menu_item) - encoderPosition = menu_item - 1; - if (((uint8_t)encoderPosition) >= currentMenuViewOffset + LCD_HEIGHT) { - currentMenuViewOffset = encoderPosition - LCD_HEIGHT + 1; - lcdDrawUpdate = 1; - menu_line = currentMenuViewOffset - 1; - menu_row = -1; + lcd_printPGM(PSTR(" ")); } -} - -void menu_back(void) -{ - if (menu_depth > 0) lcd_goto_menu(menu_stack[--menu_depth].menu, menu_stack[menu_depth].position, true, true); -} - -void menu_back_if_clicked(void) -{ - if (lcd_clicked()) - menu_back(); -} - -void menu_back_if_clicked_fb(void) -{ - if (lcd_clicked()) + if (IS_SD_PRINTING || (PRINTER_ACTIVE && (print_percent_done_normal != PRINT_PERCENT_DONE_INIT))) { - lcd_quick_feedback(); - menu_back(); + lcd.print(itostr3(print_percent_done())); } -} - -void menu_submenu(menu_func_t submenu) -{ - if (menu_depth <= MENU_DEPTH_MAX) - { - menu_stack[menu_depth].menu = menu_menu; - menu_stack[menu_depth++].position = encoderPosition; - lcd_goto_menu(submenu); - } -} - -uint8_t menu_item_ret(void) -{ - lcd_implementation_quick_feedback(); - lcdDrawUpdate = 2; - button_pressed = false; - return 1; -} - -/* -int menu_item_printf_P(char type_char, const char* format, ...) -{ - va_list args; - va_start(args, format); - int ret = 0; - lcd.setCursor(0, menu_row); - if (encoderPosition == menu_item) - lcd.print('>'); else - lcd.print(' '); - int cnt = vfprintf_P(lcdout, format, args); - for (int i = cnt; i < 18; i++) - lcd.print(' '); - lcd.print(type_char); - va_end(args); - return ret; -} -*/ -int menu_draw_item_puts_P(char type_char, const char* str) -{ - lcd.setCursor(0, menu_row); - int cnt = lcd_printf_P(_N("%c%-18S%c"), (encoderPosition == menu_item)?'>':' ', str, type_char); - return cnt; -} -/* -int menu_draw_item_puts_P_int16(char type_char, const char* str, int16_t val, ) -{ - lcd.setCursor(0, menu_row); - int cnt = lcd_printf_P(_N("%c%-18S%c"), (encoderPosition == menu_item)?'>':' ', str, type_char); - return cnt; -} -*/ -#define MENU_ITEM_DUMMY() menu_item_dummy() -inline void menu_item_dummy(void) -{ - menu_item++; -} - -#define MENU_ITEM_TEXT_P(str) do { if (menu_item_text_P(str)) return; } while (0) -uint8_t menu_item_text_P(const char* str) -{ - if (menu_item == menu_line) { - if (lcdDrawUpdate) menu_draw_item_puts_P(' ', str); - if (wasClicked && (encoderPosition == menu_item)) - return menu_item_ret(); + lcd_printPGM(PSTR("---")); } - menu_item++; - return 0; + lcd_printPGM(PSTR("% ")); } -#define MENU_ITEM_SUBMENU_P(str, submenu) do { if (menu_item_submenu_P(str, submenu)) return; } while (0) -uint8_t menu_item_submenu_P(const char* str, menu_func_t submenu) -{ - if (menu_item == menu_line) +static inline void lcd_print_time() { + //if remaining print time estimation is available print it else print elapsed time + //uses 8 characters + uint16_t print_t = 0; + if (print_time_remaining_normal != PRINT_TIME_REMAINING_INIT){ + print_t = print_time_remaining(); + } + else if(starttime != 0){ + print_t = millis() / 60000 - starttime / 60000; + } + lcd.print(LCD_STR_CLOCK[0]); + if((PRINTER_ACTIVE) && ((print_time_remaining_normal != PRINT_TIME_REMAINING_INIT)||(starttime != 0))) { - if (lcdDrawUpdate) menu_draw_item_puts_P(LCD_STR_ARROW_RIGHT[0], str); - if (wasClicked && (encoderPosition == menu_item)) + lcd.print(itostr2(print_t/60)); + lcd.print(':'); + lcd.print(itostr2(print_t%60)); + if (print_time_remaining_normal != PRINT_TIME_REMAINING_INIT) { - menu_submenu(submenu); - return menu_item_ret(); + lcd.print('R'); + (feedmultiply == 100) ? lcd.print(' ') : lcd.print('?'); } - } - menu_item++; - return 0; + else { + lcd_printPGM(PSTR(" ")); + } + }else{ + lcd_printPGM(PSTR("--:-- ")); + } } -#define MENU_ITEM_BACK_P(str) do { if (menu_item_back_P(str)) return; } while (0) -uint8_t menu_item_back_P(const char* str) + +static void lcd_implementation_drawmenu_sdfile_selected(uint8_t row, const char* pstr, const char* filename, char* longFilename) { - if (menu_item == menu_line) - { - if (lcdDrawUpdate) menu_draw_item_puts_P(LCD_STR_UPLEVEL[0], str); - if (wasClicked && (encoderPosition == menu_item)) - { - menu_back(); - return menu_item_ret(); - } - } - menu_item++; - return 0; + char c; + int enc_dif = lcd_encoder_diff; + uint8_t n = LCD_WIDTH - 1; + for(int g = 0; g<4;g++){ + lcd.setCursor(0, g); + lcd.print(' '); + } + + lcd.setCursor(0, row); + lcd.print('>'); + int i = 1; + int j = 0; + char* longFilenameTMP = longFilename; + + while((c = *longFilenameTMP) != '\0') + { + lcd.setCursor(i, row); + lcd.print(c); + i++; + longFilenameTMP++; + if(i==LCD_WIDTH){ + i=1; + j++; + longFilenameTMP = longFilename + j; + n = LCD_WIDTH - 1; + for(int g = 0; g<300 ;g++){ + manage_heater(); + if(LCD_CLICKED || ( enc_dif != lcd_encoder_diff )){ + longFilenameTMP = longFilename; + *(longFilenameTMP + LCD_WIDTH - 2) = '\0'; + i = 1; + j = 0; + break; + }else{ + if (j == 1) delay(3); //wait around 1.2 s to start scrolling text + delay(1); //then scroll with redrawing every 300 ms + } + + } + } + } + if(c!='\0'){ + lcd.setCursor(i, row); + lcd.print(c); + i++; + } + n=n-i+1; + while(n--) + lcd.print(' '); +} +static void lcd_implementation_drawmenu_sdfile(uint8_t row, const char* pstr, const char* filename, char* longFilename) +{ + char c; + uint8_t n = LCD_WIDTH - 1; + lcd.setCursor(0, row); + lcd.print(' '); + if (longFilename[0] != '\0') + { + filename = longFilename; + longFilename[LCD_WIDTH-1] = '\0'; + } + while( ((c = *filename) != '\0') && (n>0) ) + { + lcd.print(c); + filename++; + n--; + } + while(n--) + lcd.print(' '); +} +static void lcd_implementation_drawmenu_sddirectory_selected(uint8_t row, const char* pstr, const char* filename, char* longFilename) +{ + char c; + uint8_t n = LCD_WIDTH - 2; + lcd.setCursor(0, row); + lcd.print('>'); + lcd.print(LCD_STR_FOLDER[0]); + if (longFilename[0] != '\0') + { + filename = longFilename; + longFilename[LCD_WIDTH-2] = '\0'; + } + while( ((c = *filename) != '\0') && (n>0) ) + { + lcd.print(c); + filename++; + n--; + } + while(n--) + lcd.print(' '); +} +static void lcd_implementation_drawmenu_sddirectory(uint8_t row, const char* pstr, const char* filename, char* longFilename) +{ + char c; + uint8_t n = LCD_WIDTH - 2; + lcd.setCursor(0, row); + lcd.print(' '); + lcd.print(LCD_STR_FOLDER[0]); + if (longFilename[0] != '\0') + { + filename = longFilename; + longFilename[LCD_WIDTH-2] = '\0'; + } + while( ((c = *filename) != '\0') && (n>0) ) + { + lcd.print(c); + filename++; + n--; + } + while(n--) + lcd.print(' '); } -#define MENU_ITEM_FUNCTION_P(str, func) do { if (menu_item_function_P(str, func)) return; } while (0) -uint8_t menu_item_function_P(const char* str, menu_func_t func) -{ - if (menu_item == menu_line) - { - if (lcdDrawUpdate) menu_draw_item_puts_P(' ', str); - if (wasClicked && (encoderPosition == menu_item)) - { - wasClicked = false; - if (func) func(); - return menu_item_ret(); - } - } - menu_item++; - return 0; -} -#define MENU_ITEM_GCODE_P(str, str_gcode) do { if (menu_item_gcode_P(str, str_gcode)) return; } while (0) -uint8_t menu_item_gcode_P(const char* str, const char* str_gcode) -{ - if (menu_item == menu_line) - { - if (lcdDrawUpdate) menu_draw_item_puts_P(' ', str); - if (wasClicked && (encoderPosition == menu_item)) - { - if (str_gcode) enquecommand_P(str_gcode); - return menu_item_ret(); - } - } - menu_item++; - return 0; -} //#define MENU_ITEM_SDDIR(str, str_fn, str_fnl) do { if (menu_item_sddir(str, str_fn, str_fnl)) return; } while (0) #define MENU_ITEM_SDDIR(str, str_fn, str_fnl) MENU_ITEM(sddirectory, str, str_fn, str_fnl) +//extern uint8_t menu_item_sddir(const char* str, const char* str_fn, char* str_fnl); + +//#define MENU_ITEM_SDFILE(str, str_fn, str_fnl) do { if (menu_item_sdfile(str, str_fn, str_fnl)) return; } while (0) +#define MENU_ITEM_SDFILE(str, str_fn, str_fnl) MENU_ITEM(sdfile, str, str_fn, str_fnl) +//extern uint8_t menu_item_sdfile(const char* str, const char* str_fn, char* str_fnl); + + uint8_t menu_item_sddir(const char* str, const char* str_fn, char* str_fnl) { // str_fnl[18] = 0; -// printf_P(_N("menu dir %d '%s' '%s'\n"), menu_row, str_fn, str_fnl); +// printf_P(PSTR("menu dir %d '%s' '%s'\n"), menu_row, str_fn, str_fnl); if (menu_item == menu_line) { - if (lcdDrawUpdate) + if (lcd_draw_update) { - lcd.setCursor(0, menu_row); - int cnt = lcd_printf_P(_N("%c%c%-18s"), (encoderPosition == menu_item)?'>':' ', LCD_STR_FOLDER[0], str_fnl[0]?str_fnl:str_fn); -// int cnt = lcd_printf_P(_N("%c%c%-18s"), (encoderPosition == menu_item)?'>':' ', LCD_STR_FOLDER[0], str_fn); + lcd_set_cursor(0, menu_row); + int cnt = lcd_printf_P(PSTR("%c%c%-18s"), (lcd_encoder == menu_item)?'>':' ', LCD_STR_FOLDER[0], str_fnl[0]?str_fnl:str_fn); +// int cnt = lcd_printf_P(PSTR("%c%c%-18s"), (lcd_encoder == menu_item)?'>':' ', LCD_STR_FOLDER[0], str_fn); } - if (wasClicked && (encoderPosition == menu_item)) + if (menu_clicked && (lcd_encoder == menu_item)) { uint8_t depth = (uint8_t)card.getWorkDirDepth(); strcpy(dir_names[depth], str_fn); // printf_P(PSTR("%s\n"), dir_names[depth]); card.chdir(str_fn); - encoderPosition = 0; + lcd_encoder = 0; return menu_item_ret(); } } @@ -591,42 +501,40 @@ uint8_t menu_item_sddir(const char* str, const char* str_fn, char* str_fnl) return 0; } -//#define MENU_ITEM_SDFILE(str, str_fn, str_fnl) do { if (menu_item_sdfile(str, str_fn, str_fnl)) return; } while (0) -#define MENU_ITEM_SDFILE(str, str_fn, str_fnl) MENU_ITEM(sdfile, str, str_fn, str_fnl) uint8_t menu_item_sdfile(const char* str, const char* str_fn, char* str_fnl) { -// printf_P(_N("menu sdfile\n")); +// printf_P(PSTR("menu sdfile\n")); // str_fnl[19] = 0; -// printf_P(_N("menu file %d '%s' '%s'\n"), menu_row, str_fn, str_fnl); +// printf_P(PSTR("menu file %d '%s' '%s'\n"), menu_row, str_fn, str_fnl); if (menu_item == menu_line) { - if (lcdDrawUpdate) + if (lcd_draw_update) { -// printf_P(_N("menu file %d %d '%s'\n"), menu_row, menuData.sdcard_menu.viewState, str_fnl[0]?str_fnl:str_fn); - lcd.setCursor(0, menu_row); -/* if (encoderPosition == menu_item) +// printf_P(PSTR("menu file %d %d '%s'\n"), menu_row, menuData.sdcard_menu.viewState, str_fnl[0]?str_fnl:str_fn); + lcd_set_cursor(0, menu_row); +/* if (lcd_encoder == menu_item) { - lcd_printf_P(_N("%c%-19s"), (encoderPosition == menu_item)?'>':' ', (str_fnl[0]?str_fnl:str_fn) + 1); + lcd_printf_P(PSTR("%c%-19s"), (lcd_encoder == menu_item)?'>':' ', (str_fnl[0]?str_fnl:str_fn) + 1); if (menuData.sdcard_menu.viewState == 0) { menuData.sdcard_menu.viewState++; - lcd_printf_P(_N("%c%-19s"), (encoderPosition == menu_item)?'>':' ', (str_fnl[0]?str_fnl:str_fn) + 1); + lcd_printf_P(PSTR("%c%-19s"), (lcd_encoder == menu_item)?'>':' ', (str_fnl[0]?str_fnl:str_fn) + 1); } else if (menuData.sdcard_menu.viewState == 1) { - lcd_printf_P(_N("%c%-19s"), (encoderPosition == menu_item)?'>':' ', (str_fnl[0]?str_fnl:str_fn) + 2); + lcd_printf_P(PSTR("%c%-19s"), (lcd_encoder == menu_item)?'>':' ', (str_fnl[0]?str_fnl:str_fn) + 2); } } else*/ { str_fnl[19] = 0; - lcd_printf_P(_N("%c%-19s"), (encoderPosition == menu_item)?'>':' ', str_fnl[0]?str_fnl:str_fn); + lcd_printf_P(PSTR("%c%-19s"), (lcd_encoder == menu_item)?'>':' ', str_fnl[0]?str_fnl:str_fn); } -// int cnt = lcd_printf_P(_N("%c%-19s"), (encoderPosition == menu_item)?'>':' ', str_fnl); -// int cnt = lcd_printf_P(_N("%cTESTIK.gcode"), (encoderPosition == menu_item)?'>':' '); +// int cnt = lcd_printf_P(PSTR("%c%-19s"), (lcd_encoder == menu_item)?'>':' ', str_fnl); +// int cnt = lcd_printf_P(PSTR("%cTESTIK.gcode"), (lcd_encoder == menu_item)?'>':' '); } - if (wasClicked && (encoderPosition == menu_item)) + if (menu_clicked && (lcd_encoder == menu_item)) { return menu_item_ret(); } @@ -635,54 +543,361 @@ uint8_t menu_item_sdfile(const char* str, const char* str_fn, char* str_fnl) return 0; } -const char menu_fmt_int3[] PROGMEM = "%c%S:\x1b[%hhu;16H%3d"; -void _menu_edit_int3(void) + + + + + + + +/* + +20x4 |01234567890123456789| + |T 000/000D Z000.0 | + |B 000/000D F100% | + |SD100% T--:-- | + |Status line.........| +*/ +static void lcd_implementation_status_screen() { - if (lcdDrawUpdate) + + int tHotend=int(degHotend(0) + 0.5); + int tTarget=int(degTargetHotend(0) + 0.5); + + //Print the hotend temperature + lcd.setCursor(0, 0); + lcd.print(LCD_STR_THERMOMETER[0]); + lcd.print(itostr3(tHotend)); + lcd.print('/'); + lcd.print(itostr3left(tTarget)); + lcd_printPGM(PSTR(LCD_STR_DEGREE " ")); + lcd_printPGM(PSTR(" ")); + + //Print the Z coordinates + lcd.setCursor(LCD_WIDTH - 8-2, 0); +#if 1 + lcd_printPGM(PSTR(" Z")); + if (custom_message_type == 1) { + // In a bed calibration mode. + lcd_printPGM(PSTR(" --- ")); + } else { + lcd.print(ftostr32sp(current_position[Z_AXIS] + 0.00001)); + lcd.print(' '); + } +#else + lcd_printPGM(PSTR(" Queue:")); + lcd.print(int(moves_planned())); + lcd.print(' '); +#endif + + //Print the Bedtemperature + lcd.setCursor(0, 1); + tHotend=int(degBed() + 0.5); + tTarget=int(degTargetBed() + 0.5); + lcd.print(LCD_STR_BEDTEMP[0]); + lcd.print(itostr3(tHotend)); + lcd.print('/'); + lcd.print(itostr3left(tTarget)); + lcd_printPGM(PSTR(LCD_STR_DEGREE " ")); + lcd_printPGM(PSTR(" ")); + +#ifdef PLANNER_DIAGNOSTICS + //Print Feedrate + lcd.setCursor(LCD_WIDTH - 8-2, 1); + lcd.print(LCD_STR_FEEDRATE[0]); + lcd.print(itostr3(feedmultiply)); + lcd_printPGM(PSTR("% Q")); + { + uint8_t queue = planner_queue_min(); + if (queue < (BLOCK_BUFFER_SIZE >> 1)) { + lcd.write('!'); + } else { + lcd.write((char)(queue / 10) + '0'); + queue %= 10; + } + lcd.write((char)queue + '0'); + planner_queue_min_reset(); + } +#else /* PLANNER_DIAGNOSTICS */ + //Print Feedrate + lcd.setCursor(LCD_WIDTH - 8-2, 1); + lcd_printPGM(PSTR(" ")); + lcd.print(LCD_STR_FEEDRATE[0]); + lcd.print(itostr3(feedmultiply)); + lcd_printPGM(PSTR("% ")); +#endif /* PLANNER_DIAGNOSTICS */ + + bool print_sd_status = true; + +#ifdef PINDA_THERMISTOR +// if (farm_mode && (custom_message_type == 4)) + if (false) { - if (encoderPosition < menuData.editMenuParentState.minEditValue) encoderPosition = menuData.editMenuParentState.minEditValue; - if (encoderPosition > menuData.editMenuParentState.maxEditValue) encoderPosition = menuData.editMenuParentState.maxEditValue; - lcd.setCursor(0, 1); - lcd_printf_P(menu_fmt_int3, ' ', menuData.editMenuParentState.editLabel, (uint8_t)1, (int)encoderPosition); - } - if (LCD_CLICKED) - { - *((int*)(menuData.editMenuParentState.editValue)) = (int)encoderPosition; - menu_back(); + lcd.setCursor(0, 2); + lcd_printPGM(PSTR("P")); + lcd.print(ftostr3(current_temperature_pinda)); + lcd_printPGM(PSTR(LCD_STR_DEGREE " ")); + print_sd_status = false; } +#endif //PINDA_THERMISTOR + + +if (print_sd_status) +{ + //Print SD status + lcd.setCursor(0, 2); + lcd_print_percent_done(); + } -#define MENU_ITEM_EDIT_P_int3(str, pval, minval, maxval, fmt) do { if (menu_item_edit_int16(str, pval, minval, maxval, fmt)) return; } while (0) -uint8_t menu_item_edit_int3(const char* str, int16_t* pval, int16_t min_val, int16_t max_val) -{ - if (menu_item == menu_line) + // Farm number display + if (farm_mode) { - if (lcdDrawUpdate) + lcd.setCursor(6, 2); + lcd_printPGM(PSTR(" F")); + lcd.print(farm_no); + lcd_printPGM(PSTR(" ")); + + // Beat display + lcd.setCursor(LCD_WIDTH - 1, 0); + if ( (millis() - kicktime) < 60000 ) { + + lcd_printPGM(PSTR("L")); + + }else{ + lcd_printPGM(PSTR(" ")); + } + + } + else { +#ifdef SNMM + lcd_printPGM(PSTR(" E")); + lcd.print(get_ext_nr() + 1); + +#else + lcd.setCursor(LCD_WIDTH - 8 - 2, 2); + lcd_printPGM(PSTR(" ")); +#endif + } + +#ifdef CMD_DIAGNOSTICS + lcd.setCursor(LCD_WIDTH - 8 -1, 2); + lcd_printPGM(PSTR(" C")); + lcd.print(buflen); // number of commands in cmd buffer + if (buflen < 9) lcd_printPGM(" "); +#else + //Print time + lcd.setCursor(LCD_WIDTH - 8, 2); + lcd_print_time(); +#endif //CMD_DIAGNOSTICS + +#ifdef DEBUG_DISABLE_LCD_STATUS_LINE + return; +#endif //DEBUG_DISABLE_LCD_STATUS_LINE + + //Print status line + lcd.setCursor(0, 3); + + // If heating in progress, set flag + if (heating_status != 0) { custom_message = true; } + + if (IS_SD_PRINTING) { + if (strcmp(longFilenameOLD, card.longFilename) != 0) { - lcd.setCursor(0, menu_row); - lcd_printf_P(menu_fmt_int3, (encoderPosition == menu_item)?'>':' ', str, menu_row, *pval); - } - if (wasClicked && (encoderPosition == menu_item)) - { - menu_submenu(_menu_edit_int3); - menuData.editMenuParentState.editLabel = str; - menuData.editMenuParentState.editValue = pval; - menuData.editMenuParentState.minEditValue = min_val; - menuData.editMenuParentState.maxEditValue = max_val; - encoderPosition = *pval; - return menu_item_ret(); + memset(longFilenameOLD, '\0', strlen(longFilenameOLD)); + sprintf_P(longFilenameOLD, PSTR("%s"), card.longFilename); + scrollstuff = 0; } } - menu_item++; - return 0; + + // If printing from SD, show what we are printing + if ((IS_SD_PRINTING) && !custom_message +#ifdef DEBUG_BUILD + && lcd_status_message[0] == 0 +#endif /* DEBUG_BUILD */ + ) + + { + if(strlen(card.longFilename) > LCD_WIDTH) + { + + int inters = 0; + int gh = scrollstuff; + while (((gh - scrollstuff) < LCD_WIDTH) && (inters == 0)) + { + + if (card.longFilename[gh] == '\0') + { + lcd.setCursor(gh - scrollstuff, 3); + lcd.print(card.longFilename[gh - 1]); + scrollstuff = 0; + gh = scrollstuff; + inters = 1; + } + else + { + lcd.setCursor(gh - scrollstuff, 3); + lcd.print(card.longFilename[gh - 1]); + gh++; + } + + + } + scrollstuff++; + } + else + { + lcd.print(longFilenameOLD); + } + } + + // If not, check for other special events + else + { + + if (custom_message) + { + // If heating flag, show progress of heating. + if (heating_status != 0) + { + heating_status_counter++; + if (heating_status_counter > 13) + { + heating_status_counter = 0; + } + lcd.setCursor(7, 3); + lcd_printPGM(PSTR(" ")); + + for (int dots = 0; dots < heating_status_counter; dots++) + { + lcd.setCursor(7 + dots, 3); + lcd.print('.'); + } + + switch (heating_status) + { + case 1: + lcd.setCursor(0, 3); + lcd_printPGM(_T(MSG_HEATING)); + break; + case 2: + lcd.setCursor(0, 3); + lcd_printPGM(_T(MSG_HEATING_COMPLETE)); + heating_status = 0; + heating_status_counter = 0; + custom_message = false; + break; + case 3: + lcd.setCursor(0, 3); + lcd_printPGM(_T(MSG_BED_HEATING)); + break; + case 4: + lcd.setCursor(0, 3); + lcd_printPGM(_T(MSG_BED_DONE)); + heating_status = 0; + heating_status_counter = 0; + custom_message = false; + break; + default: + break; + } + } + + // If mesh bed leveling in progress, show the status + + if (custom_message_type == 1) + { + if (custom_message_state > 10) + { + lcd.setCursor(0, 3); + lcd_printPGM(PSTR(" ")); + lcd.setCursor(0, 3); + lcd_printPGM(_T(MSG_CALIBRATE_Z_AUTO)); + lcd_printPGM(PSTR(" : ")); + lcd.print(custom_message_state-10); + } + else + { + if (custom_message_state == 3) + { + lcd_printPGM(_T(WELCOME_MSG)); + lcd_setstatuspgm(_T(WELCOME_MSG)); + custom_message = false; + custom_message_type = 0; + } + if (custom_message_state > 3 && custom_message_state <= 10 ) + { + lcd.setCursor(0, 3); + lcd_printPGM(PSTR(" ")); + lcd.setCursor(0, 3); + lcd_printPGM(_i("Calibration done"));////MSG_HOMEYZ_DONE c=0 r=0 + custom_message_state--; + } + } + + } + // If loading filament, print status + if (custom_message_type == 2) + { + lcd.print(lcd_status_message); + } + // PID tuning in progress + if (custom_message_type == 3) { + lcd.print(lcd_status_message); + if (pid_cycle <= pid_number_of_cycles && custom_message_state > 0) { + lcd.setCursor(10, 3); + lcd.print(itostr3(pid_cycle)); + + lcd.print('/'); + lcd.print(itostr3left(pid_number_of_cycles)); + } + } + // PINDA temp calibration in progress + if (custom_message_type == 4) { + char progress[4]; + lcd.setCursor(0, 3); + lcd_printPGM(_T(MSG_TEMP_CALIBRATION)); + lcd.setCursor(12, 3); + sprintf(progress, "%d/6", custom_message_state); + lcd.print(progress); + } + // temp compensation preheat + if (custom_message_type == 5) { + lcd.setCursor(0, 3); + lcd_printPGM(_i("PINDA Heating"));////MSG_PINDA_PREHEAT c=20 r=1 + if (custom_message_state <= PINDA_HEAT_T) { + lcd_printPGM(PSTR(": ")); + lcd.print(custom_message_state); //seconds + lcd.print(' '); + + } + } + + + } + else + { + // Nothing special, print status message normally + lcd.print(lcd_status_message); + } + } + + // Fill the rest of line to have nice and clean output + for(int fillspace = 0; fillspace<20;fillspace++) + { + if((lcd_status_message[fillspace] > 31 )) + { + } + else + { + lcd.print(' '); + } + } + } - - - - /* Main status screen. It's up to the implementation specific part to show what is needed. As this is very display dependent */ static void lcd_status_screen() @@ -707,8 +922,8 @@ static void lcd_status_screen() if (lcd_status_update_delay) lcd_status_update_delay--; else - lcdDrawUpdate = 1; - if (lcdDrawUpdate) + lcd_draw_update = 1; + if (lcd_draw_update) { ReInitLCD++; @@ -767,8 +982,7 @@ static void lcd_status_screen() } - } // end of lcdDrawUpdate -#ifdef ULTIPANEL + } // end of lcd_draw_update bool current_click = LCD_CLICKED; @@ -797,27 +1011,27 @@ static void lcd_status_screen() #ifdef ULTIPANEL_FEEDMULTIPLY // Dead zone at 100% feedrate - if ((feedmultiply < 100 && (feedmultiply + int(encoderPosition)) > 100) || - (feedmultiply > 100 && (feedmultiply + int(encoderPosition)) < 100)) + if ((feedmultiply < 100 && (feedmultiply + int(lcd_encoder)) > 100) || + (feedmultiply > 100 && (feedmultiply + int(lcd_encoder)) < 100)) { - encoderPosition = 0; + lcd_encoder = 0; feedmultiply = 100; } - if (feedmultiply == 100 && int(encoderPosition) > ENCODER_FEEDRATE_DEADZONE) + if (feedmultiply == 100 && int(lcd_encoder) > ENCODER_FEEDRATE_DEADZONE) { - feedmultiply += int(encoderPosition) - ENCODER_FEEDRATE_DEADZONE; - encoderPosition = 0; + feedmultiply += int(lcd_encoder) - ENCODER_FEEDRATE_DEADZONE; + lcd_encoder = 0; } - else if (feedmultiply == 100 && int(encoderPosition) < -ENCODER_FEEDRATE_DEADZONE) + else if (feedmultiply == 100 && int(lcd_encoder) < -ENCODER_FEEDRATE_DEADZONE) { - feedmultiply += int(encoderPosition) + ENCODER_FEEDRATE_DEADZONE; - encoderPosition = 0; + feedmultiply += int(lcd_encoder) + ENCODER_FEEDRATE_DEADZONE; + lcd_encoder = 0; } else if (feedmultiply != 100) { - feedmultiply += int(encoderPosition); - encoderPosition = 0; + feedmultiply += int(lcd_encoder); + lcd_encoder = 0; } #endif //ULTIPANEL_FEEDMULTIPLY @@ -825,7 +1039,6 @@ static void lcd_status_screen() feedmultiply = 10; else if (feedmultiply > 999) feedmultiply = 999; -#endif //ULTIPANEL /*if (farm_mode && !printer_connected) { lcd.setCursor(0, 3); @@ -846,7 +1059,6 @@ static void lcd_status_screen() } -#ifdef ULTIPANEL void lcd_commands() { @@ -856,7 +1068,7 @@ void lcd_commands() if (card.sdprinting) { card.pauseSDPrint(); lcd_setstatuspgm(_T(MSG_FINISHING_MOVEMENTS)); - lcdDrawUpdate = 3; + lcd_draw_update = 3; lcd_commands_step = 1; } else { @@ -877,7 +1089,7 @@ void lcd_commands() char cmd1[30]; if (lcd_commands_step == 0) { - lcdDrawUpdate = 3; + lcd_draw_update = 3; lcd_commands_step = 4; } if (lcd_commands_step == 1 && !blocks_queued() && cmd_buffer_empty()) { //recover feedmultiply; cmd_buffer_empty() ensures that card.sdprinting is synchronized with buffered commands and thus print cant be paused until resume is finished @@ -985,7 +1197,7 @@ void lcd_commands() enquecommand_P(PSTR("G1 F4000")); lcd_implementation_clear(); - lcd_goto_menu(lcd_babystep_z, 0, false); + menu_goto(lcd_babystep_z, 0, false, true); lcd_commands_step = 8; @@ -1581,7 +1793,7 @@ void lcd_commands() custom_message_type = 3; custom_message_state = 1; custom_message = true; - lcdDrawUpdate = 3; + lcd_draw_update = 3; lcd_commands_step = 3; } if (lcd_commands_step == 3 && !blocks_queued()) { //PID calibration @@ -1633,7 +1845,7 @@ static float count_e(float layer_heigth, float extrusion_width, float extrusion_ static void lcd_return_to_status() { lcd_implementation_init(); // to maybe revive the LCD if static electricity killed it. - lcd_goto_menu(lcd_status_screen, 0, false); + menu_goto(lcd_status_screen, 0, false, true); menu_depth = 0; } @@ -1955,7 +2167,7 @@ static void lcd_preheat_menu() static void lcd_support_menu() { - if (menuData.supportMenu.status == 0 || lcdDrawUpdate == 2) { + if (menuData.supportMenu.status == 0 || lcd_draw_update == 2) { // Menu was entered or SD card status has changed (plugged in or removed). // Initialize its status. menuData.supportMenu.status = 1; @@ -2194,21 +2406,21 @@ void lcd_alright() { lcd.print(">"); - enc_dif = encoderDiff; + enc_dif = lcd_encoder_diff; while (lcd_change_fil_state == 0) { manage_heater(); manage_inactivity(true); - if ( abs((enc_dif - encoderDiff)) > 4 ) { + if ( abs((enc_dif - lcd_encoder_diff)) > 4 ) { - if ( (abs(enc_dif - encoderDiff)) > 1 ) { - if (enc_dif > encoderDiff ) { + if ( (abs(enc_dif - lcd_encoder_diff)) > 1 ) { + if (enc_dif > lcd_encoder_diff ) { cursor_pos --; } - if (enc_dif < encoderDiff ) { + if (enc_dif < lcd_encoder_diff ) { cursor_pos ++; } @@ -2227,7 +2439,7 @@ void lcd_alright() { lcd.print(" "); lcd.setCursor(0, cursor_pos); lcd.print(">"); - enc_dif = encoderDiff; + enc_dif = lcd_encoder_diff; delay(100); } @@ -2377,19 +2589,19 @@ static void _lcd_move(const char *name, int axis, int min, int max) { menuData._lcd_moveMenu.initialized = true; } - if (encoderPosition != 0) { + if (lcd_encoder != 0) { refresh_cmd_timeout(); if (! planner_queue_full()) { - current_position[axis] += float((int)encoderPosition) * move_menu_scale; + current_position[axis] += float((int)lcd_encoder) * 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; + lcd_encoder = 0; world2machine_clamp(current_position[X_AXIS], current_position[Y_AXIS]); 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); - lcdDrawUpdate = 1; + lcd_draw_update = 1; } } - if (lcdDrawUpdate) lcd_implementation_drawedit(name, ftostr31(current_position[axis])); + if (lcd_draw_update) lcd_implementation_drawedit(name, ftostr31(current_position[axis])); if (menuExiting || LCD_CLICKED) (void)enable_endstops(menuData._lcd_moveMenu.endstopsEnabledPrevious); if (LCD_CLICKED) menu_back(); } @@ -2398,17 +2610,17 @@ static void _lcd_move(const char *name, int axis, int min, int max) { static void lcd_move_e() { if (degHotend0() > EXTRUDE_MINTEMP) { - if (encoderPosition != 0) + if (lcd_encoder != 0) { refresh_cmd_timeout(); if (! planner_queue_full()) { - current_position[E_AXIS] += float((int)encoderPosition) * move_menu_scale; - encoderPosition = 0; + current_position[E_AXIS] += float((int)lcd_encoder) * move_menu_scale; + lcd_encoder = 0; plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], manual_feedrate[E_AXIS] / 60, active_extruder); - lcdDrawUpdate = 1; + lcd_draw_update = 1; } } - if (lcdDrawUpdate) + if (lcd_draw_update) { lcd_implementation_drawedit(PSTR("Extruder"), ftostr31(current_position[E_AXIS])); } @@ -2460,7 +2672,7 @@ static void lcd_menu_xyz_y_min() else lcd_printf_P(_N("%6.2fmm"), distanceMin[i]); } if (lcd_clicked()) - lcd_goto_menu(lcd_menu_xyz_skew); + menu_goto(lcd_menu_xyz_skew, 0, true, true); } /** * @brief Show measured axis skewness @@ -2496,7 +2708,7 @@ static void lcd_menu_xyz_skew() else lcd_puts_P(_N(ESC_H(15,0)"N/A")); if (lcd_clicked()) - lcd_goto_menu(lcd_menu_xyz_offset); + menu_goto(lcd_menu_xyz_offset, 0, true, true); } /** * @brief Show measured bed offset from expected position @@ -2526,20 +2738,14 @@ static void lcd_menu_xyz_offset() // Save a single axis babystep value. void EEPROM_save_B(int pos, int* value) { - union Data data; - data.value = *value; - - eeprom_update_byte((unsigned char*)pos, data.b[0]); - eeprom_update_byte((unsigned char*)pos + 1, data.b[1]); + eeprom_update_byte((unsigned char*)pos, (unsigned char)((*value) & 0xff)); + eeprom_update_byte((unsigned char*)pos + 1, (unsigned char)((*value) >> 8)); } // Read a single axis babystep value. void EEPROM_read_B(int pos, int* value) { - union Data data; - data.b[0] = eeprom_read_byte((unsigned char*)pos); - data.b[1] = eeprom_read_byte((unsigned char*)pos + 1); - *value = data.value; + *value = (int)eeprom_read_byte((unsigned char*)pos) | (int)(eeprom_read_byte((unsigned char*)pos + 1) << 8); } @@ -2580,33 +2786,33 @@ static void _lcd_babystep(int axis, const char *msg) menuData.babyStep.babystepMemMM[0] = menuData.babyStep.babystepMem[0]/axis_steps_per_unit[X_AXIS]; menuData.babyStep.babystepMemMM[1] = menuData.babyStep.babystepMem[1]/axis_steps_per_unit[Y_AXIS]; menuData.babyStep.babystepMemMM[2] = menuData.babyStep.babystepMem[2]/axis_steps_per_unit[Z_AXIS]; - lcdDrawUpdate = 1; + lcd_draw_update = 1; //SERIAL_ECHO("Z baby step: "); //SERIAL_ECHO(menuData.babyStep.babystepMem[2]); // Wait 90 seconds before closing the live adjust dialog. lcd_timeoutToStatus = millis() + 90000; } - if (encoderPosition != 0) + if (lcd_encoder != 0) { - if (homing_flag) encoderPosition = 0; + if (homing_flag) lcd_encoder = 0; - menuData.babyStep.babystepMem[axis] += (int)encoderPosition; + menuData.babyStep.babystepMem[axis] += (int)lcd_encoder; if (axis == 2) { if (menuData.babyStep.babystepMem[axis] < Z_BABYSTEP_MIN) menuData.babyStep.babystepMem[axis] = Z_BABYSTEP_MIN; //-3999 -> -9.99 mm else if (menuData.babyStep.babystepMem[axis] > Z_BABYSTEP_MAX) menuData.babyStep.babystepMem[axis] = Z_BABYSTEP_MAX; //0 else { CRITICAL_SECTION_START - babystepsTodo[axis] += (int)encoderPosition; + babystepsTodo[axis] += (int)lcd_encoder; CRITICAL_SECTION_END } } menuData.babyStep.babystepMemMM[axis] = menuData.babyStep.babystepMem[axis]/axis_steps_per_unit[axis]; delay(50); - encoderPosition = 0; - lcdDrawUpdate = 1; + lcd_encoder = 0; + lcd_draw_update = 1; } - if (lcdDrawUpdate) + if (lcd_draw_update) lcd_implementation_drawedit_2(msg, ftostr13ns(menuData.babyStep.babystepMemMM[axis])); if (LCD_CLICKED || menuExiting) { // Only update the EEPROM when leaving the menu. @@ -2678,7 +2884,7 @@ static void lcd_adjust_bed() menuData.adjustBed.front2 = 0; menuData.adjustBed.rear2 = 0; } - lcdDrawUpdate = 1; + lcd_draw_update = 1; eeprom_update_byte((unsigned char*)EEPROM_BED_CORRECTION_VALID, 1); } @@ -2693,10 +2899,10 @@ static void lcd_adjust_bed() MENU_BEGIN(); MENU_ITEM_BACK_P(_T(MSG_SETTINGS)); - MENU_ITEM_EDIT(int3, _i("Left side [um]"), &menuData.adjustBed.left2, -BED_ADJUSTMENT_UM_MAX, BED_ADJUSTMENT_UM_MAX);////MSG_BED_CORRECTION_LEFT c=14 r=1 - MENU_ITEM_EDIT(int3, _i("Right side[um]"), &menuData.adjustBed.right2, -BED_ADJUSTMENT_UM_MAX, BED_ADJUSTMENT_UM_MAX);////MSG_BED_CORRECTION_RIGHT c=14 r=1 - MENU_ITEM_EDIT(int3, _i("Front side[um]"), &menuData.adjustBed.front2, -BED_ADJUSTMENT_UM_MAX, BED_ADJUSTMENT_UM_MAX);////MSG_BED_CORRECTION_FRONT c=14 r=1 - MENU_ITEM_EDIT(int3, _i("Rear side [um]"), &menuData.adjustBed.rear2, -BED_ADJUSTMENT_UM_MAX, BED_ADJUSTMENT_UM_MAX);////MSG_BED_CORRECTION_REAR c=14 r=1 + MENU_ITEM_EDIT_int3_P(_i("Left side [um]"), &menuData.adjustBed.left2, -BED_ADJUSTMENT_UM_MAX, BED_ADJUSTMENT_UM_MAX);////MSG_BED_CORRECTION_LEFT c=14 r=1 + MENU_ITEM_EDIT_int3_P(_i("Right side[um]"), &menuData.adjustBed.right2, -BED_ADJUSTMENT_UM_MAX, BED_ADJUSTMENT_UM_MAX);////MSG_BED_CORRECTION_RIGHT c=14 r=1 + MENU_ITEM_EDIT_int3_P(_i("Front side[um]"), &menuData.adjustBed.front2, -BED_ADJUSTMENT_UM_MAX, BED_ADJUSTMENT_UM_MAX);////MSG_BED_CORRECTION_FRONT c=14 r=1 + MENU_ITEM_EDIT_int3_P(_i("Rear side [um]"), &menuData.adjustBed.rear2, -BED_ADJUSTMENT_UM_MAX, BED_ADJUSTMENT_UM_MAX);////MSG_BED_CORRECTION_REAR c=14 r=1 MENU_ITEM_FUNCTION_P(_i("Reset"), lcd_adjust_bed_reset);////MSG_BED_CORRECTION_RESET c=0 r=0 MENU_END(); } @@ -2706,10 +2912,10 @@ void pid_extruder() { lcd_implementation_clear(); lcd.setCursor(1, 0); lcd_printPGM(_i("Set temperature:"));////MSG_SET_TEMPERATURE c=19 r=1 - pid_temp += int(encoderPosition); + pid_temp += int(lcd_encoder); if (pid_temp > HEATER_0_MAXTEMP) pid_temp = HEATER_0_MAXTEMP; if (pid_temp < HEATER_0_MINTEMP) pid_temp = HEATER_0_MINTEMP; - encoderPosition = 0; + lcd_encoder = 0; lcd.setCursor(1, 2); lcd.print(ftostr3(pid_temp)); if (lcd_clicked()) { @@ -2743,21 +2949,21 @@ void lcd_adjust_z() { lcd.print(">"); - enc_dif = encoderDiff; + enc_dif = lcd_encoder_diff; while (fsm == 0) { manage_heater(); manage_inactivity(true); - if ( abs((enc_dif - encoderDiff)) > 4 ) { + if ( abs((enc_dif - lcd_encoder_diff)) > 4 ) { - if ( (abs(enc_dif - encoderDiff)) > 1 ) { - if (enc_dif > encoderDiff ) { + if ( (abs(enc_dif - lcd_encoder_diff)) > 1 ) { + if (enc_dif > lcd_encoder_diff ) { cursor_pos --; } - if (enc_dif < encoderDiff ) { + if (enc_dif < lcd_encoder_diff ) { cursor_pos ++; } @@ -2774,7 +2980,7 @@ void lcd_adjust_z() { lcd.print(" "); lcd.setCursor(0, cursor_pos); lcd.print(">"); - enc_dif = encoderDiff; + enc_dif = lcd_encoder_diff; delay(100); } @@ -2891,22 +3097,22 @@ bool lcd_calibrate_z_end_stop_manual(bool only_z) const bool multi_screen = msg_next != NULL; unsigned long previous_millis_msg = millis(); // Until the user finishes the z up movement. - encoderDiff = 0; - encoderPosition = 0; + lcd_encoder_diff = 0; + lcd_encoder = 0; for (;;) { // if (millis() - previous_millis_cmd > LCD_TIMEOUT_TO_STATUS) // goto canceled; manage_heater(); manage_inactivity(true); - if (abs(encoderDiff) >= ENCODER_PULSES_PER_STEP) { + if (abs(lcd_encoder_diff) >= ENCODER_PULSES_PER_STEP) { delay(50); previous_millis_cmd = millis(); - encoderPosition += abs(encoderDiff / ENCODER_PULSES_PER_STEP); - encoderDiff = 0; + lcd_encoder += abs(lcd_encoder_diff / ENCODER_PULSES_PER_STEP); + lcd_encoder_diff = 0; if (! planner_queue_full()) { // Only move up, whatever direction the user rotates the encoder. - current_position[Z_AXIS] += fabs(encoderPosition); - encoderPosition = 0; + current_position[Z_AXIS] += fabs(lcd_encoder); + lcd_encoder = 0; plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], manual_feedrate[Z_AXIS] / 60, active_extruder); } } @@ -3044,7 +3250,7 @@ static const char* lcd_display_message_fullscreen_nonBlocking_P(const char *msg, const char* lcd_display_message_fullscreen_P(const char *msg, uint8_t &nlines) { - // Disable update of the screen by the usual lcd_update() routine. + // Disable update of the screen by the usual lcd_update(0) routine. lcd_update_enable(false); lcd_implementation_clear(); return lcd_display_message_fullscreen_nonBlocking_P(msg, nlines); @@ -3127,7 +3333,7 @@ int8_t lcd_show_multiscreen_message_yes_no_and_wait_P(const char *msg, bool allo // Wait for user confirmation or a timeout. unsigned long previous_millis_cmd = millis(); - int8_t enc_dif = encoderDiff; + int8_t enc_dif = lcd_encoder_diff; //KEEPALIVE_STATE(PAUSED_FOR_USER); for (;;) { for (uint8_t i = 0; i < 100; ++i) { @@ -3137,22 +3343,22 @@ int8_t lcd_show_multiscreen_message_yes_no_and_wait_P(const char *msg, bool allo manage_heater(); manage_inactivity(true); - if (abs(enc_dif - encoderDiff) > 4) { + if (abs(enc_dif - lcd_encoder_diff) > 4) { if (msg_next == NULL) { lcd.setCursor(0, 3); - if (enc_dif < encoderDiff && yes) { + if (enc_dif < lcd_encoder_diff && yes) { lcd_printPGM((PSTR(" "))); lcd.setCursor(7, 3); lcd_printPGM((PSTR(">"))); yes = false; } - else if (enc_dif > encoderDiff && !yes) { + else if (enc_dif > lcd_encoder_diff && !yes) { lcd_printPGM((PSTR(">"))); lcd.setCursor(7, 3); lcd_printPGM((PSTR(" "))); yes = true; } - enc_dif = encoderDiff; + enc_dif = lcd_encoder_diff; } else { break; //turning knob skips waiting loop @@ -3212,28 +3418,28 @@ int8_t lcd_show_fullscreen_message_yes_no_and_wait_P(const char *msg, bool allow // Wait for user confirmation or a timeout. unsigned long previous_millis_cmd = millis(); - int8_t enc_dif = encoderDiff; + int8_t enc_dif = lcd_encoder_diff; KEEPALIVE_STATE(PAUSED_FOR_USER); for (;;) { if (allow_timeouting && millis() - previous_millis_cmd > LCD_TIMEOUT_TO_STATUS) return -1; manage_heater(); manage_inactivity(true); - if (abs(enc_dif - encoderDiff) > 4) { + if (abs(enc_dif - lcd_encoder_diff) > 4) { lcd.setCursor(0, 2); - if (enc_dif < encoderDiff && yes) { + if (enc_dif < lcd_encoder_diff && yes) { lcd_printPGM((PSTR(" "))); lcd.setCursor(0, 3); lcd_printPGM((PSTR(">"))); yes = false; } - else if (enc_dif > encoderDiff && !yes) { + else if (enc_dif > lcd_encoder_diff && !yes) { lcd_printPGM((PSTR(">"))); lcd.setCursor(0, 3); lcd_printPGM((PSTR(" "))); yes = true; } - enc_dif = encoderDiff; + enc_dif = lcd_encoder_diff; } if (lcd_clicked()) { while (lcd_clicked()); @@ -3348,7 +3554,7 @@ static void menu_show_end_stops() { // Otherwise the Z calibration is not changed and false is returned. void lcd_diag_show_end_stops() { - int enc_dif = encoderDiff; + int enc_dif = lcd_encoder_diff; lcd_implementation_clear(); for (;;) { manage_heater(); @@ -3617,21 +3823,21 @@ void lcd_pick_babystep(){ lcd.print(">"); - enc_dif = encoderDiff; + enc_dif = lcd_encoder_diff; while (fsm == 0) { manage_heater(); manage_inactivity(true); - if ( abs((enc_dif - encoderDiff)) > 4 ) { + if ( abs((enc_dif - lcd_encoder_diff)) > 4 ) { - if ( (abs(enc_dif - encoderDiff)) > 1 ) { - if (enc_dif > encoderDiff ) { + if ( (abs(enc_dif - lcd_encoder_diff)) > 1 ) { + if (enc_dif > lcd_encoder_diff ) { cursor_pos --; } - if (enc_dif < encoderDiff ) { + if (enc_dif < lcd_encoder_diff ) { cursor_pos ++; } @@ -3662,7 +3868,7 @@ void lcd_pick_babystep(){ } - enc_dif = encoderDiff; + enc_dif = lcd_encoder_diff; delay(100); } @@ -3836,8 +4042,8 @@ static void lcd_crash_mode_set() }else{ crashdet_enable(); } - if (IS_SD_PRINTING || is_usb_printing || (lcd_commands_type == LCD_COMMAND_V2_CAL)) lcd_goto_menu(lcd_tune_menu, 9); - else lcd_goto_menu(lcd_settings_menu, 9); + if (IS_SD_PRINTING || is_usb_printing || (lcd_commands_type == LCD_COMMAND_V2_CAL)) menu_goto(lcd_tune_menu, 9, true, true); + else menu_goto(lcd_settings_menu, 9, true, true); } #endif //TMC2130 @@ -3880,9 +4086,9 @@ void menu_setlang(unsigned char lang) lang_boot_update_start(lang); lcd_update_enable(true); lcd_implementation_clear(); - lcd_goto_menu(lcd_language_menu); + menu_goto(lcd_language_menu, 0, true, true); lcd_timeoutToStatus = -1; //infinite timeout - lcdDrawUpdate = 2; + lcd_draw_update = 2; } } @@ -4008,14 +4214,14 @@ void lcd_calibrate_pinda() { //manage_inactivity(true); manage_heater(); - if (abs(encoderDiff) >= ENCODER_PULSES_PER_STEP) { //adjusting mark by knob rotation + if (abs(lcd_encoder_diff) >= ENCODER_PULSES_PER_STEP) { //adjusting mark by knob rotation delay_keep_alive(50); //previous_millis_cmd = millis(); - encoderPosition += (encoderDiff / ENCODER_PULSES_PER_STEP); - encoderDiff = 0; + lcd_encoder += (lcd_encoder_diff / ENCODER_PULSES_PER_STEP); + lcd_encoder_diff = 0; if (!planner_queue_full()) { - current_position[E_AXIS] += float(abs((int)encoderPosition)) * 0.01; //0.05 - encoderPosition = 0; + current_position[E_AXIS] += float(abs((int)lcd_encoder)) * 0.01; //0.05 + lcd_encoder = 0; plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], feedrate, active_extruder); } @@ -4024,7 +4230,7 @@ void lcd_calibrate_pinda() { steps_final = current_position[E_AXIS] * axis_steps_per_unit[E_AXIS]; //steps_final = st_get_position(E_AXIS); - lcdDrawUpdate = 1; + lcd_draw_update = 1; e_steps_per_unit = ((float)(steps_final)) / 100.0f; if (e_steps_per_unit < MIN_E_STEPS_PER_UNIT) e_steps_per_unit = MIN_E_STEPS_PER_UNIT; if (e_steps_per_unit > MAX_E_STEPS_PER_UNIT) e_steps_per_unit = MAX_E_STEPS_PER_UNIT; @@ -4039,7 +4245,7 @@ void lcd_calibrate_pinda() { delay_keep_alive(500); lcd_show_fullscreen_message_and_wait_P(_i("E calibration finished. Please clean the nozzle. Click when done."));////MSG_CLEAN_NOZZLE_E c=20 r=8 lcd_update_enable(true); - lcdDrawUpdate = 2; + lcd_draw_update = 2; } else @@ -4111,13 +4317,13 @@ void lcd_language() { lcd_update_enable(true); lcd_implementation_clear(); - lcd_goto_menu(lcd_language_menu); + menu_goto(lcd_language_menu, 0, true, true); lcd_timeoutToStatus = -1; //infinite timeout - lcdDrawUpdate = 2; + lcd_draw_update = 2; while ((menu_menu != lcd_status_screen) && (!lang_is_selected())) { delay(50); - lcd_update(); + lcd_update(0); manage_heater(); manage_inactivity(true); } @@ -4519,7 +4725,7 @@ static void lcd_calibration_menu() } void bowden_menu() { - int enc_dif = encoderDiff; + int enc_dif = lcd_encoder_diff; int cursor_pos = 0; lcd_implementation_clear(); lcd.setCursor(0, 0); @@ -4533,20 +4739,20 @@ void bowden_menu() { lcd.print(bowden_length[i] - 48); } - enc_dif = encoderDiff; + enc_dif = lcd_encoder_diff; while (1) { manage_heater(); manage_inactivity(true); - if (abs((enc_dif - encoderDiff)) > 2) { + if (abs((enc_dif - lcd_encoder_diff)) > 2) { - if (enc_dif > encoderDiff) { + if (enc_dif > lcd_encoder_diff) { cursor_pos--; } - if (enc_dif < encoderDiff) { + if (enc_dif < lcd_encoder_diff) { cursor_pos++; } @@ -4569,7 +4775,7 @@ void bowden_menu() { lcd.setCursor(0, cursor_pos); lcd.print(">"); - enc_dif = encoderDiff; + enc_dif = lcd_encoder_diff; delay(100); } @@ -4591,19 +4797,19 @@ void bowden_menu() { lcd.setCursor(13, 1); lcd.print(bowden_length[cursor_pos] - 48); - if (abs((enc_dif - encoderDiff)) > 2) { - if (enc_dif > encoderDiff) { + if (abs((enc_dif - lcd_encoder_diff)) > 2) { + if (enc_dif > lcd_encoder_diff) { bowden_length[cursor_pos]--; lcd.setCursor(13, 1); lcd.print(bowden_length[cursor_pos] - 48); - enc_dif = encoderDiff; + enc_dif = lcd_encoder_diff; } - if (enc_dif < encoderDiff) { + if (enc_dif < lcd_encoder_diff) { bowden_length[cursor_pos]++; lcd.setCursor(13, 1); lcd.print(bowden_length[cursor_pos] - 48); - enc_dif = encoderDiff; + enc_dif = lcd_encoder_diff; } } delay(100); @@ -4615,7 +4821,7 @@ void bowden_menu() { if (lcd_show_fullscreen_message_yes_no_and_wait_P(PSTR("Continue with another bowden?"))) { lcd_update_enable(true); lcd_implementation_clear(); - enc_dif = encoderDiff; + enc_dif = lcd_encoder_diff; lcd.setCursor(0, cursor_pos); lcd.print(">"); for (int i = 0; i < 4; i++) { @@ -4648,11 +4854,11 @@ static char snmm_stop_print_menu() { //menu for choosing which filaments will be while (1) { manage_heater(); manage_inactivity(true); - if (abs((enc_dif - encoderDiff)) > 4) { + if (abs((enc_dif - lcd_encoder_diff)) > 4) { - if ((abs(enc_dif - encoderDiff)) > 1) { - if (enc_dif > encoderDiff) cursor_pos--; - if (enc_dif < encoderDiff) cursor_pos++; + if ((abs(enc_dif - lcd_encoder_diff)) > 1) { + if (enc_dif > lcd_encoder_diff) cursor_pos--; + if (enc_dif < lcd_encoder_diff) cursor_pos++; if (cursor_pos > 3) cursor_pos = 3; if (cursor_pos < 1) cursor_pos = 1; @@ -4664,7 +4870,7 @@ static char snmm_stop_print_menu() { //menu for choosing which filaments will be lcd.print(" "); lcd.setCursor(0, cursor_pos); lcd.print(">"); - enc_dif = encoderDiff; + enc_dif = lcd_encoder_diff; delay(100); } } @@ -4686,7 +4892,7 @@ char choose_extruder_menu() { int enc_dif = 0; char cursor_pos = 1; - enc_dif = encoderDiff; + enc_dif = lcd_encoder_diff; lcd_implementation_clear(); lcd_printPGM(_T(MSG_CHOOSE_EXTRUDER)); @@ -4706,14 +4912,14 @@ char choose_extruder_menu() { manage_heater(); manage_inactivity(true); - if (abs((enc_dif - encoderDiff)) > 4) { + if (abs((enc_dif - lcd_encoder_diff)) > 4) { - if ((abs(enc_dif - encoderDiff)) > 1) { - if (enc_dif > encoderDiff) { + if ((abs(enc_dif - lcd_encoder_diff)) > 1) { + if (enc_dif > lcd_encoder_diff) { cursor_pos--; } - if (enc_dif < encoderDiff) { + if (enc_dif < lcd_encoder_diff) { cursor_pos++; } @@ -4748,7 +4954,7 @@ char choose_extruder_menu() { lcd.print(" "); lcd.setCursor(0, cursor_pos); lcd.print(">"); - enc_dif = encoderDiff; + enc_dif = lcd_encoder_diff; delay(100); } @@ -4788,7 +4994,7 @@ char reset_menu() { item[4] = "Bowden length"; #endif // SNMM - enc_dif = encoderDiff; + enc_dif = lcd_encoder_diff; lcd_implementation_clear(); lcd.setCursor(0, 0); lcd.print(">"); @@ -4803,14 +5009,14 @@ char reset_menu() { manage_heater(); manage_inactivity(true); - if (abs((enc_dif - encoderDiff)) > 4) { + if (abs((enc_dif - lcd_encoder_diff)) > 4) { - if ((abs(enc_dif - encoderDiff)) > 1) { - if (enc_dif > encoderDiff) { + if ((abs(enc_dif - lcd_encoder_diff)) > 1) { + if (enc_dif > lcd_encoder_diff) { cursor_pos--; } - if (enc_dif < encoderDiff) { + if (enc_dif < lcd_encoder_diff) { cursor_pos++; } @@ -4839,7 +5045,7 @@ char reset_menu() { lcd.print(" "); lcd.setCursor(0, cursor_pos); lcd.print(">"); - enc_dif = encoderDiff; + enc_dif = lcd_encoder_diff; delay(100); } @@ -4865,7 +5071,7 @@ static void lcd_disable_farm_mode() lcd_return_to_status(); } lcd_update_enable(true); - lcdDrawUpdate = 2; + lcd_draw_update = 2; } @@ -4969,7 +5175,7 @@ void extr_adj(int extruder) //loading filament for SNMM max_feedrate[E_AXIS] = 50; lcd_update_enable(true); lcd_return_to_status(); - lcdDrawUpdate = 2; + lcd_draw_update = 2; } @@ -5208,8 +5414,8 @@ static void lcd_farm_no() do { - if (abs((enc_dif - encoderDiff)) > 2) { - if (enc_dif > encoderDiff) { + if (abs((enc_dif - lcd_encoder_diff)) > 2) { + if (enc_dif > lcd_encoder_diff) { switch (step) { case(0): if (_farmno >= 100) _farmno -= 100; break; case(1): if (_farmno % 100 >= 10) _farmno -= 10; break; @@ -5218,7 +5424,7 @@ static void lcd_farm_no() } } - if (enc_dif < encoderDiff) { + if (enc_dif < lcd_encoder_diff) { switch (step) { case(0): if (_farmno < 900) _farmno += 100; break; case(1): if (_farmno % 100 < 90) _farmno += 10; break; @@ -5227,7 +5433,7 @@ static void lcd_farm_no() } } enc_dif = 0; - encoderDiff = 0; + lcd_encoder_diff = 0; } lcd.setCursor(0, 2); @@ -5275,7 +5481,7 @@ unsigned char lcd_choose_color() { static int first = 0; int enc_dif = 0; unsigned char cursor_pos = 1; - enc_dif = encoderDiff; + enc_dif = lcd_encoder_diff; lcd_implementation_clear(); lcd.setCursor(0, 1); lcd.print(">"); @@ -5292,13 +5498,13 @@ unsigned char lcd_choose_color() { manage_heater(); manage_inactivity(true); proc_commands(); - if (abs((enc_dif - encoderDiff)) > 12) { + if (abs((enc_dif - lcd_encoder_diff)) > 12) { - if (enc_dif > encoderDiff) { + if (enc_dif > lcd_encoder_diff) { cursor_pos--; } - if (enc_dif < encoderDiff) { + if (enc_dif < lcd_encoder_diff) { cursor_pos++; } @@ -5325,7 +5531,7 @@ unsigned char lcd_choose_color() { lcd.print(" "); lcd.setCursor(0, cursor_pos); lcd.print(">"); - enc_dif = encoderDiff; + enc_dif = lcd_encoder_diff; delay(100); } @@ -5353,7 +5559,7 @@ void lcd_confirm_print() int _ret = 0; int _t = 0; - enc_dif = encoderDiff; + enc_dif = lcd_encoder_diff; lcd_implementation_clear(); lcd.setCursor(0, 0); @@ -5361,15 +5567,15 @@ void lcd_confirm_print() do { - if (abs(enc_dif - encoderDiff) > 12) { - if (enc_dif > encoderDiff) { + if (abs(enc_dif - lcd_encoder_diff) > 12) { + if (enc_dif > lcd_encoder_diff) { cursor_pos--; } - if (enc_dif < encoderDiff) { + if (enc_dif < lcd_encoder_diff) { cursor_pos++; } - enc_dif = encoderDiff; + enc_dif = lcd_encoder_diff; } if (cursor_pos > 2) { cursor_pos = 2; } @@ -5459,7 +5665,7 @@ static void lcd_main_menu() { int tempScrool = 0; - if (lcdDrawUpdate == 0 && LCD_CLICKED == 0) + if (lcd_draw_update == 0 && LCD_CLICKED == 0) //delay(100); return; // nothing to do (so don't thrash the SD card) uint16_t fileCnt = card.getnrfilenames(); @@ -5672,7 +5878,7 @@ static void lcd_colorprint_change() { custom_message_type = 2; //just print status message lcd_setstatuspgm(_T(MSG_FINISHING_MOVEMENTS)); lcd_return_to_status(); - lcdDrawUpdate = 3; + lcd_draw_update = 3; } static void lcd_tune_menu() @@ -5693,13 +5899,13 @@ static void lcd_tune_menu() MENU_BEGIN(); MENU_ITEM_BACK_P(_T(MSG_MAIN)); //1 - MENU_ITEM_EDIT(int3, _i("Speed"), &feedmultiply, 10, 999);//2////MSG_SPEED c=0 r=0 + MENU_ITEM_EDIT_int3_P(_i("Speed"), &feedmultiply, 10, 999);//2////MSG_SPEED c=0 r=0 - MENU_ITEM_EDIT(int3, _T(MSG_NOZZLE), &target_temperature[0], 0, HEATER_0_MAXTEMP - 10);//3 - MENU_ITEM_EDIT(int3, _T(MSG_BED), &target_temperature_bed, 0, BED_MAXTEMP - 10);//4 + MENU_ITEM_EDIT_int3_P(_T(MSG_NOZZLE), &target_temperature[0], 0, HEATER_0_MAXTEMP - 10);//3 + MENU_ITEM_EDIT_int3_P(_T(MSG_BED), &target_temperature_bed, 0, BED_MAXTEMP - 10);//4 - MENU_ITEM_EDIT(int3, _T(MSG_FAN_SPEED), &fanSpeed, 0, 255);//5 - MENU_ITEM_EDIT(int3, _i("Flow"), &extrudemultiply, 10, 999);//6////MSG_FLOW c=0 r=0 + MENU_ITEM_EDIT_int3_P(_T(MSG_FAN_SPEED), &fanSpeed, 0, 255);//5 + MENU_ITEM_EDIT_int3_P(_i("Flow"), &extrudemultiply, 10, 999);//6////MSG_FLOW c=0 r=0 #ifdef FILAMENTCHANGEENABLE MENU_ITEM_FUNCTION_P(_T(MSG_FILAMENTCHANGE), lcd_colorprint_change);//7 #endif @@ -5759,22 +5965,22 @@ static void lcd_control_temperature_menu() MENU_ITEM_BACK_P(_T(MSG_SETTINGS)); #if TEMP_SENSOR_0 != 0 //MENU_ITEM_EDIT_P_int16 - if (menu_item_edit_int3(_T(MSG_NOZZLE), &target_temperature[0], 0, HEATER_0_MAXTEMP - 10)) +/* if (menu_item_edit_int3(_T(MSG_NOZZLE), &target_temperature[0], 0, HEATER_0_MAXTEMP - 10)) { return; - } -// MENU_ITEM_EDIT(int3, _T(MSG_NOZZLE), &target_temperature[0], 0, HEATER_0_MAXTEMP - 10); + }*/ + MENU_ITEM_EDIT_int3_P(_T(MSG_NOZZLE), &target_temperature[0], 0, HEATER_0_MAXTEMP - 10); #endif #if TEMP_SENSOR_1 != 0 - MENU_ITEM_EDIT(int3, _i("Nozzle2"), &target_temperature[1], 0, HEATER_1_MAXTEMP - 10);////MSG_NOZZLE1 c=0 r=0 + MENU_ITEM_EDIT_int3_P(_i("Nozzle2"), &target_temperature[1], 0, HEATER_1_MAXTEMP - 10);////MSG_NOZZLE1 c=0 r=0 #endif #if TEMP_SENSOR_2 != 0 - MENU_ITEM_EDIT(int3, _i("Nozzle3"), &target_temperature[2], 0, HEATER_2_MAXTEMP - 10);////MSG_NOZZLE2 c=0 r=0 + MENU_ITEM_EDIT_int3_P(_i("Nozzle3"), &target_temperature[2], 0, HEATER_2_MAXTEMP - 10);////MSG_NOZZLE2 c=0 r=0 #endif #if TEMP_SENSOR_BED != 0 - MENU_ITEM_EDIT(int3, _T(MSG_BED), &target_temperature_bed, 0, BED_MAXTEMP - 3); + MENU_ITEM_EDIT_int3_P(_T(MSG_BED), &target_temperature_bed, 0, BED_MAXTEMP - 3); #endif - MENU_ITEM_EDIT(int3, _T(MSG_FAN_SPEED), &fanSpeed, 0, 255); + MENU_ITEM_EDIT_int3_P(_T(MSG_FAN_SPEED), &fanSpeed, 0, 255); #if defined AUTOTEMP && (TEMP_SENSOR_0 != 0) MENU_ITEM_EDIT(bool, MSG_AUTOTEMP, &autotemp_enabled); MENU_ITEM_EDIT(float3, _i(" \002 Min"), &autotemp_min, 0, HEATER_0_MAXTEMP - 10);////MSG_MIN c=0 r=0 @@ -5790,13 +5996,13 @@ static void lcd_control_temperature_menu() static void lcd_sd_refresh() { card.initsd(); - currentMenuViewOffset = 0; + menu_top = 0; } #endif static void lcd_sd_updir() { card.updir(); - currentMenuViewOffset = 0; + menu_top = 0; } void lcd_print_stop() { @@ -5846,19 +6052,19 @@ void lcd_sdcard_stop() lcd.setCursor(0, 2); lcd.print(" "); lcd.setCursor(0, 3); lcd.print(" "); - if ((int32_t)encoderPosition > 2) { encoderPosition = 2; } - if ((int32_t)encoderPosition < 1) { encoderPosition = 1; } + if ((int32_t)lcd_encoder > 2) { lcd_encoder = 2; } + if ((int32_t)lcd_encoder < 1) { lcd_encoder = 1; } - lcd.setCursor(0, 1 + encoderPosition); + lcd.setCursor(0, 1 + lcd_encoder); lcd.print(">"); if (lcd_clicked()) { - if ((int32_t)encoderPosition == 1) + if ((int32_t)lcd_encoder == 1) { lcd_return_to_status(); } - if ((int32_t)encoderPosition == 2) + if ((int32_t)lcd_encoder == 2) { lcd_print_stop(); } @@ -5903,7 +6109,7 @@ void lcd_sdcard_menu() presort_flag = false; card.presort(); } - if (lcdDrawUpdate == 0 && LCD_CLICKED == 0) + if (lcd_draw_update == 0 && LCD_CLICKED == 0) //delay(100); return; // nothing to do (so don't thrash the SD card) uint16_t fileCnt = card.getnrfilenames(); @@ -5971,7 +6177,7 @@ void lcd_sdcard_menu() //int j; //char description[31]; int tempScrool = 0; - if (lcdDrawUpdate == 0 && LCD_CLICKED == 0) + if (lcd_draw_update == 0 && LCD_CLICKED == 0) //delay(100); return; // nothing to do (so don't thrash the SD card) uint16_t fileCnt = card.getnrfilenames(); @@ -6020,29 +6226,29 @@ void lcd_sdcard_menu() #define menu_edit_type(_type, _name, _strFunc, scale) \ void menu_edit_ ## _name () \ { \ - if ((int32_t)encoderPosition < 0) encoderPosition = 0; \ - if ((int32_t)encoderPosition > menuData.editMenuParentState.maxEditValue) encoderPosition = menuData.editMenuParentState.maxEditValue; \ - if (lcdDrawUpdate) \ - lcd_implementation_drawedit(menuData.editMenuParentState.editLabel, _strFunc(((_type)((int32_t)encoderPosition + menuData.editMenuParentState.minEditValue)) / scale)); \ + if ((int32_t)lcd_encoder < 0) lcd_encoder = 0; \ + if ((int32_t)lcd_encoder > menuData.editMenuParentState.maxEditValue) lcd_encoder = menuData.editMenuParentState.maxEditValue; \ + if (lcd_draw_update) \ + lcd_implementation_drawedit(menuData.editMenuParentState.editLabel, _strFunc(((_type)((int32_t)lcd_encoder + menuData.editMenuParentState.minEditValue)) / scale)); \ if (LCD_CLICKED) \ { \ - *((_type*)menuData.editMenuParentState.editValue) = ((_type)((int32_t)encoderPosition + menuData.editMenuParentState.minEditValue)) / scale; \ - lcd_goto_menu(menuData.editMenuParentState.prevMenu, menuData.editMenuParentState.prevEncoderPosition, true, false); \ + *((_type*)menuData.editMenuParentState.editValue) = ((_type)((int32_t)lcd_encoder + menuData.editMenuParentState.minEditValue)) / scale; \ + menu_goto(menuData.editMenuParentState.prevMenu, menuData.editMenuParentState.prevEncoderPosition, true, false); \ } \ } \ static void menu_action_setting_edit_ ## _name (const char* pstr, _type* ptr, _type minValue, _type maxValue) \ { \ asm("cli"); \ menuData.editMenuParentState.prevMenu = menu_menu; \ - menuData.editMenuParentState.prevEncoderPosition = encoderPosition; \ + menuData.editMenuParentState.prevEncoderPosition = lcd_encoder; \ asm("sei"); \ \ - lcdDrawUpdate = 2; \ + lcd_draw_update = 2; \ menuData.editMenuParentState.editLabel = pstr; \ menuData.editMenuParentState.editValue = ptr; \ menuData.editMenuParentState.minEditValue = minValue * scale; \ menuData.editMenuParentState.maxEditValue = maxValue * scale - menuData.editMenuParentState.minEditValue; \ - lcd_goto_menu(menu_edit_ ## _name, (*ptr) * scale - menuData.editMenuParentState.minEditValue, true, false); \ + menu_goto(menu_edit_ ## _name, (*ptr) * scale - menuData.editMenuParentState.minEditValue, true, false); \ \ }\ @@ -6838,7 +7044,7 @@ static bool lcd_selftest_manual_fan_check(int _fan, bool check_opposite) int8_t enc_dif = 0; KEEPALIVE_STATE(PAUSED_FOR_USER); - button_pressed = false; + lcd_button_pressed = false; do { switch (_fan) @@ -6855,8 +7061,8 @@ static bool lcd_selftest_manual_fan_check(int _fan, bool check_opposite) break; } - if (abs((enc_dif - encoderDiff)) > 2) { - if (enc_dif > encoderDiff) { + if (abs((enc_dif - lcd_encoder_diff)) > 2) { + if (enc_dif > lcd_encoder_diff) { _result = !check_opposite; lcd.setCursor(0, 2); lcd.print(">"); lcd.setCursor(1, 2); lcd_printPGM(_T(MSG_SELFTEST_FAN_YES)); @@ -6864,7 +7070,7 @@ static bool lcd_selftest_manual_fan_check(int _fan, bool check_opposite) lcd.setCursor(1, 3); lcd_printPGM(_T(MSG_SELFTEST_FAN_NO)); } - if (enc_dif < encoderDiff) { + if (enc_dif < lcd_encoder_diff) { _result = check_opposite; lcd.setCursor(0, 2); lcd.print(" "); lcd.setCursor(1, 2); lcd_printPGM(_T(MSG_SELFTEST_FAN_YES)); @@ -6872,7 +7078,7 @@ static bool lcd_selftest_manual_fan_check(int _fan, bool check_opposite) lcd.setCursor(1, 3); lcd_printPGM(_T(MSG_SELFTEST_FAN_NO)); } enc_dif = 0; - encoderDiff = 0; + lcd_encoder_diff = 0; } @@ -7057,13 +7263,6 @@ static void lcd_selftest_screen_step(int _row, int _col, int _state, const char /** End of menus **/ -static void lcd_quick_feedback() -{ - lcdDrawUpdate = 2; - button_pressed = false; - lcd_implementation_quick_feedback(); -} - /** Menu action functions **/ static bool check_file(const char* filename) { @@ -7141,21 +7340,23 @@ static void menu_action_sddirectory(const char* filename, char* longFilename) strcpy(dir_names[depth], filename); MYSERIAL.println(dir_names[depth]); card.chdir(filename); - encoderPosition = 0; + lcd_encoder = 0; } static void menu_action_setting_edit_bool(const char* pstr, bool* ptr) { *ptr = !(*ptr); } -#endif//ULTIPANEL /** LCD API **/ void lcd_init() { - lcd_implementation_init(); - -#ifdef NEWPANEL + lcd_implementation_init(); + lcd_longpress_func = menu_lcd_longpress_func; + lcd_charsetup_func = menu_lcd_charsetup_func; + lcd_lcdupdate_func = menu_lcd_lcdupdate_func; + menu_menu = lcd_status_screen; + SET_INPUT(BTN_EN1); SET_INPUT(BTN_EN2); WRITE(BTN_EN1, HIGH); @@ -7164,195 +7365,19 @@ void lcd_init() SET_INPUT(BTN_ENC); WRITE(BTN_ENC, HIGH); #endif -#ifdef REPRAPWORLD_KEYPAD - pinMode(SHIFT_CLK, OUTPUT); - pinMode(SHIFT_LD, OUTPUT); - pinMode(SHIFT_OUT, INPUT); - WRITE(SHIFT_OUT, HIGH); - WRITE(SHIFT_LD, HIGH); -#endif -#else // Not NEWPANEL -#ifdef SR_LCD_2W_NL // Non latching 2 wire shift register - pinMode (SR_DATA_PIN, OUTPUT); - pinMode (SR_CLK_PIN, OUTPUT); -#elif defined(SHIFT_CLK) - pinMode(SHIFT_CLK, OUTPUT); - pinMode(SHIFT_LD, OUTPUT); - pinMode(SHIFT_EN, OUTPUT); - pinMode(SHIFT_OUT, INPUT); - WRITE(SHIFT_OUT, HIGH); - WRITE(SHIFT_LD, HIGH); - WRITE(SHIFT_EN, LOW); -#else -#ifdef ULTIPANEL -#error ULTIPANEL requires an encoder -#endif -#endif // SR_LCD_2W_NL -#endif//!NEWPANEL #if defined (SDSUPPORT) && defined(SDCARDDETECT) && (SDCARDDETECT > 0) pinMode(SDCARDDETECT, INPUT); WRITE(SDCARDDETECT, HIGH); lcd_oldcardstatus = IS_SD_INSERTED; #endif//(SDCARDDETECT > 0) -#ifdef LCD_HAS_SLOW_BUTTONS - slow_buttons = 0; -#endif lcd_buttons_update(); -#ifdef ULTIPANEL - encoderDiff = 0; -#endif + lcd_encoder_diff = 0; } -//#include - -static volatile bool lcd_update_enabled = true; -unsigned long lcd_timeoutToStatus = 0; - -void lcd_update_enable(bool enabled) -{ - if (lcd_update_enabled != enabled) { - lcd_update_enabled = enabled; - if (enabled) { - // Reset encoder position. This is equivalent to re-entering a menu. - encoderPosition = 0; - encoderDiff = 0; - // Enabling the normal LCD update procedure. - // Reset the timeout interval. - lcd_timeoutToStatus = millis() + LCD_TIMEOUT_TO_STATUS; - // Force the keypad update now. - lcd_next_update_millis = millis() - 1; - // Full update. - lcd_implementation_clear(); - if (menu_menu == lcd_status_screen) - lcd_set_custom_characters_degree(); - else - lcd_set_custom_characters_arrows(); - lcd_update(2); - } else { - // Clear the LCD always, or let it to the caller? - } - } -} - -void lcd_update(uint8_t lcdDrawUpdateOverride) -{ - - if (lcdDrawUpdate < lcdDrawUpdateOverride) - lcdDrawUpdate = lcdDrawUpdateOverride; - - if (!lcd_update_enabled) - return; - -#ifdef LCD_HAS_SLOW_BUTTONS - slow_buttons = lcd_implementation_read_slow_buttons(); // buttons which take too long to read in interrupt context -#endif - - lcd_buttons_update(); - -#if (SDCARDDETECT > 0) - 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. - - if (lcd_oldcardstatus) - { - card.initsd(); - LCD_MESSAGERPGM(_i("Card inserted"));////MSG_SD_INSERTED c=0 r=0 - //get_description(); - } - else - { - card.release(); - LCD_MESSAGERPGM(_i("Card removed"));////MSG_SD_REMOVED c=0 r=0 - } - } -#endif//CARDINSERTED - - if (lcd_next_update_millis < millis()) - { -#ifdef DEBUG_BLINK_ACTIVE - static bool active_led = false; - active_led = !active_led; - pinMode(LED_PIN, OUTPUT); - digitalWrite(LED_PIN, active_led?HIGH:LOW); -#endif //DEBUG_BLINK_ACTIVE - -#ifdef ULTIPANEL -#ifdef REPRAPWORLD_KEYPAD - 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(); - } -#endif - if (abs(encoderDiff) >= ENCODER_PULSES_PER_STEP) - { - if (lcdDrawUpdate == 0) - lcdDrawUpdate = 1; - encoderPosition += encoderDiff / ENCODER_PULSES_PER_STEP; - encoderDiff = 0; - lcd_timeoutToStatus = millis() + LCD_TIMEOUT_TO_STATUS; - } - - if (LCD_CLICKED) lcd_timeoutToStatus = millis() + LCD_TIMEOUT_TO_STATUS; -#endif//ULTIPANEL - - (*menu_menu)(); - -#ifdef LCD_HAS_STATUS_INDICATORS - lcd_implementation_update_indicators(); -#endif - -#ifdef ULTIPANEL - if (lcd_timeoutToStatus < millis() && menu_menu != lcd_status_screen) - { - // Exiting a menu. Let's call the menu function the last time with menuExiting flag set to true - // to give it a chance to save its state. - // This is useful for example, when the babystep value has to be written into EEPROM. - if (menu_menu != NULL) { - menuExiting = true; - (*menu_menu)(); - menuExiting = false; - } - lcd_implementation_clear(); - lcd_return_to_status(); - lcdDrawUpdate = 2; - } -#endif//ULTIPANEL - if (lcdDrawUpdate == 2) lcd_implementation_clear(); - if (lcdDrawUpdate) lcdDrawUpdate--; - lcd_next_update_millis = millis() + LCD_UPDATE_INTERVAL; - } - if (!SdFatUtil::test_stack_integrity()) stack_error(); -#ifdef DEBUG_STEPPER_TIMER_MISSED - if (stepper_timer_overflow_state) stepper_timer_overflow(); -#endif /* DEBUG_STEPPER_TIMER_MISSED */ - lcd_ping(); //check that we have received ping command if we are in farm mode - lcd_send_status(); - if (lcd_commands_type == LCD_COMMAND_V2_CAL) lcd_commands(); -} void lcd_printer_connected() { printer_connected = true; @@ -7430,7 +7455,7 @@ void lcd_finishstatus() { } } lcd_status_message[LCD_WIDTH] = '\0'; - lcdDrawUpdate = 2; + lcd_draw_update = 2; } void lcd_setstatus(const char* message) @@ -7452,9 +7477,7 @@ void lcd_setalertstatuspgm(const char* message) { lcd_setstatuspgm(message); lcd_status_message_level = 1; -#ifdef ULTIPANEL lcd_return_to_status(); -#endif//ULTIPANEL } void lcd_reset_alert_level() { @@ -7465,160 +7488,8 @@ uint8_t get_message_level() { return lcd_status_message_level; } -#ifdef DOGLCD -void lcd_setcontrast(uint8_t value) -{ - lcd_contrast = value & 63; - u8g.setContrast(lcd_contrast); -} -#endif -#ifdef ULTIPANEL -/* Warning: This function is called from interrupt context */ -void lcd_buttons_update() -{ - static bool _lock = false; - if (_lock) return; - _lock = true; -#ifdef NEWPANEL - 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 (lcd_update_enabled == true) { //if we are in non-modal mode, long press can be used and short press triggers with button release - if (READ(BTN_ENC) == 0) { //button is pressed - lcd_timeoutToStatus = millis() + LCD_TIMEOUT_TO_STATUS; - if (millis() > button_blanking_time) { - button_blanking_time = millis() + BUTTON_BLANKING_TIME; - if (button_pressed == false && long_press_active == false) { - longPressTimer.start(); - button_pressed = true; - } - else { - if (longPressTimer.expired(LONG_PRESS_TIME)) { - long_press_active = true; - move_menu_scale = 1.0; - menu_submenu(lcd_move_z); - } - } - } - } - else { //button not pressed - if (button_pressed) { //button was released - button_blanking_time = millis() + BUTTON_BLANKING_TIME; - if (long_press_active == false) { //button released before long press gets activated - newbutton |= EN_C; - } - else if (menu_menu == lcd_move_z) lcd_quick_feedback(); - //button_pressed is set back to false via lcd_quick_feedback function - } - else { - long_press_active = false; - } - } - } - else { //we are in modal mode - if (READ(BTN_ENC) == 0) - newbutton |= EN_C; - } - -#endif - buttons = newbutton; -#ifdef LCD_HAS_SLOW_BUTTONS - buttons |= slow_buttons; -#endif -#ifdef REPRAPWORLD_KEYPAD - // 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 = newbutton_reprapworld_keypad >> 1; - if (READ(SHIFT_OUT)) - newbutton_reprapworld_keypad |= (1 << 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; - WRITE(SHIFT_LD, LOW); - WRITE(SHIFT_LD, HIGH); - unsigned char tmp_buttons = 0; - for (int8_t i = 0; i < 8; i++) - { - newbutton = newbutton >> 1; - if (READ(SHIFT_OUT)) - newbutton |= (1 << 7); - WRITE(SHIFT_CLK, HIGH); - WRITE(SHIFT_CLK, LOW); - } - 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; - } - } - lastEncoderBits = enc; - _lock = false; -} - -bool lcd_detected(void) -{ -#if (defined(LCD_I2C_TYPE_MCP23017) || defined(LCD_I2C_TYPE_MCP23008)) && defined(DETECT_DEVICE) - return lcd.LcdDetected() == 1; -#else - return true; -#endif -} - -void lcd_buzz(long duration, uint16_t freq) -{ -#ifdef LCD_USE_I2C_BUZZER - lcd.buzz(duration, freq); -#endif -} - -bool lcd_clicked() -{ - bool clicked = LCD_CLICKED; - if(clicked) button_pressed = false; - return clicked; -} -#endif//ULTIPANEL /********************************/ /** Float conversion utilities **/ @@ -7907,4 +7778,92 @@ char *ftostr52(const float &x) return conv; } -#endif //ULTRA_LCD + + + + + + + + + + + + + +void menu_lcd_longpress_func(void) +{ + menu_submenu(lcd_move_z); +} + +void menu_lcd_charsetup_func(void) +{ + if (menu_menu == lcd_status_screen) + lcd_set_custom_characters_degree(); + else + lcd_set_custom_characters_arrows(); +} + +void menu_lcd_lcdupdate_func(void) +{ +#if (SDCARDDETECT > 0) + if ((IS_SD_INSERTED != lcd_oldcardstatus)) + { + lcd_draw_update = 2; + lcd_oldcardstatus = IS_SD_INSERTED; + lcd_implementation_init(); // to maybe revive the LCD if static electricity killed it. + + if (lcd_oldcardstatus) + { + card.initsd(); + LCD_MESSAGERPGM(_i("Card inserted"));////MSG_SD_INSERTED c=0 r=0 + //get_description(); + } + else + { + card.release(); + LCD_MESSAGERPGM(_i("Card removed"));////MSG_SD_REMOVED c=0 r=0 + } + } +#endif//CARDINSERTED + + if (lcd_next_update_millis < millis()) + { + + if (abs(lcd_encoder_diff) >= ENCODER_PULSES_PER_STEP) + { + if (lcd_draw_update == 0) + lcd_draw_update = 1; + lcd_encoder += lcd_encoder_diff / ENCODER_PULSES_PER_STEP; + lcd_encoder_diff = 0; + lcd_timeoutToStatus = millis() + LCD_TIMEOUT_TO_STATUS; + } + + if (LCD_CLICKED) lcd_timeoutToStatus = millis() + LCD_TIMEOUT_TO_STATUS; + + (*menu_menu)(); + + if (lcd_timeoutToStatus < millis() && menu_menu != lcd_status_screen) + { + // Exiting a menu. Let's call the menu function the last time with menuExiting flag set to true + // to give it a chance to save its state. + // This is useful for example, when the babystep value has to be written into EEPROM. + if (menu_menu != NULL) { + menuExiting = true; + (*menu_menu)(); + menuExiting = false; + } + lcd_implementation_clear(); + lcd_return_to_status(); + lcd_draw_update = 2; + } + if (lcd_draw_update == 2) lcd_implementation_clear(); + if (lcd_draw_update) lcd_draw_update--; + lcd_next_update_millis = millis() + LCD_UPDATE_INTERVAL; + } + if (!SdFatUtil::test_stack_integrity()) stack_error(); + lcd_ping(); //check that we have received ping command if we are in farm mode + lcd_send_status(); + if (lcd_commands_type == LCD_COMMAND_V2_CAL) lcd_commands(); +} + diff --git a/Firmware/ultralcd.h b/Firmware/ultralcd.h index a0920788..5edca1fa 100644 --- a/Firmware/ultralcd.h +++ b/Firmware/ultralcd.h @@ -7,13 +7,13 @@ extern int lcd_puts_P(const char* str); extern int lcd_printf_P(const char* format, ...); -#ifdef ULTRA_LCD +extern void menu_lcd_longpress_func(void); +extern void menu_lcd_charsetup_func(void); +extern void menu_lcd_lcdupdate_func(void); static void lcd_language_menu(); - void lcd_update(uint8_t lcdDrawUpdateOverride = 0); // Call with a false parameter to suppress the LCD update from various places like the planner or the temp control. - void lcd_update_enable(bool enable); void lcd_init(); void lcd_setstatus(const char* message); void lcd_setstatuspgm(const char* message); @@ -37,7 +37,6 @@ extern int lcd_printf_P(const char* format, ...); void lcd_confirm_print(); unsigned char lcd_choose_color(); //void lcd_mylang(); - bool lcd_detected(void); static void lcd_selftest_v(); extern bool lcd_selftest(); @@ -81,10 +80,6 @@ extern int lcd_printf_P(const char* format, ...); extern void lcd_diag_show_end_stops(); -#ifdef DOGLCD - extern int lcd_contrast; - void lcd_setcontrast(uint8_t value); -#endif static unsigned char blink = 0; // Variable for visualization of fan rotation in GLCD @@ -93,18 +88,7 @@ extern int lcd_printf_P(const char* format, ...); #define LCD_MESSAGERPGM(x) lcd_setstatuspgm((x)) #define LCD_ALERTMESSAGERPGM(x) lcd_setalertstatuspgm((x)) - #define LCD_UPDATE_INTERVAL 100 - #define LCD_TIMEOUT_TO_STATUS 30000 - #ifdef ULTIPANEL - void lcd_buttons_update(); - extern volatile uint8_t buttons; //the last checked buttons in a bit array. - #ifdef REPRAPWORLD_KEYPAD - extern volatile uint8_t buttons_reprapworld_keypad; // to store the keypad shift register values - #endif - #else - FORCE_INLINE void lcd_buttons_update() {} - #endif // To be used in lcd_commands_type. @@ -143,65 +127,10 @@ extern int lcd_printf_P(const char* format, ...); extern bool cancel_heatup; extern bool isPrintPaused; - void lcd_buzz(long duration,uint16_t freq); - bool lcd_clicked(); void lcd_ignore_click(bool b=true); void lcd_commands(); - #ifdef NEWPANEL - #define EN_C (1< -1 - // encoder click is directly connected - #define BLEN_C 2 - #define EN_C (1< -1 - // the pause/stop/restart button is connected to BTN_ENC when used - #define B_ST (EN_C) // Map the pause/stop/resume button into its normalized functional name - #define LCD_CLICKED (buttons&(B_MI|B_RI|B_ST)) // pause/stop button also acts as click until we implement proper pause/stop. - #else - #define LCD_CLICKED (buttons&(B_MI|B_RI)) - #endif - - // I2C buttons take too long to read inside an interrupt context and so we read them during lcd_update - #define LCD_HAS_SLOW_BUTTONS - -#elif defined(LCD_I2C_PANELOLU2) - // encoder click can be read through I2C if not directly connected - #if BTN_ENC <= 0 - #define B_I2C_BTN_OFFSET 3 // (the first three bit positions reserved for EN_A, EN_B, EN_C) - - #define B_MI (PANELOLU2_ENCODER_C< - #include - #include - #define LCD_CLASS LiquidCrystal_I2C - LCD_CLASS lcd(LCD_I2C_ADDRESS,LCD_I2C_PIN_EN,LCD_I2C_PIN_RW,LCD_I2C_PIN_RS,LCD_I2C_PIN_D4,LCD_I2C_PIN_D5,LCD_I2C_PIN_D6,LCD_I2C_PIN_D7); - -#elif defined(LCD_I2C_TYPE_MCP23017) - //for the LED indicators (which maybe mapped to different things in lcd_implementation_update_indicators()) - #define LED_A 0x04 //100 - #define LED_B 0x02 //010 - #define LED_C 0x01 //001 - - #define LCD_HAS_STATUS_INDICATORS - - #include - #include - #define LCD_CLASS LiquidTWI2 - #if defined(DETECT_DEVICE) - LCD_CLASS lcd(LCD_I2C_ADDRESS, 1); - #else - LCD_CLASS lcd(LCD_I2C_ADDRESS); - #endif - -#elif defined(LCD_I2C_TYPE_MCP23008) - #include - #include - #define LCD_CLASS LiquidTWI2 - #if defined(DETECT_DEVICE) - LCD_CLASS lcd(LCD_I2C_ADDRESS, 1); - #else - LCD_CLASS lcd(LCD_I2C_ADDRESS); - #endif - -#elif defined(LCD_I2C_TYPE_PCA8574) - #include - #define LCD_CLASS LiquidCrystal_I2C - LCD_CLASS lcd(LCD_I2C_ADDRESS, LCD_WIDTH, LCD_HEIGHT); - -// 2 wire Non-latching LCD SR from: -// https://bitbucket.org/fmalpartida/new-LiquidCrystal/wiki/schematics#!shiftregister-connection -#elif defined(SR_LCD_2W_NL) - - extern "C" void __cxa_pure_virtual() { while (1); } - #include - #include - #define LCD_CLASS LiquidCrystal_SR - LCD_CLASS lcd(SR_DATA_PIN, SR_CLK_PIN); - -#else - // Standard directly connected LCD implementations - #ifdef LANGUAGE_RU - #include "LiquidCrystal_Rus.h" - #define LCD_CLASS LiquidCrystal_Rus - #else - #include "LiquidCrystal_Prusa.h" - #define LCD_CLASS LiquidCrystal_Prusa - #endif - LCD_CLASS lcd(LCD_PINS_RS, LCD_PINS_ENABLE, LCD_PINS_D4, LCD_PINS_D5,LCD_PINS_D6,LCD_PINS_D7); //RS,Enable,D4,D5,D6,D7 -#endif - -/* Custom characters defined in the first 8 characters of the LCD */ -#define LCD_STR_BEDTEMP "\x00" -#define LCD_STR_DEGREE "\x01" -#define LCD_STR_THERMOMETER "\x02" -#define LCD_STR_UPLEVEL "\x03" -#define LCD_STR_REFRESH "\x04" -#define LCD_STR_FOLDER "\x05" -#define LCD_STR_FEEDRATE "\x06" -#define LCD_STR_CLOCK "\x07" -#define LCD_STR_ARROW_UP "\x0B" -#define LCD_STR_ARROW_DOWN "\x01" -#define LCD_STR_ARROW_RIGHT "\x7E" /* from the default character set */ - -static void lcd_set_custom_characters() -{ - byte bedTemp[8] = { - B00000, - B11111, - B10101, - B10001, - B10101, - B11111, - B00000, - B00000 - }; //thanks Sonny Mounicou - byte degree[8] = { - B01100, - B10010, - B10010, - B01100, - B00000, - B00000, - B00000, - B00000 - }; - byte thermometer[8] = { - B00100, - B01010, - B01010, - B01010, - B01010, - B10001, - B10001, - B01110 - }; - byte uplevel[8] = { - B00100, - B01110, - B11111, - B00100, - B11100, - B00000, - B00000, - B00000 - }; //thanks joris - byte refresh[8] = { - B00000, - B00110, - B11001, - B11000, - B00011, - B10011, - B01100, - B00000, - }; //thanks joris - byte folder[8] = { - B00000, - B11100, - B11111, - B10001, - B10001, - B11111, - B00000, - B00000 - }; //thanks joris - #ifdef LANGUAGE_EN_H - byte feedrate[8] = { - B11100, - B10000, - B11000, - B10111, - B00101, - B00110, - B00101, - B00000 - }; //thanks Sonny Mounicou - #else - /* - byte feedrate[8] = { - B11100, - B10100, - B11000, - B10100, - B00000, - B00111, - B00010, - B00010 - }; - */ - /* - byte feedrate[8] = { - B01100, - B10011, - B00000, - B01100, - B10011, - B00000, - B01100, - B10011 - }; - */ - byte feedrate[8] = { - B00000, - B00100, - B10010, - B01001, - B10010, - B00100, - B00000, - B00000 - }; - #endif - - byte clock[8] = { - B00000, - B01110, - B10011, - B10101, - B10001, - B01110, - B00000, - B00000 - }; //thanks Sonny Mounicou - - byte arrup[8] = { - B00100, - B01110, - B11111, - B00000, - B00000, - B00000, - B00000, - B00000 - }; - - byte arrdown[8] = { - B00000, - B00000, - B00000, - B00000, - B00000, - B10001, - B01010, - B00100 - }; - - - lcd.createChar(LCD_STR_BEDTEMP[0], bedTemp); - lcd.createChar(LCD_STR_DEGREE[0], degree); - lcd.createChar(LCD_STR_THERMOMETER[0], thermometer); - lcd.createChar(LCD_STR_UPLEVEL[0], uplevel); - lcd.createChar(LCD_STR_REFRESH[0], refresh); - lcd.createChar(LCD_STR_FOLDER[0], folder); - lcd.createChar(LCD_STR_FEEDRATE[0], feedrate); - lcd.createChar(LCD_STR_CLOCK[0], clock); - //lcd.createChar(LCD_STR_ARROW_UP[0], arrup); - //lcd.createChar(LCD_STR_ARROW_DOWN[0], arrdown); -} - -void lcd_set_custom_characters_arrows() - { - - byte arrdown[8] = { - B00000, - B00000, - B00000, - B00000, - B00000, - B10001, - B01010, - B00100 - }; - - lcd.createChar(1, arrdown); -} - -void lcd_set_custom_characters_progress() - { - byte progress[8] = { - B11111, - B11111, - B11111, - B11111, - B11111, - B11111, - B11111, - B11111, - }; - lcd.createChar(1, progress); - } - -void lcd_set_custom_characters_nextpage() - { - - byte arrdown[8] = { - B00000, - B00000, - B10001, - B01010, - B00100, - B10001, - B01010, - B00100 - }; - - byte confirm[8] = { - B00000, - B00001, - B00011, - B10110, - B11100, - B01000, - B00000 - }; - - lcd.createChar(1, arrdown); - lcd.createChar(2, confirm); -} - -void lcd_set_custom_characters_degree() - { - byte degree[8] = { - B01100, - B10010, - B10010, - B01100, - B00000, - B00000, - B00000, - B00000 - }; - - lcd.createChar(1, degree); -} - - -static void lcd_implementation_init() -{ - -#if defined(LCD_I2C_TYPE_PCF8575) - lcd.begin(LCD_WIDTH, LCD_HEIGHT); - #ifdef LCD_I2C_PIN_BL - lcd.setBacklightPin(LCD_I2C_PIN_BL,POSITIVE); - lcd.setBacklight(HIGH); - #endif - -#elif defined(LCD_I2C_TYPE_MCP23017) - lcd.setMCPType(LTI_TYPE_MCP23017); - lcd.begin(LCD_WIDTH, LCD_HEIGHT); - lcd.setBacklight(0); //set all the LEDs off to begin with - -#elif defined(LCD_I2C_TYPE_MCP23008) - lcd.setMCPType(LTI_TYPE_MCP23008); - lcd.begin(LCD_WIDTH, LCD_HEIGHT); - -#elif defined(LCD_I2C_TYPE_PCA8574) - lcd.init(); - lcd.backlight(); - -#else - lcd.begin(LCD_WIDTH, LCD_HEIGHT); -#endif - - lcd_set_custom_characters(); - - lcd.clear(); -} - - -static void lcd_implementation_init_noclear() -{ - -#if defined(LCD_I2C_TYPE_PCF8575) - lcd.begin_noclear(LCD_WIDTH, LCD_HEIGHT); - #ifdef LCD_I2C_PIN_BL - lcd.setBacklightPin(LCD_I2C_PIN_BL,POSITIVE); - lcd.setBacklight(HIGH); - #endif - -#elif defined(LCD_I2C_TYPE_MCP23017) - lcd.setMCPType(LTI_TYPE_MCP23017); - lcd.begin_noclear(LCD_WIDTH, LCD_HEIGHT); - lcd.setBacklight(0); //set all the LEDs off to begin with - -#elif defined(LCD_I2C_TYPE_MCP23008) - lcd.setMCPType(LTI_TYPE_MCP23008); - lcd.begin_noclear(LCD_WIDTH, LCD_HEIGHT); - -#elif defined(LCD_I2C_TYPE_PCA8574) - lcd.init(); - lcd.backlight(); - -#else - lcd.begin_noclear(LCD_WIDTH, LCD_HEIGHT); -#endif - - lcd_set_custom_characters(); - -} - - -static void lcd_implementation_nodisplay() -{ - lcd.noDisplay(); -} -static void lcd_implementation_display() -{ - lcd.display(); -} - -void lcd_implementation_clear() -{ - lcd.clear(); -} -/* Arduino < 1.0.0 is missing a function to print PROGMEM strings, so we need to implement our own */ -void lcd_printPGM(const char* str) -{ - char c; - while((c = pgm_read_byte(str++)) != '\0') - { - lcd.write(c); - } -} - -void lcd_print_at_PGM(uint8_t x, uint8_t y, const char* str) -{ - lcd.setCursor(x, y); - char c; - while((c = pgm_read_byte(str++)) != '\0') - { - lcd.write(c); - } -} - -void lcd_implementation_write(char c) -{ - lcd.write(c); -} - -void lcd_implementation_print(int8_t i) -{ - lcd.print(i); -} - -void lcd_implementation_print_at(uint8_t x, uint8_t y, int8_t i) -{ - lcd.setCursor(x, y); - lcd.print(i); -} - -void lcd_implementation_print(int i) -{ - lcd.print(i); -} - -void lcd_implementation_print_at(uint8_t x, uint8_t y, int i) -{ - lcd.setCursor(x, y); - lcd.print(i); -} - -void lcd_implementation_print(float f) -{ - lcd.print(f); -} - -void lcd_implementation_print(const char *str) -{ - lcd.print(str); -} - -void lcd_implementation_print_at(uint8_t x, uint8_t y, const char *str) -{ - lcd.setCursor(x, y); - lcd.print(str); -} - -static inline void lcd_print_percent_done() { - if (is_usb_printing) - { - lcd_printPGM(PSTR("USB")); - } - else if(IS_SD_PRINTING) - { - lcd_printPGM(PSTR("SD")); - } - else - { - lcd_printPGM(PSTR(" ")); - } - if (IS_SD_PRINTING || (PRINTER_ACTIVE && (print_percent_done_normal != PRINT_PERCENT_DONE_INIT))) - { - lcd.print(itostr3(print_percent_done())); - } - else - { - lcd_printPGM(PSTR("---")); - } - lcd_printPGM(PSTR("% ")); -} - -static inline void lcd_print_time() { - //if remaining print time estimation is available print it else print elapsed time - //uses 8 characters - uint16_t print_t = 0; - if (print_time_remaining_normal != PRINT_TIME_REMAINING_INIT){ - print_t = print_time_remaining(); - } - else if(starttime != 0){ - print_t = millis() / 60000 - starttime / 60000; - } - lcd.print(LCD_STR_CLOCK[0]); - if((PRINTER_ACTIVE) && ((print_time_remaining_normal != PRINT_TIME_REMAINING_INIT)||(starttime != 0))) - { - lcd.print(itostr2(print_t/60)); - lcd.print(':'); - lcd.print(itostr2(print_t%60)); - if (print_time_remaining_normal != PRINT_TIME_REMAINING_INIT) - { - lcd.print('R'); - (feedmultiply == 100) ? lcd.print(' ') : lcd.print('?'); - } - else { - lcd_printPGM(PSTR(" ")); - } - }else{ - lcd_printPGM(PSTR("--:-- ")); - } -} - -/* - -20x4 |01234567890123456789| - |T 000/000D Z000.0 | - |B 000/000D F100% | - |SD100% T--:-- | - |Status line.........| -*/ -static void lcd_implementation_status_screen() -{ - - int tHotend=int(degHotend(0) + 0.5); - int tTarget=int(degTargetHotend(0) + 0.5); - - //Print the hotend temperature - lcd.setCursor(0, 0); - lcd.print(LCD_STR_THERMOMETER[0]); - lcd.print(itostr3(tHotend)); - lcd.print('/'); - lcd.print(itostr3left(tTarget)); - lcd_printPGM(PSTR(LCD_STR_DEGREE " ")); - lcd_printPGM(PSTR(" ")); - - //Print the Z coordinates - lcd.setCursor(LCD_WIDTH - 8-2, 0); -#if 1 - lcd_printPGM(PSTR(" Z")); - if (custom_message_type == 1) { - // In a bed calibration mode. - lcd_printPGM(PSTR(" --- ")); - } else { - lcd.print(ftostr32sp(current_position[Z_AXIS] + 0.00001)); - lcd.print(' '); - } -#else - lcd_printPGM(PSTR(" Queue:")); - lcd.print(int(moves_planned())); - lcd.print(' '); -#endif - - //Print the Bedtemperature - lcd.setCursor(0, 1); - tHotend=int(degBed() + 0.5); - tTarget=int(degTargetBed() + 0.5); - lcd.print(LCD_STR_BEDTEMP[0]); - lcd.print(itostr3(tHotend)); - lcd.print('/'); - lcd.print(itostr3left(tTarget)); - lcd_printPGM(PSTR(LCD_STR_DEGREE " ")); - lcd_printPGM(PSTR(" ")); - -#ifdef PLANNER_DIAGNOSTICS - //Print Feedrate - lcd.setCursor(LCD_WIDTH - 8-2, 1); - lcd.print(LCD_STR_FEEDRATE[0]); - lcd.print(itostr3(feedmultiply)); - lcd_printPGM(PSTR("% Q")); - { - uint8_t queue = planner_queue_min(); - if (queue < (BLOCK_BUFFER_SIZE >> 1)) { - lcd.write('!'); - } else { - lcd.write((char)(queue / 10) + '0'); - queue %= 10; - } - lcd.write((char)queue + '0'); - planner_queue_min_reset(); - } -#else /* PLANNER_DIAGNOSTICS */ - //Print Feedrate - lcd.setCursor(LCD_WIDTH - 8-2, 1); - lcd_printPGM(PSTR(" ")); - lcd.print(LCD_STR_FEEDRATE[0]); - lcd.print(itostr3(feedmultiply)); - lcd_printPGM(PSTR("% ")); -#endif /* PLANNER_DIAGNOSTICS */ - - bool print_sd_status = true; - -#ifdef PINDA_THERMISTOR -// if (farm_mode && (custom_message_type == 4)) - if (false) - { - lcd.setCursor(0, 2); - lcd_printPGM(PSTR("P")); - lcd.print(ftostr3(current_temperature_pinda)); - lcd_printPGM(PSTR(LCD_STR_DEGREE " ")); - print_sd_status = false; - } -#endif //PINDA_THERMISTOR - - -if (print_sd_status) -{ - //Print SD status - lcd.setCursor(0, 2); - lcd_print_percent_done(); - -} - - // Farm number display - if (farm_mode) - { - lcd.setCursor(6, 2); - lcd_printPGM(PSTR(" F")); - lcd.print(farm_no); - lcd_printPGM(PSTR(" ")); - - // Beat display - lcd.setCursor(LCD_WIDTH - 1, 0); - if ( (millis() - kicktime) < 60000 ) { - - lcd_printPGM(PSTR("L")); - - }else{ - lcd_printPGM(PSTR(" ")); - } - - } - else { -#ifdef SNMM - lcd_printPGM(PSTR(" E")); - lcd.print(get_ext_nr() + 1); - -#else - lcd.setCursor(LCD_WIDTH - 8 - 2, 2); - lcd_printPGM(PSTR(" ")); -#endif - } - -#ifdef CMD_DIAGNOSTICS - lcd.setCursor(LCD_WIDTH - 8 -1, 2); - lcd_printPGM(PSTR(" C")); - lcd.print(buflen); // number of commands in cmd buffer - if (buflen < 9) lcd_printPGM(" "); -#else - //Print time - lcd.setCursor(LCD_WIDTH - 8, 2); - lcd_print_time(); -#endif //CMD_DIAGNOSTICS - -#ifdef DEBUG_DISABLE_LCD_STATUS_LINE - return; -#endif //DEBUG_DISABLE_LCD_STATUS_LINE - - //Print status line - lcd.setCursor(0, 3); - - // If heating in progress, set flag - if (heating_status != 0) { custom_message = true; } - - if (IS_SD_PRINTING) { - if (strcmp(longFilenameOLD, card.longFilename) != 0) - { - memset(longFilenameOLD, '\0', strlen(longFilenameOLD)); - sprintf_P(longFilenameOLD, PSTR("%s"), card.longFilename); - scrollstuff = 0; - } - } - - // If printing from SD, show what we are printing - if ((IS_SD_PRINTING) && !custom_message -#ifdef DEBUG_BUILD - && lcd_status_message[0] == 0 -#endif /* DEBUG_BUILD */ - ) - - { - if(strlen(card.longFilename) > LCD_WIDTH) - { - - int inters = 0; - int gh = scrollstuff; - while (((gh - scrollstuff) < LCD_WIDTH) && (inters == 0)) - { - - if (card.longFilename[gh] == '\0') - { - lcd.setCursor(gh - scrollstuff, 3); - lcd.print(card.longFilename[gh - 1]); - scrollstuff = 0; - gh = scrollstuff; - inters = 1; - } - else - { - lcd.setCursor(gh - scrollstuff, 3); - lcd.print(card.longFilename[gh - 1]); - gh++; - } - - - } - scrollstuff++; - } - else - { - lcd.print(longFilenameOLD); - } - } - - // If not, check for other special events - else - { - - if (custom_message) - { - // If heating flag, show progress of heating. - if (heating_status != 0) - { - heating_status_counter++; - if (heating_status_counter > 13) - { - heating_status_counter = 0; - } - lcd.setCursor(7, 3); - lcd_printPGM(PSTR(" ")); - - for (int dots = 0; dots < heating_status_counter; dots++) - { - lcd.setCursor(7 + dots, 3); - lcd.print('.'); - } - - switch (heating_status) - { - case 1: - lcd.setCursor(0, 3); - lcd_printPGM(_T(MSG_HEATING)); - break; - case 2: - lcd.setCursor(0, 3); - lcd_printPGM(_T(MSG_HEATING_COMPLETE)); - heating_status = 0; - heating_status_counter = 0; - custom_message = false; - break; - case 3: - lcd.setCursor(0, 3); - lcd_printPGM(_T(MSG_BED_HEATING)); - break; - case 4: - lcd.setCursor(0, 3); - lcd_printPGM(_T(MSG_BED_DONE)); - heating_status = 0; - heating_status_counter = 0; - custom_message = false; - break; - default: - break; - } - } - - // If mesh bed leveling in progress, show the status - - if (custom_message_type == 1) - { - if (custom_message_state > 10) - { - lcd.setCursor(0, 3); - lcd_printPGM(PSTR(" ")); - lcd.setCursor(0, 3); - lcd_printPGM(_T(MSG_CALIBRATE_Z_AUTO)); - lcd_printPGM(PSTR(" : ")); - lcd.print(custom_message_state-10); - } - else - { - if (custom_message_state == 3) - { - lcd_printPGM(_T(WELCOME_MSG)); - lcd_setstatuspgm(_T(WELCOME_MSG)); - custom_message = false; - custom_message_type = 0; - } - if (custom_message_state > 3 && custom_message_state <= 10 ) - { - lcd.setCursor(0, 3); - lcd_printPGM(PSTR(" ")); - lcd.setCursor(0, 3); - lcd_printPGM(_i("Calibration done"));////MSG_HOMEYZ_DONE c=0 r=0 - custom_message_state--; - } - } - - } - // If loading filament, print status - if (custom_message_type == 2) - { - lcd.print(lcd_status_message); - } - // PID tuning in progress - if (custom_message_type == 3) { - lcd.print(lcd_status_message); - if (pid_cycle <= pid_number_of_cycles && custom_message_state > 0) { - lcd.setCursor(10, 3); - lcd.print(itostr3(pid_cycle)); - - lcd.print('/'); - lcd.print(itostr3left(pid_number_of_cycles)); - } - } - // PINDA temp calibration in progress - if (custom_message_type == 4) { - char progress[4]; - lcd.setCursor(0, 3); - lcd_printPGM(_T(MSG_TEMP_CALIBRATION)); - lcd.setCursor(12, 3); - sprintf(progress, "%d/6", custom_message_state); - lcd.print(progress); - } - // temp compensation preheat - if (custom_message_type == 5) { - lcd.setCursor(0, 3); - lcd_printPGM(_i("PINDA Heating"));////MSG_PINDA_PREHEAT c=20 r=1 - if (custom_message_state <= PINDA_HEAT_T) { - lcd_printPGM(PSTR(": ")); - lcd.print(custom_message_state); //seconds - lcd.print(' '); - - } - } - - - } - else - { - // Nothing special, print status message normally - lcd.print(lcd_status_message); - } - } - - // Fill the rest of line to have nice and clean output - for(int fillspace = 0; fillspace<20;fillspace++) - { - if((lcd_status_message[fillspace] > 31 )) - { - } - else - { - lcd.print(' '); - } - } - -} - - -static void lcd_implementation_drawmenu_generic(uint8_t row, const char* pstr, char pre_char, char post_char) -{ - char c; - //Use all characters in narrow LCDs - #if LCD_WIDTH < 20 - uint8_t n = LCD_WIDTH - 1 - 1; - #else - uint8_t n = LCD_WIDTH - 1 - 2; - #endif - lcd.setCursor(0, row); - lcd.print(pre_char); - while( ((c = pgm_read_byte(pstr)) != '\0') && (n>0) ) - { - lcd.print(c); - pstr++; - n--; - } - while(n--) - lcd.print(' '); - lcd.print(post_char); - lcd.print(' '); -} - -static void lcd_implementation_drawmenu_generic_RAM(uint8_t row, const char* str, char pre_char, char post_char) -{ - char c; - //Use all characters in narrow LCDs - #if LCD_WIDTH < 20 - uint8_t n = LCD_WIDTH - 1 - 1; - #else - uint8_t n = LCD_WIDTH - 1 - 2; - #endif - lcd.setCursor(0, row); - lcd.print(pre_char); - while( ((c = *str) != '\0') && (n>0) ) - { - lcd.print(c); - str++; - n--; - } - while(n--) - lcd.print(' '); - lcd.print(post_char); - lcd.print(' '); -} - -static void lcd_implementation_drawmenu_setting_edit_generic(uint8_t row, const char* pstr, char pre_char, char* data) -{ - char c; - //Use all characters in narrow LCDs - #if LCD_WIDTH < 20 - uint8_t n = LCD_WIDTH - 1 - 1 - strlen(data); - #else - uint8_t n = LCD_WIDTH - 1 - 2 - strlen(data); - #endif - lcd.setCursor(0, row); - lcd.print(pre_char); - while( ((c = pgm_read_byte(pstr)) != '\0') && (n>0) ) - { - lcd.print(c); - pstr++; - n--; - } - lcd.print(':'); - while(n--) - lcd.print(' '); - lcd.print(data); -} -static void lcd_implementation_drawmenu_setting_edit_generic_P(uint8_t row, const char* pstr, char pre_char, const char* data) -{ - char c; - //Use all characters in narrow LCDs - #if LCD_WIDTH < 20 - uint8_t n = LCD_WIDTH - 1 - 1 - strlen_P(data); - #else - uint8_t n = LCD_WIDTH - 1 - 2 - strlen_P(data); - #endif - lcd.setCursor(0, row); - lcd.print(pre_char); - while( ((c = pgm_read_byte(pstr)) != '\0') && (n>0) ) - { - lcd.print(c); - pstr++; - n--; - } - lcd.print(':'); - while(n--) - lcd.print(' '); - lcd_printPGM(data); -} - - -extern char *wfac_to_str5(const uint8_t &x); -extern char *mres_to_str3(const uint8_t &x); - -#define lcd_implementation_drawmenu_setting_edit_wfac_selected(row, pstr, pstr2, data, minValue, maxValue) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, '>', wfac_to_str5(*(data))) -#define lcd_implementation_drawmenu_setting_edit_wfac(row, pstr, pstr2, data, minValue, maxValue) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, ' ', wfac_to_str5(*(data))) -#define lcd_implementation_drawmenu_setting_edit_mres_selected(row, pstr, pstr2, data, minValue, maxValue) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, '>', mres_to_str3(*(data))) -#define lcd_implementation_drawmenu_setting_edit_mres(row, pstr, pstr2, data, minValue, maxValue) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, ' ', mres_to_str3(*(data))) -#define lcd_implementation_drawmenu_setting_edit_byte3_selected(row, pstr, pstr2, data, minValue, maxValue) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, '>', itostr3((uint8_t)*(data))) -#define lcd_implementation_drawmenu_setting_edit_byte3(row, pstr, pstr2, data, minValue, maxValue) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, ' ', itostr3((uint8_t)*(data))) -#define lcd_implementation_drawmenu_setting_edit_int3_selected(row, pstr, pstr2, data, minValue, maxValue) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, '>', itostr3(*(data))) -#define lcd_implementation_drawmenu_setting_edit_int3(row, pstr, pstr2, data, minValue, maxValue) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, ' ', itostr3(*(data))) -#define lcd_implementation_drawmenu_setting_edit_float3_selected(row, pstr, pstr2, data, minValue, maxValue) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, '>', ftostr3(*(data))) -#define lcd_implementation_drawmenu_setting_edit_float3(row, pstr, pstr2, data, minValue, maxValue) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, ' ', ftostr3(*(data))) -#define lcd_implementation_drawmenu_setting_edit_float32_selected(row, pstr, pstr2, data, minValue, maxValue) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, '>', ftostr32(*(data))) -#define lcd_implementation_drawmenu_setting_edit_float32(row, pstr, pstr2, data, minValue, maxValue) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, ' ', ftostr32(*(data))) -#define lcd_implementation_drawmenu_setting_edit_float43_selected(row, pstr, pstr2, data, minValue, maxValue) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, '>', ftostr43(*(data))) -#define lcd_implementation_drawmenu_setting_edit_float43(row, pstr, pstr2, data, minValue, maxValue) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, ' ', ftostr43(*(data))) -#define lcd_implementation_drawmenu_setting_edit_float5_selected(row, pstr, pstr2, data, minValue, maxValue) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, '>', ftostr5(*(data))) -#define lcd_implementation_drawmenu_setting_edit_float5(row, pstr, pstr2, data, minValue, maxValue) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, ' ', ftostr5(*(data))) -#define lcd_implementation_drawmenu_setting_edit_float52_selected(row, pstr, pstr2, data, minValue, maxValue) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, '>', ftostr52(*(data))) -#define lcd_implementation_drawmenu_setting_edit_float52(row, pstr, pstr2, data, minValue, maxValue) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, ' ', ftostr52(*(data))) -#define lcd_implementation_drawmenu_setting_edit_float51_selected(row, pstr, pstr2, data, minValue, maxValue) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, '>', ftostr51(*(data))) -#define lcd_implementation_drawmenu_setting_edit_float51(row, pstr, pstr2, data, minValue, maxValue) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, ' ', ftostr51(*(data))) -#define lcd_implementation_drawmenu_setting_edit_long5_selected(row, pstr, pstr2, data, minValue, maxValue) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, '>', ftostr5(*(data))) -#define lcd_implementation_drawmenu_setting_edit_long5(row, pstr, pstr2, data, minValue, maxValue) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, ' ', ftostr5(*(data))) -#define lcd_implementation_drawmenu_setting_edit_bool_selected(row, pstr, pstr2, data) lcd_implementation_drawmenu_setting_edit_generic_P(row, pstr, '>', (*(data))?PSTR(MSG_ON):PSTR(MSG_OFF)) -#define lcd_implementation_drawmenu_setting_edit_bool(row, pstr, pstr2, data) lcd_implementation_drawmenu_setting_edit_generic_P(row, pstr, ' ', (*(data))?PSTR(MSG_ON):PSTR(MSG_OFF)) - -//Add version for callback functions -#define lcd_implementation_drawmenu_setting_edit_callback_int3_selected(row, pstr, pstr2, data, minValue, maxValue, callback) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, '>', itostr3(*(data))) -#define lcd_implementation_drawmenu_setting_edit_callback_int3(row, pstr, pstr2, data, minValue, maxValue, callback) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, ' ', itostr3(*(data))) -#define lcd_implementation_drawmenu_setting_edit_callback_float3_selected(row, pstr, pstr2, data, minValue, maxValue, callback) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, '>', ftostr3(*(data))) -#define lcd_implementation_drawmenu_setting_edit_callback_float3(row, pstr, pstr2, data, minValue, maxValue, callback) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, ' ', ftostr3(*(data))) -#define lcd_implementation_drawmenu_setting_edit_callback_float32_selected(row, pstr, pstr2, data, minValue, maxValue, callback) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, '>', ftostr32(*(data))) -#define lcd_implementation_drawmenu_setting_edit_callback_float32(row, pstr, pstr2, data, minValue, maxValue, callback) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, ' ', ftostr32(*(data))) -#define lcd_implementation_drawmenu_setting_edit_callback_float43_selected(row, pstr, pstr2, data, minValue, maxValue, callback) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, '>', ftostr43(*(data))) -#define lcd_implementation_drawmenu_setting_edit_callback_float43(row, pstr, pstr2, data, minValue, maxValue, callback) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, ' ', ftostr43(*(data))) -#define lcd_implementation_drawmenu_setting_edit_callback_float5_selected(row, pstr, pstr2, data, minValue, maxValue, callback) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, '>', ftostr5(*(data))) -#define lcd_implementation_drawmenu_setting_edit_callback_float5(row, pstr, pstr2, data, minValue, maxValue, callback) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, ' ', ftostr5(*(data))) -#define lcd_implementation_drawmenu_setting_edit_callback_float52_selected(row, pstr, pstr2, data, minValue, maxValue, callback) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, '>', ftostr52(*(data))) -#define lcd_implementation_drawmenu_setting_edit_callback_float52(row, pstr, pstr2, data, minValue, maxValue, callback) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, ' ', ftostr52(*(data))) -#define lcd_implementation_drawmenu_setting_edit_callback_float51_selected(row, pstr, pstr2, data, minValue, maxValue, callback) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, '>', ftostr51(*(data))) -#define lcd_implementation_drawmenu_setting_edit_callback_float51(row, pstr, pstr2, data, minValue, maxValue, callback) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, ' ', ftostr51(*(data))) -#define lcd_implementation_drawmenu_setting_edit_callback_long5_selected(row, pstr, pstr2, data, minValue, maxValue, callback) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, '>', ftostr5(*(data))) -#define lcd_implementation_drawmenu_setting_edit_callback_long5(row, pstr, pstr2, data, minValue, maxValue, callback) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, ' ', ftostr5(*(data))) -#define lcd_implementation_drawmenu_setting_edit_callback_bool_selected(row, pstr, pstr2, data, callback) lcd_implementation_drawmenu_setting_edit_generic_P(row, pstr, '>', (*(data))?PSTR(MSG_ON):PSTR(MSG_OFF)) -#define lcd_implementation_drawmenu_setting_edit_callback_bool(row, pstr, pstr2, data, callback) lcd_implementation_drawmenu_setting_edit_generic_P(row, pstr, ' ', (*(data))?PSTR(MSG_ON):PSTR(MSG_OFF)) - - -void lcd_implementation_drawedit(const char* pstr, char* value) -{ - lcd.setCursor(1, 1); - lcd_printPGM(pstr); - lcd.print(':'); - #if LCD_WIDTH < 20 - lcd.setCursor(LCD_WIDTH - strlen(value), 1); - #else - lcd.setCursor(LCD_WIDTH -1 - strlen(value), 1); - #endif - lcd.print(value); -} - -void lcd_implementation_drawedit_2(const char* pstr, char* value) -{ - lcd.setCursor(0, 1); - lcd_printPGM(pstr); - lcd.print(':'); - - lcd.setCursor((LCD_WIDTH - strlen(value))/2, 3); - - lcd.print(value); - lcd.print(" mm"); -} - -static void lcd_implementation_drawmenu_sdfile_selected(uint8_t row, const char* pstr, const char* filename, char* longFilename) -{ - char c; - int enc_dif = encoderDiff; - uint8_t n = LCD_WIDTH - 1; - for(int g = 0; g<4;g++){ - lcd.setCursor(0, g); - lcd.print(' '); - } - - lcd.setCursor(0, row); - lcd.print('>'); - int i = 1; - int j = 0; - char* longFilenameTMP = longFilename; - - while((c = *longFilenameTMP) != '\0') - { - lcd.setCursor(i, row); - lcd.print(c); - i++; - longFilenameTMP++; - if(i==LCD_WIDTH){ - i=1; - j++; - longFilenameTMP = longFilename + j; - n = LCD_WIDTH - 1; - for(int g = 0; g<300 ;g++){ - manage_heater(); - if(LCD_CLICKED || ( enc_dif != encoderDiff )){ - longFilenameTMP = longFilename; - *(longFilenameTMP + LCD_WIDTH - 2) = '\0'; - i = 1; - j = 0; - break; - }else{ - if (j == 1) delay(3); //wait around 1.2 s to start scrolling text - delay(1); //then scroll with redrawing every 300 ms - } - - } - } - } - if(c!='\0'){ - lcd.setCursor(i, row); - lcd.print(c); - i++; - } - n=n-i+1; - while(n--) - lcd.print(' '); -} -static void lcd_implementation_drawmenu_sdfile(uint8_t row, const char* pstr, const char* filename, char* longFilename) -{ - char c; - uint8_t n = LCD_WIDTH - 1; - lcd.setCursor(0, row); - lcd.print(' '); - if (longFilename[0] != '\0') - { - filename = longFilename; - longFilename[LCD_WIDTH-1] = '\0'; - } - while( ((c = *filename) != '\0') && (n>0) ) - { - lcd.print(c); - filename++; - n--; - } - while(n--) - lcd.print(' '); -} -static void lcd_implementation_drawmenu_sddirectory_selected(uint8_t row, const char* pstr, const char* filename, char* longFilename) -{ - char c; - uint8_t n = LCD_WIDTH - 2; - lcd.setCursor(0, row); - lcd.print('>'); - lcd.print(LCD_STR_FOLDER[0]); - if (longFilename[0] != '\0') - { - filename = longFilename; - longFilename[LCD_WIDTH-2] = '\0'; - } - while( ((c = *filename) != '\0') && (n>0) ) - { - lcd.print(c); - filename++; - n--; - } - while(n--) - lcd.print(' '); -} -static void lcd_implementation_drawmenu_sddirectory(uint8_t row, const char* pstr, const char* filename, char* longFilename) -{ - char c; - uint8_t n = LCD_WIDTH - 2; - lcd.setCursor(0, row); - lcd.print(' '); - lcd.print(LCD_STR_FOLDER[0]); - if (longFilename[0] != '\0') - { - filename = longFilename; - longFilename[LCD_WIDTH-2] = '\0'; - } - while( ((c = *filename) != '\0') && (n>0) ) - { - lcd.print(c); - filename++; - n--; - } - while(n--) - lcd.print(' '); -} - - -static void lcd_implementation_quick_feedback() -{ -#ifdef LCD_USE_I2C_BUZZER - #if !defined(LCD_FEEDBACK_FREQUENCY_HZ) || !defined(LCD_FEEDBACK_FREQUENCY_DURATION_MS) - lcd_buzz(1000/6,100); - #else - lcd_buzz(LCD_FEEDBACK_FREQUENCY_DURATION_MS,LCD_FEEDBACK_FREQUENCY_HZ); - #endif -#elif defined(BEEPER) && BEEPER > -1 - SET_OUTPUT(BEEPER); - #if !defined(LCD_FEEDBACK_FREQUENCY_HZ) || !defined(LCD_FEEDBACK_FREQUENCY_DURATION_MS) - for(int8_t i=0;i<10;i++) - { - WRITE(BEEPER,HIGH); - delayMicroseconds(100); - WRITE(BEEPER,LOW); - delayMicroseconds(100); - } - #else - for(int8_t i=0;i<(LCD_FEEDBACK_FREQUENCY_DURATION_MS / (1000 / LCD_FEEDBACK_FREQUENCY_HZ));i++) - { - WRITE(BEEPER,HIGH); - delayMicroseconds(1000000 / LCD_FEEDBACK_FREQUENCY_HZ / 2); - WRITE(BEEPER,LOW); - delayMicroseconds(1000000 / LCD_FEEDBACK_FREQUENCY_HZ / 2); - } - #endif -#endif -} - -#ifdef LCD_HAS_STATUS_INDICATORS -static void lcd_implementation_update_indicators() -{ - #if defined(LCD_I2C_PANELOLU2) || defined(LCD_I2C_VIKI) - //set the LEDS - referred to as backlights by the LiquidTWI2 library - static uint8_t ledsprev = 0; - uint8_t leds = 0; - if (target_temperature_bed > 0) leds |= LED_A; - if (target_temperature[0] > 0) leds |= LED_B; - if (fanSpeed) leds |= LED_C; - #if EXTRUDERS > 1 - if (target_temperature[1] > 0) leds |= LED_C; - #endif - if (leds != ledsprev) { - lcd.setBacklight(leds); - ledsprev = leds; - } - #endif -} -#endif - -#ifdef LCD_HAS_SLOW_BUTTONS -extern uint32_t blocking_enc; - -static uint8_t lcd_implementation_read_slow_buttons() -{ - #ifdef LCD_I2C_TYPE_MCP23017 - uint8_t slow_buttons; - // Reading these buttons this is likely to be too slow to call inside interrupt context - // so they are called during normal lcd_update - slow_buttons = lcd.readButtons() << B_I2C_BTN_OFFSET; - - #if defined(LCD_I2C_VIKI) - if(slow_buttons & (B_MI|B_RI)) { //LCD clicked - if(blocking_enc > millis()) { - slow_buttons &= ~(B_MI|B_RI); // Disable LCD clicked buttons if screen is updated - } - } - #endif - return slow_buttons; - #endif -} -#endif - -#endif//ULTRA_LCD_IMPLEMENTATION_HITACHI_HD44780_H diff --git a/Firmware/util.cpp b/Firmware/util.cpp index 3258a0c0..1de26e2f 100644 --- a/Firmware/util.cpp +++ b/Firmware/util.cpp @@ -304,7 +304,7 @@ bool show_upgrade_dialog_if_version_newer(const char *version_string) lcd_wait_for_click(); lcd_update_enable(true); lcd_implementation_clear(); - lcd_update(); + lcd_update(0); } // Succeeded. diff --git a/Firmware/variants/1_75mm_MK25-RAMBo10a-E3Dv6full.h b/Firmware/variants/1_75mm_MK25-RAMBo10a-E3Dv6full.h index d07ab986..f08e8062 100644 --- a/Firmware/variants/1_75mm_MK25-RAMBo10a-E3Dv6full.h +++ b/Firmware/variants/1_75mm_MK25-RAMBo10a-E3Dv6full.h @@ -136,7 +136,6 @@ //#define DEBUG_DISABLE_PRUSA_STATISTICS //disable prusa_statistics() mesages //#define DEBUG_XSTEP_DUP_PIN 21 //duplicate x-step output to pin 21 (SCL on P3) //#define DEBUG_YSTEP_DUP_PIN 21 //duplicate y-step output to pin 21 (SCL on P3) -//#define DEBUG_BLINK_ACTIVE //#define DEBUG_DISABLE_FANCHECK //disable fan check (no ISR INT7, check disabled) //#define DEBUG_DISABLE_FSENSORCHECK //disable fsensor check (no ISR INT7, check disabled) //#define DEBUG_DUMP_TO_2ND_SERIAL //dump received characters to 2nd serial line diff --git a/Firmware/variants/1_75mm_MK25-RAMBo13a-E3Dv6full.h b/Firmware/variants/1_75mm_MK25-RAMBo13a-E3Dv6full.h index d019c758..1a32cefe 100644 --- a/Firmware/variants/1_75mm_MK25-RAMBo13a-E3Dv6full.h +++ b/Firmware/variants/1_75mm_MK25-RAMBo13a-E3Dv6full.h @@ -136,7 +136,6 @@ //#define DEBUG_DISABLE_PRUSA_STATISTICS //disable prusa_statistics() mesages //#define DEBUG_XSTEP_DUP_PIN 21 //duplicate x-step output to pin 21 (SCL on P3) //#define DEBUG_YSTEP_DUP_PIN 21 //duplicate y-step output to pin 21 (SCL on P3) -//#define DEBUG_BLINK_ACTIVE //#define DEBUG_DISABLE_FANCHECK //disable fan check (no ISR INT7, check disabled) //#define DEBUG_DISABLE_FSENSORCHECK //disable fsensor check (no ISR INT7, check disabled) //#define DEBUG_DUMP_TO_2ND_SERIAL //dump received characters to 2nd serial line diff --git a/Firmware/variants/1_75mm_MK3-EINSy10a-E3Dv6full.h b/Firmware/variants/1_75mm_MK3-EINSy10a-E3Dv6full.h index 78441c2d..ca8c00f1 100644 --- a/Firmware/variants/1_75mm_MK3-EINSy10a-E3Dv6full.h +++ b/Firmware/variants/1_75mm_MK3-EINSy10a-E3Dv6full.h @@ -177,7 +177,6 @@ //#define DEBUG_DISABLE_FORCE_SELFTEST //disable force selftest //#define DEBUG_XSTEP_DUP_PIN 21 //duplicate x-step output to pin 21 (SCL on P3) //#define DEBUG_YSTEP_DUP_PIN 21 //duplicate y-step output to pin 21 (SCL on P3) -//#define DEBUG_BLINK_ACTIVE //#define DEBUG_DISABLE_FANCHECK //disable fan check (no ISR INT7, check disabled) //#define DEBUG_DISABLE_FSENSORCHECK //disable fsensor check (no ISR INT7, check disabled) #define DEBUG_DUMP_TO_2ND_SERIAL //dump received characters to 2nd serial line