My Marlin configs for Fabrikator Mini and CTC i3 Pro B
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

ultralcd.cpp 63KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869
  1. #include "ultralcd.h"
  2. #ifdef ULTRA_LCD
  3. #include "Marlin.h"
  4. #include "language.h"
  5. #include "cardreader.h"
  6. #include "temperature.h"
  7. #include "stepper.h"
  8. #include "ConfigurationStore.h"
  9. int8_t encoderDiff; /* encoderDiff is updated from interrupt context and added to encoderPosition every LCD update */
  10. bool encoderRateMultiplierEnabled;
  11. int32_t lastEncoderMovementMillis;
  12. /* Configuration settings */
  13. int plaPreheatHotendTemp;
  14. int plaPreheatHPBTemp;
  15. int plaPreheatFanSpeed;
  16. int absPreheatHotendTemp;
  17. int absPreheatHPBTemp;
  18. int absPreheatFanSpeed;
  19. #ifdef FILAMENT_LCD_DISPLAY
  20. millis_t previous_lcd_status_ms = 0;
  21. #endif
  22. /* !Configuration settings */
  23. //Function pointer to menu functions.
  24. typedef void (*menuFunc_t)();
  25. uint8_t lcd_status_message_level;
  26. char lcd_status_message[3*LCD_WIDTH+1] = WELCOME_MSG; // worst case is kana with up to 3*LCD_WIDTH+1
  27. #ifdef DOGLCD
  28. #include "dogm_lcd_implementation.h"
  29. #else
  30. #include "ultralcd_implementation_hitachi_HD44780.h"
  31. #endif
  32. // The main status screen
  33. static void lcd_status_screen();
  34. #ifdef ULTIPANEL
  35. #if HAS_POWER_SWITCH
  36. extern bool powersupply;
  37. #endif
  38. static float manual_feedrate[] = MANUAL_FEEDRATE;
  39. static void lcd_main_menu();
  40. static void lcd_tune_menu();
  41. static void lcd_prepare_menu();
  42. static void lcd_move_menu();
  43. static void lcd_control_menu();
  44. static void lcd_control_temperature_menu();
  45. static void lcd_control_temperature_preheat_pla_settings_menu();
  46. static void lcd_control_temperature_preheat_abs_settings_menu();
  47. static void lcd_control_motion_menu();
  48. static void lcd_control_volumetric_menu();
  49. #ifdef HAS_LCD_CONTRAST
  50. static void lcd_set_contrast();
  51. #endif
  52. #ifdef FWRETRACT
  53. static void lcd_control_retract_menu();
  54. #endif
  55. static void lcd_sdcard_menu();
  56. #ifdef DELTA_CALIBRATION_MENU
  57. static void lcd_delta_calibrate_menu();
  58. #endif
  59. #if defined(MANUAL_BED_LEVELING)
  60. #include "mesh_bed_leveling.h"
  61. static void _lcd_level_bed();
  62. static void _lcd_level_bed_homing();
  63. static void lcd_level_bed();
  64. #endif
  65. /* Different types of actions that can be used in menu items. */
  66. static void menu_action_back(menuFunc_t data);
  67. static void menu_action_submenu(menuFunc_t data);
  68. static void menu_action_gcode(const char* pgcode);
  69. static void menu_action_function(menuFunc_t data);
  70. static void menu_action_sdfile(const char* filename, char* longFilename);
  71. static void menu_action_sddirectory(const char* filename, char* longFilename);
  72. static void menu_action_setting_edit_bool(const char* pstr, bool* ptr);
  73. static void menu_action_setting_edit_int3(const char* pstr, int* ptr, int minValue, int maxValue);
  74. static void menu_action_setting_edit_float3(const char* pstr, float* ptr, float minValue, float maxValue);
  75. static void menu_action_setting_edit_float32(const char* pstr, float* ptr, float minValue, float maxValue);
  76. static void menu_action_setting_edit_float43(const char* pstr, float* ptr, float minValue, float maxValue);
  77. static void menu_action_setting_edit_float5(const char* pstr, float* ptr, float minValue, float maxValue);
  78. static void menu_action_setting_edit_float51(const char* pstr, float* ptr, float minValue, float maxValue);
  79. static void menu_action_setting_edit_float52(const char* pstr, float* ptr, float minValue, float maxValue);
  80. static void menu_action_setting_edit_long5(const char* pstr, unsigned long* ptr, unsigned long minValue, unsigned long maxValue);
  81. static void menu_action_setting_edit_callback_bool(const char* pstr, bool* ptr, menuFunc_t callbackFunc);
  82. static void menu_action_setting_edit_callback_int3(const char* pstr, int* ptr, int minValue, int maxValue, menuFunc_t callbackFunc);
  83. static void menu_action_setting_edit_callback_float3(const char* pstr, float* ptr, float minValue, float maxValue, menuFunc_t callbackFunc);
  84. static void menu_action_setting_edit_callback_float32(const char* pstr, float* ptr, float minValue, float maxValue, menuFunc_t callbackFunc);
  85. static void menu_action_setting_edit_callback_float43(const char* pstr, float* ptr, float minValue, float maxValue, menuFunc_t callbackFunc);
  86. static void menu_action_setting_edit_callback_float5(const char* pstr, float* ptr, float minValue, float maxValue, menuFunc_t callbackFunc);
  87. static void menu_action_setting_edit_callback_float51(const char* pstr, float* ptr, float minValue, float maxValue, menuFunc_t callbackFunc);
  88. static void menu_action_setting_edit_callback_float52(const char* pstr, float* ptr, float minValue, float maxValue, menuFunc_t callbackFunc);
  89. static void menu_action_setting_edit_callback_long5(const char* pstr, unsigned long* ptr, unsigned long minValue, unsigned long maxValue, menuFunc_t callbackFunc);
  90. #define ENCODER_FEEDRATE_DEADZONE 10
  91. #if !defined(LCD_I2C_VIKI)
  92. #ifndef ENCODER_STEPS_PER_MENU_ITEM
  93. #define ENCODER_STEPS_PER_MENU_ITEM 5
  94. #endif
  95. #ifndef ENCODER_PULSES_PER_STEP
  96. #define ENCODER_PULSES_PER_STEP 1
  97. #endif
  98. #else
  99. #ifndef ENCODER_STEPS_PER_MENU_ITEM
  100. #define ENCODER_STEPS_PER_MENU_ITEM 2 // VIKI LCD rotary encoder uses a different number of steps per rotation
  101. #endif
  102. #ifndef ENCODER_PULSES_PER_STEP
  103. #define ENCODER_PULSES_PER_STEP 1
  104. #endif
  105. #endif
  106. /* Helper macros for menus */
  107. /**
  108. * START_MENU generates the init code for a menu function
  109. */
  110. #define START_MENU() do { \
  111. encoderRateMultiplierEnabled = false; \
  112. if (encoderPosition > 0x8000) encoderPosition = 0; \
  113. uint8_t encoderLine = encoderPosition / ENCODER_STEPS_PER_MENU_ITEM; \
  114. if (encoderLine < currentMenuViewOffset) currentMenuViewOffset = encoderLine; \
  115. uint8_t _lineNr = currentMenuViewOffset, _menuItemNr; \
  116. bool wasClicked = LCD_CLICKED, itemSelected; \
  117. for (uint8_t _drawLineNr = 0; _drawLineNr < LCD_HEIGHT; _drawLineNr++, _lineNr++) { \
  118. _menuItemNr = 0;
  119. /**
  120. * MENU_ITEM generates draw & handler code for a menu item, potentially calling:
  121. *
  122. * lcd_implementation_drawmenu_[type](sel, row, label, arg3...)
  123. * menu_action_[type](arg3...)
  124. *
  125. * Examples:
  126. * MENU_ITEM(back, MSG_WATCH, lcd_status_screen)
  127. * lcd_implementation_drawmenu_back(sel, row, PSTR(MSG_WATCH), lcd_status_screen)
  128. * menu_action_back(lcd_status_screen)
  129. *
  130. * MENU_ITEM(function, MSG_PAUSE_PRINT, lcd_sdcard_pause)
  131. * lcd_implementation_drawmenu_function(sel, row, PSTR(MSG_PAUSE_PRINT), lcd_sdcard_pause)
  132. * menu_action_function(lcd_sdcard_pause)
  133. *
  134. * MENU_ITEM_EDIT(int3, MSG_SPEED, &feedrate_multiplier, 10, 999)
  135. * MENU_ITEM(setting_edit_int3, MSG_SPEED, PSTR(MSG_SPEED), &feedrate_multiplier, 10, 999)
  136. * lcd_implementation_drawmenu_setting_edit_int3(sel, row, PSTR(MSG_SPEED), PSTR(MSG_SPEED), &feedrate_multiplier, 10, 999)
  137. * menu_action_setting_edit_int3(PSTR(MSG_SPEED), &feedrate_multiplier, 10, 999)
  138. *
  139. */
  140. #define MENU_ITEM(type, label, args...) do { \
  141. if (_menuItemNr == _lineNr) { \
  142. itemSelected = encoderLine == _menuItemNr; \
  143. if (lcdDrawUpdate) \
  144. lcd_implementation_drawmenu_ ## type(itemSelected, _drawLineNr, PSTR(label), ## args); \
  145. if (wasClicked && itemSelected) { \
  146. lcd_quick_feedback(); \
  147. menu_action_ ## type(args); \
  148. return; \
  149. } \
  150. } \
  151. _menuItemNr++; \
  152. } while(0)
  153. #ifdef ENCODER_RATE_MULTIPLIER
  154. /**
  155. * MENU_MULTIPLIER_ITEM generates drawing and handling code for a multiplier menu item
  156. */
  157. #define MENU_MULTIPLIER_ITEM(type, label, args...) do { \
  158. if (_menuItemNr == _lineNr) { \
  159. itemSelected = encoderLine == _menuItemNr; \
  160. if (lcdDrawUpdate) \
  161. lcd_implementation_drawmenu_ ## type(itemSelected, _drawLineNr, PSTR(label), ## args); \
  162. if (wasClicked && itemSelected) { \
  163. lcd_quick_feedback(); \
  164. encoderRateMultiplierEnabled = true; \
  165. lastEncoderMovementMillis = 0; \
  166. menu_action_ ## type(args); \
  167. return; \
  168. } \
  169. } \
  170. _menuItemNr++; \
  171. } while(0)
  172. #endif //ENCODER_RATE_MULTIPLIER
  173. #define MENU_ITEM_DUMMY() do { _menuItemNr++; } while(0)
  174. #define MENU_ITEM_EDIT(type, label, args...) MENU_ITEM(setting_edit_ ## type, label, PSTR(label), ## args)
  175. #define MENU_ITEM_EDIT_CALLBACK(type, label, args...) MENU_ITEM(setting_edit_callback_ ## type, label, PSTR(label), ## args)
  176. #ifdef ENCODER_RATE_MULTIPLIER
  177. #define MENU_MULTIPLIER_ITEM_EDIT(type, label, args...) MENU_MULTIPLIER_ITEM(setting_edit_ ## type, label, PSTR(label), ## args)
  178. #define MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(type, label, args...) MENU_MULTIPLIER_ITEM(setting_edit_callback_ ## type, label, PSTR(label), ## args)
  179. #else //!ENCODER_RATE_MULTIPLIER
  180. #define MENU_MULTIPLIER_ITEM_EDIT(type, label, args...) MENU_ITEM(setting_edit_ ## type, label, PSTR(label), ## args)
  181. #define MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(type, label, args...) MENU_ITEM(setting_edit_callback_ ## type, label, PSTR(label), ## args)
  182. #endif //!ENCODER_RATE_MULTIPLIER
  183. #define END_MENU() \
  184. if (encoderLine >= _menuItemNr) { encoderPosition = _menuItemNr * ENCODER_STEPS_PER_MENU_ITEM - 1; encoderLine = encoderPosition / ENCODER_STEPS_PER_MENU_ITEM; }\
  185. if (encoderLine >= currentMenuViewOffset + LCD_HEIGHT) { currentMenuViewOffset = encoderLine - LCD_HEIGHT + 1; lcdDrawUpdate = 1; _lineNr = currentMenuViewOffset - 1; _drawLineNr = -1; } \
  186. } } while(0)
  187. /** Used variables to keep track of the menu */
  188. #ifndef REPRAPWORLD_KEYPAD
  189. volatile uint8_t buttons; // Bits of the pressed buttons.
  190. #else
  191. volatile uint8_t buttons_reprapworld_keypad; // The reprapworld_keypad shift register values
  192. #endif
  193. #ifdef LCD_HAS_SLOW_BUTTONS
  194. volatile uint8_t slow_buttons; // Bits of the pressed buttons.
  195. #endif
  196. uint8_t currentMenuViewOffset; /* scroll offset in the current menu */
  197. millis_t next_button_update_ms;
  198. uint8_t lastEncoderBits;
  199. uint32_t encoderPosition;
  200. #if (SDCARDDETECT > 0)
  201. bool lcd_oldcardstatus;
  202. #endif
  203. #endif // ULTIPANEL
  204. menuFunc_t currentMenu = lcd_status_screen; /* function pointer to the currently active menu */
  205. millis_t next_lcd_update_ms;
  206. uint8_t lcd_status_update_delay;
  207. bool ignore_click = false;
  208. bool wait_for_unclick;
  209. 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) */
  210. //prevMenu and prevEncoderPosition are used to store the previous menu location when editing settings.
  211. menuFunc_t prevMenu = NULL;
  212. uint16_t prevEncoderPosition;
  213. //Variables used when editing values.
  214. const char* editLabel;
  215. void* editValue;
  216. int32_t minEditValue, maxEditValue;
  217. menuFunc_t callbackFunc;
  218. // place-holders for Ki and Kd edits
  219. float raw_Ki, raw_Kd;
  220. static void lcd_goto_menu(menuFunc_t menu, const bool feedback=false, const uint32_t encoder=0) {
  221. if (currentMenu != menu) {
  222. currentMenu = menu;
  223. #ifdef NEWPANEL
  224. encoderPosition = encoder;
  225. if (feedback) lcd_quick_feedback();
  226. #endif
  227. // For LCD_PROGRESS_BAR re-initialize the custom characters
  228. #ifdef LCD_PROGRESS_BAR
  229. lcd_set_custom_characters(menu == lcd_status_screen);
  230. #endif
  231. }
  232. }
  233. /* Main status screen. It's up to the implementation specific part to show what is needed. As this is very display dependent */
  234. static void lcd_status_screen() {
  235. encoderRateMultiplierEnabled = false;
  236. #ifdef LCD_PROGRESS_BAR
  237. millis_t ms = millis();
  238. #ifndef PROGRESS_MSG_ONCE
  239. if (ms > progressBarTick + PROGRESS_BAR_MSG_TIME + PROGRESS_BAR_BAR_TIME) {
  240. progressBarTick = ms;
  241. }
  242. #endif
  243. #if PROGRESS_MSG_EXPIRE > 0
  244. // Handle message expire
  245. if (expireStatusMillis > 0) {
  246. if (card.isFileOpen()) {
  247. // Expire the message when printing is active
  248. if (IS_SD_PRINTING) {
  249. // Expire the message when printing is active
  250. if (ms >= expireStatusMillis) {
  251. lcd_status_message[0] = '\0';
  252. expireStatusMillis = 0;
  253. }
  254. }
  255. else {
  256. expireStatusMillis += LCD_UPDATE_INTERVAL;
  257. }
  258. }
  259. else {
  260. expireStatusMillis = 0;
  261. }
  262. }
  263. #endif
  264. #endif //LCD_PROGRESS_BAR
  265. lcd_implementation_status_screen();
  266. #ifdef ULTIPANEL
  267. bool current_click = LCD_CLICKED;
  268. if (ignore_click) {
  269. if (wait_for_unclick) {
  270. if (!current_click)
  271. ignore_click = wait_for_unclick = false;
  272. else
  273. current_click = false;
  274. }
  275. else if (current_click) {
  276. lcd_quick_feedback();
  277. wait_for_unclick = true;
  278. current_click = false;
  279. }
  280. }
  281. if (current_click) {
  282. lcd_goto_menu(lcd_main_menu, true);
  283. lcd_implementation_init( // to maybe revive the LCD if static electricity killed it.
  284. #ifdef LCD_PROGRESS_BAR
  285. currentMenu == lcd_status_screen
  286. #endif
  287. );
  288. #ifdef FILAMENT_LCD_DISPLAY
  289. previous_lcd_status_ms = millis(); // get status message to show up for a while
  290. #endif
  291. }
  292. #ifdef ULTIPANEL_FEEDMULTIPLY
  293. // Dead zone at 100% feedrate
  294. if ((feedrate_multiplier < 100 && (feedrate_multiplier + int(encoderPosition)) > 100) ||
  295. (feedrate_multiplier > 100 && (feedrate_multiplier + int(encoderPosition)) < 100)) {
  296. encoderPosition = 0;
  297. feedrate_multiplier = 100;
  298. }
  299. if (feedrate_multiplier == 100) {
  300. if (int(encoderPosition) > ENCODER_FEEDRATE_DEADZONE) {
  301. feedrate_multiplier += int(encoderPosition) - ENCODER_FEEDRATE_DEADZONE;
  302. encoderPosition = 0;
  303. }
  304. else if (int(encoderPosition) < -ENCODER_FEEDRATE_DEADZONE) {
  305. feedrate_multiplier += int(encoderPosition) + ENCODER_FEEDRATE_DEADZONE;
  306. encoderPosition = 0;
  307. }
  308. }
  309. else {
  310. feedrate_multiplier += int(encoderPosition);
  311. encoderPosition = 0;
  312. }
  313. #endif // ULTIPANEL_FEEDMULTIPLY
  314. feedrate_multiplier = constrain(feedrate_multiplier, 10, 999);
  315. #endif //ULTIPANEL
  316. }
  317. #ifdef ULTIPANEL
  318. static void lcd_return_to_status() { lcd_goto_menu(lcd_status_screen); }
  319. static void lcd_sdcard_pause() { card.pauseSDPrint(); }
  320. static void lcd_sdcard_resume() { card.startFileprint(); }
  321. static void lcd_sdcard_stop() {
  322. quickStop();
  323. card.sdprinting = false;
  324. card.closefile();
  325. autotempShutdown();
  326. cancel_heatup = true;
  327. lcd_setstatus(MSG_PRINT_ABORTED, true);
  328. }
  329. /* Menu implementation */
  330. static void lcd_main_menu() {
  331. START_MENU();
  332. MENU_ITEM(back, MSG_WATCH, lcd_status_screen);
  333. if (movesplanned() || IS_SD_PRINTING) {
  334. MENU_ITEM(submenu, MSG_TUNE, lcd_tune_menu);
  335. }
  336. else {
  337. MENU_ITEM(submenu, MSG_PREPARE, lcd_prepare_menu);
  338. #ifdef DELTA_CALIBRATION_MENU
  339. MENU_ITEM(submenu, MSG_DELTA_CALIBRATE, lcd_delta_calibrate_menu);
  340. #endif
  341. }
  342. MENU_ITEM(submenu, MSG_CONTROL, lcd_control_menu);
  343. #ifdef SDSUPPORT
  344. if (card.cardOK) {
  345. if (card.isFileOpen()) {
  346. if (card.sdprinting)
  347. MENU_ITEM(function, MSG_PAUSE_PRINT, lcd_sdcard_pause);
  348. else
  349. MENU_ITEM(function, MSG_RESUME_PRINT, lcd_sdcard_resume);
  350. MENU_ITEM(function, MSG_STOP_PRINT, lcd_sdcard_stop);
  351. }
  352. else {
  353. MENU_ITEM(submenu, MSG_CARD_MENU, lcd_sdcard_menu);
  354. #if SDCARDDETECT < 1
  355. MENU_ITEM(gcode, MSG_CNG_SDCARD, PSTR("M21")); // SD-card changed by user
  356. #endif
  357. }
  358. }
  359. else {
  360. MENU_ITEM(submenu, MSG_NO_CARD, lcd_sdcard_menu);
  361. #if SDCARDDETECT < 1
  362. MENU_ITEM(gcode, MSG_INIT_SDCARD, PSTR("M21")); // Manually initialize the SD-card via user interface
  363. #endif
  364. }
  365. #endif //SDSUPPORT
  366. END_MENU();
  367. }
  368. #if defined(SDSUPPORT) && defined(MENU_ADDAUTOSTART)
  369. static void lcd_autostart_sd() {
  370. card.autostart_index = 0;
  371. card.setroot();
  372. card.checkautostart(true);
  373. }
  374. #endif
  375. void lcd_set_home_offsets() {
  376. for (int8_t i=0; i < NUM_AXIS; i++) {
  377. if (i != E_AXIS) {
  378. home_offset[i] -= current_position[i];
  379. current_position[i] = 0.0;
  380. }
  381. }
  382. plan_set_position(0.0, 0.0, 0.0, current_position[E_AXIS]);
  383. // Audio feedback
  384. enqueuecommands_P(PSTR("M300 S659 P200\nM300 S698 P200"));
  385. lcd_return_to_status();
  386. }
  387. #ifdef BABYSTEPPING
  388. static void _lcd_babystep(int axis, const char *msg) {
  389. if (encoderPosition != 0) {
  390. babystepsTodo[axis] += (int)encoderPosition;
  391. encoderPosition = 0;
  392. lcdDrawUpdate = 1;
  393. }
  394. if (lcdDrawUpdate) lcd_implementation_drawedit(msg, "");
  395. if (LCD_CLICKED) lcd_goto_menu(lcd_tune_menu);
  396. }
  397. static void lcd_babystep_x() { _lcd_babystep(X_AXIS, PSTR(MSG_BABYSTEPPING_X)); }
  398. static void lcd_babystep_y() { _lcd_babystep(Y_AXIS, PSTR(MSG_BABYSTEPPING_Y)); }
  399. static void lcd_babystep_z() { _lcd_babystep(Z_AXIS, PSTR(MSG_BABYSTEPPING_Z)); }
  400. #endif //BABYSTEPPING
  401. static void lcd_tune_menu() {
  402. START_MENU();
  403. MENU_ITEM(back, MSG_MAIN, lcd_main_menu);
  404. MENU_ITEM_EDIT(int3, MSG_SPEED, &feedrate_multiplier, 10, 999);
  405. #if TEMP_SENSOR_0 != 0
  406. MENU_MULTIPLIER_ITEM_EDIT(int3, MSG_NOZZLE, &target_temperature[0], 0, HEATER_0_MAXTEMP - 15);
  407. #endif
  408. #if TEMP_SENSOR_1 != 0
  409. MENU_MULTIPLIER_ITEM_EDIT(int3, MSG_NOZZLE MSG_N2, &target_temperature[1], 0, HEATER_1_MAXTEMP - 15);
  410. #endif
  411. #if TEMP_SENSOR_2 != 0
  412. MENU_MULTIPLIER_ITEM_EDIT(int3, MSG_NOZZLE MSG_N3, &target_temperature[2], 0, HEATER_2_MAXTEMP - 15);
  413. #endif
  414. #if TEMP_SENSOR_3 != 0
  415. MENU_MULTIPLIER_ITEM_EDIT(int3, MSG_NOZZLE MSG_N4, &target_temperature[3], 0, HEATER_3_MAXTEMP - 15);
  416. #endif
  417. #if TEMP_SENSOR_BED != 0
  418. MENU_MULTIPLIER_ITEM_EDIT(int3, MSG_BED, &target_temperature_bed, 0, BED_MAXTEMP - 15);
  419. #endif
  420. MENU_MULTIPLIER_ITEM_EDIT(int3, MSG_FAN_SPEED, &fanSpeed, 0, 255);
  421. MENU_ITEM_EDIT(int3, MSG_FLOW, &extruder_multiply[active_extruder], 10, 999);
  422. MENU_ITEM_EDIT(int3, MSG_FLOW MSG_F0, &extruder_multiply[0], 10, 999);
  423. #if TEMP_SENSOR_1 != 0
  424. MENU_ITEM_EDIT(int3, MSG_FLOW MSG_F1, &extruder_multiply[1], 10, 999);
  425. #endif
  426. #if TEMP_SENSOR_2 != 0
  427. MENU_ITEM_EDIT(int3, MSG_FLOW MSG_F2, &extruder_multiply[2], 10, 999);
  428. #endif
  429. #if TEMP_SENSOR_3 != 0
  430. MENU_ITEM_EDIT(int3, MSG_FLOW MSG_F3, &extruder_multiply[3], 10, 999);
  431. #endif
  432. #ifdef BABYSTEPPING
  433. #ifdef BABYSTEP_XY
  434. MENU_ITEM(submenu, MSG_BABYSTEP_X, lcd_babystep_x);
  435. MENU_ITEM(submenu, MSG_BABYSTEP_Y, lcd_babystep_y);
  436. #endif //BABYSTEP_XY
  437. MENU_ITEM(submenu, MSG_BABYSTEP_Z, lcd_babystep_z);
  438. #endif
  439. #ifdef FILAMENTCHANGEENABLE
  440. MENU_ITEM(gcode, MSG_FILAMENTCHANGE, PSTR("M600"));
  441. #endif
  442. END_MENU();
  443. }
  444. void _lcd_preheat(int endnum, const float temph, const float tempb, const int fan) {
  445. if (temph > 0) setTargetHotend(temph, endnum);
  446. setTargetBed(tempb);
  447. fanSpeed = fan;
  448. lcd_return_to_status();
  449. setWatch(); // heater sanity check timer
  450. }
  451. void lcd_preheat_pla0() { _lcd_preheat(0, plaPreheatHotendTemp, plaPreheatHPBTemp, plaPreheatFanSpeed); }
  452. void lcd_preheat_abs0() { _lcd_preheat(0, absPreheatHotendTemp, absPreheatHPBTemp, absPreheatFanSpeed); }
  453. #if TEMP_SENSOR_1 != 0 || TEMP_SENSOR_2 != 0 || TEMP_SENSOR_3 != 0 || TEMP_SENSOR_BED != 0 //more than one extruder present
  454. #if TEMP_SENSOR_1 != 0
  455. void lcd_preheat_pla1() { _lcd_preheat(1, plaPreheatHotendTemp, plaPreheatHPBTemp, plaPreheatFanSpeed); }
  456. void lcd_preheat_abs1() { _lcd_preheat(1, absPreheatHotendTemp, absPreheatHPBTemp, absPreheatFanSpeed); }
  457. #endif
  458. #if TEMP_SENSOR_2 != 0
  459. void lcd_preheat_pla2() { _lcd_preheat(2, plaPreheatHotendTemp, plaPreheatHPBTemp, plaPreheatFanSpeed); }
  460. void lcd_preheat_abs2() { _lcd_preheat(2, absPreheatHotendTemp, absPreheatHPBTemp, absPreheatFanSpeed); }
  461. #endif
  462. #if TEMP_SENSOR_3 != 0
  463. void lcd_preheat_pla3() { _lcd_preheat(3, plaPreheatHotendTemp, plaPreheatHPBTemp, plaPreheatFanSpeed); }
  464. void lcd_preheat_abs3() { _lcd_preheat(3, absPreheatHotendTemp, absPreheatHPBTemp, absPreheatFanSpeed); }
  465. #endif
  466. void lcd_preheat_pla0123() {
  467. setTargetHotend0(plaPreheatHotendTemp);
  468. setTargetHotend1(plaPreheatHotendTemp);
  469. setTargetHotend2(plaPreheatHotendTemp);
  470. _lcd_preheat(3, plaPreheatHotendTemp, plaPreheatHPBTemp, plaPreheatFanSpeed);
  471. }
  472. void lcd_preheat_abs0123() {
  473. setTargetHotend0(absPreheatHotendTemp);
  474. setTargetHotend1(absPreheatHotendTemp);
  475. setTargetHotend2(absPreheatHotendTemp);
  476. _lcd_preheat(3, absPreheatHotendTemp, absPreheatHPBTemp, absPreheatFanSpeed);
  477. }
  478. #if TEMP_SENSOR_0 != 0
  479. void lcd_preheat_pla_bedonly() { _lcd_preheat(0, 0, plaPreheatHPBTemp, plaPreheatFanSpeed); }
  480. void lcd_preheat_abs_bedonly() { _lcd_preheat(0, 0, absPreheatHPBTemp, absPreheatFanSpeed); }
  481. static void lcd_preheat_pla_menu() {
  482. START_MENU();
  483. MENU_ITEM(back, MSG_PREPARE, lcd_prepare_menu);
  484. MENU_ITEM(function, MSG_PREHEAT_PLA_N MSG_H1, lcd_preheat_pla0);
  485. #if TEMP_SENSOR_1 != 0
  486. MENU_ITEM(function, MSG_PREHEAT_PLA_N MSG_H2, lcd_preheat_pla1);
  487. #endif
  488. #if TEMP_SENSOR_2 != 0
  489. MENU_ITEM(function, MSG_PREHEAT_PLA_N MSG_H3, lcd_preheat_pla2);
  490. #endif
  491. #if TEMP_SENSOR_3 != 0
  492. MENU_ITEM(function, MSG_PREHEAT_PLA_N MSG_H4, lcd_preheat_pla3);
  493. #endif
  494. MENU_ITEM(function, MSG_PREHEAT_PLA_ALL, lcd_preheat_pla0123);
  495. #if TEMP_SENSOR_BED != 0
  496. MENU_ITEM(function, MSG_PREHEAT_PLA_BEDONLY, lcd_preheat_pla_bedonly);
  497. #endif
  498. END_MENU();
  499. }
  500. static void lcd_preheat_abs_menu() {
  501. START_MENU();
  502. MENU_ITEM(back, MSG_PREPARE, lcd_prepare_menu);
  503. MENU_ITEM(function, MSG_PREHEAT_ABS_N MSG_H1, lcd_preheat_abs0);
  504. #if TEMP_SENSOR_1 != 0
  505. MENU_ITEM(function, MSG_PREHEAT_ABS_N MSG_H2, lcd_preheat_abs1);
  506. #endif
  507. #if TEMP_SENSOR_2 != 0
  508. MENU_ITEM(function, MSG_PREHEAT_ABS_N MSG_H3, lcd_preheat_abs2);
  509. #endif
  510. #if TEMP_SENSOR_3 != 0
  511. MENU_ITEM(function, MSG_PREHEAT_ABS_N MSG_H4, lcd_preheat_abs3);
  512. #endif
  513. MENU_ITEM(function, MSG_PREHEAT_ABS_ALL, lcd_preheat_abs0123);
  514. #if TEMP_SENSOR_BED != 0
  515. MENU_ITEM(function, MSG_PREHEAT_ABS_BEDONLY, lcd_preheat_abs_bedonly);
  516. #endif
  517. END_MENU();
  518. }
  519. #endif
  520. #endif // more than one temperature sensor present
  521. void lcd_cooldown() {
  522. setTargetHotend0(0);
  523. setTargetHotend1(0);
  524. setTargetHotend2(0);
  525. setTargetHotend3(0);
  526. setTargetBed(0);
  527. fanSpeed = 0;
  528. lcd_return_to_status();
  529. }
  530. static void lcd_prepare_menu() {
  531. START_MENU();
  532. MENU_ITEM(back, MSG_MAIN, lcd_main_menu);
  533. #if defined( SDSUPPORT ) && defined( MENU_ADDAUTOSTART )
  534. MENU_ITEM(function, MSG_AUTOSTART, lcd_autostart_sd);
  535. #endif
  536. MENU_ITEM(gcode, MSG_DISABLE_STEPPERS, PSTR("M84"));
  537. MENU_ITEM(gcode, MSG_AUTO_HOME, PSTR("G28"));
  538. MENU_ITEM(function, MSG_SET_HOME_OFFSETS, lcd_set_home_offsets);
  539. //MENU_ITEM(gcode, MSG_SET_ORIGIN, PSTR("G92 X0 Y0 Z0"));
  540. #if TEMP_SENSOR_0 != 0
  541. #if TEMP_SENSOR_1 != 0 || TEMP_SENSOR_2 != 0 || TEMP_SENSOR_3 != 0 || TEMP_SENSOR_BED != 0
  542. MENU_ITEM(submenu, MSG_PREHEAT_PLA, lcd_preheat_pla_menu);
  543. MENU_ITEM(submenu, MSG_PREHEAT_ABS, lcd_preheat_abs_menu);
  544. #else
  545. MENU_ITEM(function, MSG_PREHEAT_PLA, lcd_preheat_pla0);
  546. MENU_ITEM(function, MSG_PREHEAT_ABS, lcd_preheat_abs0);
  547. #endif
  548. #endif
  549. MENU_ITEM(function, MSG_COOLDOWN, lcd_cooldown);
  550. #if HAS_POWER_SWITCH
  551. if (powersupply)
  552. MENU_ITEM(gcode, MSG_SWITCH_PS_OFF, PSTR("M81"));
  553. else
  554. MENU_ITEM(gcode, MSG_SWITCH_PS_ON, PSTR("M80"));
  555. #endif
  556. MENU_ITEM(submenu, MSG_MOVE_AXIS, lcd_move_menu);
  557. #if defined(MANUAL_BED_LEVELING)
  558. MENU_ITEM(submenu, MSG_LEVEL_BED, lcd_level_bed);
  559. #endif
  560. END_MENU();
  561. }
  562. #ifdef DELTA_CALIBRATION_MENU
  563. static void lcd_delta_calibrate_menu() {
  564. START_MENU();
  565. MENU_ITEM(back, MSG_MAIN, lcd_main_menu);
  566. MENU_ITEM(gcode, MSG_AUTO_HOME, PSTR("G28"));
  567. MENU_ITEM(gcode, MSG_DELTA_CALIBRATE_X, PSTR("G0 F8000 X-77.94 Y-45 Z0"));
  568. MENU_ITEM(gcode, MSG_DELTA_CALIBRATE_Y, PSTR("G0 F8000 X77.94 Y-45 Z0"));
  569. MENU_ITEM(gcode, MSG_DELTA_CALIBRATE_Z, PSTR("G0 F8000 X0 Y90 Z0"));
  570. MENU_ITEM(gcode, MSG_DELTA_CALIBRATE_CENTER, PSTR("G0 F8000 X0 Y0 Z0"));
  571. END_MENU();
  572. }
  573. #endif // DELTA_CALIBRATION_MENU
  574. inline void line_to_current() {
  575. #ifdef DELTA
  576. calculate_delta(current_position);
  577. plan_buffer_line(delta[X_AXIS], delta[Y_AXIS], delta[Z_AXIS], current_position[E_AXIS], manual_feedrate[X_AXIS]/60, active_extruder);
  578. #else
  579. plan_buffer_line(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS], manual_feedrate[X_AXIS]/60, active_extruder);
  580. #endif
  581. }
  582. float move_menu_scale;
  583. static void lcd_move_menu_axis();
  584. static void _lcd_move(const char *name, int axis, int min, int max) {
  585. if (encoderPosition != 0) {
  586. refresh_cmd_timeout();
  587. current_position[axis] += float((int)encoderPosition) * move_menu_scale;
  588. if (min_software_endstops && current_position[axis] < min) current_position[axis] = min;
  589. if (max_software_endstops && current_position[axis] > max) current_position[axis] = max;
  590. encoderPosition = 0;
  591. line_to_current();
  592. lcdDrawUpdate = 1;
  593. }
  594. if (lcdDrawUpdate) lcd_implementation_drawedit(name, ftostr31(current_position[axis]));
  595. if (LCD_CLICKED) lcd_goto_menu(lcd_move_menu_axis);
  596. }
  597. static void lcd_move_x() { _lcd_move(PSTR("X"), X_AXIS, X_MIN_POS, X_MAX_POS); }
  598. static void lcd_move_y() { _lcd_move(PSTR("Y"), Y_AXIS, Y_MIN_POS, Y_MAX_POS); }
  599. static void lcd_move_z() { _lcd_move(PSTR("Z"), Z_AXIS, Z_MIN_POS, Z_MAX_POS); }
  600. static void lcd_move_e() {
  601. if (encoderPosition != 0) {
  602. current_position[E_AXIS] += float((int)encoderPosition) * move_menu_scale;
  603. encoderPosition = 0;
  604. line_to_current();
  605. lcdDrawUpdate = 1;
  606. }
  607. if (lcdDrawUpdate) lcd_implementation_drawedit(PSTR("Extruder"), ftostr31(current_position[E_AXIS]));
  608. if (LCD_CLICKED) lcd_goto_menu(lcd_move_menu_axis);
  609. }
  610. static void lcd_move_menu_axis() {
  611. START_MENU();
  612. MENU_ITEM(back, MSG_MOVE_AXIS, lcd_move_menu);
  613. MENU_ITEM(submenu, MSG_MOVE_X, lcd_move_x);
  614. MENU_ITEM(submenu, MSG_MOVE_Y, lcd_move_y);
  615. if (move_menu_scale < 10.0) {
  616. MENU_ITEM(submenu, MSG_MOVE_Z, lcd_move_z);
  617. MENU_ITEM(submenu, MSG_MOVE_E, lcd_move_e);
  618. }
  619. END_MENU();
  620. }
  621. static void lcd_move_menu_10mm() {
  622. move_menu_scale = 10.0;
  623. lcd_move_menu_axis();
  624. }
  625. static void lcd_move_menu_1mm() {
  626. move_menu_scale = 1.0;
  627. lcd_move_menu_axis();
  628. }
  629. static void lcd_move_menu_01mm() {
  630. move_menu_scale = 0.1;
  631. lcd_move_menu_axis();
  632. }
  633. static void lcd_move_menu() {
  634. START_MENU();
  635. MENU_ITEM(back, MSG_PREPARE, lcd_prepare_menu);
  636. MENU_ITEM(submenu, MSG_MOVE_10MM, lcd_move_menu_10mm);
  637. MENU_ITEM(submenu, MSG_MOVE_1MM, lcd_move_menu_1mm);
  638. MENU_ITEM(submenu, MSG_MOVE_01MM, lcd_move_menu_01mm);
  639. //TODO:X,Y,Z,E
  640. END_MENU();
  641. }
  642. static void lcd_control_menu() {
  643. START_MENU();
  644. MENU_ITEM(back, MSG_MAIN, lcd_main_menu);
  645. MENU_ITEM(submenu, MSG_TEMPERATURE, lcd_control_temperature_menu);
  646. MENU_ITEM(submenu, MSG_MOTION, lcd_control_motion_menu);
  647. MENU_ITEM(submenu, MSG_VOLUMETRIC, lcd_control_volumetric_menu);
  648. #ifdef HAS_LCD_CONTRAST
  649. //MENU_ITEM_EDIT(int3, MSG_CONTRAST, &lcd_contrast, 0, 63);
  650. MENU_ITEM(submenu, MSG_CONTRAST, lcd_set_contrast);
  651. #endif
  652. #ifdef FWRETRACT
  653. MENU_ITEM(submenu, MSG_RETRACT, lcd_control_retract_menu);
  654. #endif
  655. #ifdef EEPROM_SETTINGS
  656. MENU_ITEM(function, MSG_STORE_EPROM, Config_StoreSettings);
  657. MENU_ITEM(function, MSG_LOAD_EPROM, Config_RetrieveSettings);
  658. #endif
  659. MENU_ITEM(function, MSG_RESTORE_FAILSAFE, Config_ResetDefault);
  660. END_MENU();
  661. }
  662. #ifdef PIDTEMP
  663. // Helpers for editing PID Ki & Kd values
  664. // grab the PID value out of the temp variable; scale it; then update the PID driver
  665. void copy_and_scalePID_i(int e) {
  666. PID_PARAM(Ki, e) = scalePID_i(raw_Ki);
  667. updatePID();
  668. }
  669. void copy_and_scalePID_d(int e) {
  670. PID_PARAM(Kd, e) = scalePID_d(raw_Kd);
  671. updatePID();
  672. }
  673. void copy_and_scalePID_i_E1() { copy_and_scalePID_i(0); }
  674. void copy_and_scalePID_d_E1() { copy_and_scalePID_d(0); }
  675. #ifdef PID_PARAMS_PER_EXTRUDER
  676. #if EXTRUDERS > 1
  677. void copy_and_scalePID_i_E2() { copy_and_scalePID_i(1); }
  678. void copy_and_scalePID_d_E2() { copy_and_scalePID_d(1); }
  679. #if EXTRUDERS > 2
  680. void copy_and_scalePID_i_E3() { copy_and_scalePID_i(2); }
  681. void copy_and_scalePID_d_E3() { copy_and_scalePID_d(2); }
  682. #if EXTRUDERS > 3
  683. void copy_and_scalePID_i_E4() { copy_and_scalePID_i(3); }
  684. void copy_and_scalePID_d_E4() { copy_and_scalePID_d(3); }
  685. #endif //EXTRUDERS > 3
  686. #endif //EXTRUDERS > 2
  687. #endif //EXTRUDERS > 1
  688. #endif //PID_PARAMS_PER_EXTRUDER
  689. #endif //PIDTEMP
  690. static void lcd_control_temperature_menu() {
  691. START_MENU();
  692. MENU_ITEM(back, MSG_CONTROL, lcd_control_menu);
  693. #if TEMP_SENSOR_0 != 0
  694. MENU_MULTIPLIER_ITEM_EDIT(int3, MSG_NOZZLE, &target_temperature[0], 0, HEATER_0_MAXTEMP - 15);
  695. #endif
  696. #if EXTRUDERS > 1
  697. #if TEMP_SENSOR_1 != 0
  698. MENU_MULTIPLIER_ITEM_EDIT(int3, MSG_NOZZLE MSG_N2, &target_temperature[1], 0, HEATER_1_MAXTEMP - 15);
  699. #endif
  700. #if EXTRUDERS > 2
  701. #if TEMP_SENSOR_2 != 0
  702. MENU_MULTIPLIER_ITEM_EDIT(int3, MSG_NOZZLE MSG_N3, &target_temperature[2], 0, HEATER_2_MAXTEMP - 15);
  703. #endif
  704. #if EXTRUDERS > 3
  705. #if TEMP_SENSOR_3 != 0
  706. MENU_MULTIPLIER_ITEM_EDIT(int3, MSG_NOZZLE MSG_N4, &target_temperature[3], 0, HEATER_3_MAXTEMP - 15);
  707. #endif
  708. #endif // EXTRUDERS > 3
  709. #endif // EXTRUDERS > 2
  710. #endif // EXTRUDERS > 1
  711. #if TEMP_SENSOR_BED != 0
  712. MENU_MULTIPLIER_ITEM_EDIT(int3, MSG_BED, &target_temperature_bed, 0, BED_MAXTEMP - 15);
  713. #endif
  714. MENU_MULTIPLIER_ITEM_EDIT(int3, MSG_FAN_SPEED, &fanSpeed, 0, 255);
  715. #if defined(AUTOTEMP) && (TEMP_SENSOR_0 != 0)
  716. MENU_ITEM_EDIT(bool, MSG_AUTOTEMP, &autotemp_enabled);
  717. MENU_ITEM_EDIT(float3, MSG_MIN, &autotemp_min, 0, HEATER_0_MAXTEMP - 15);
  718. MENU_ITEM_EDIT(float3, MSG_MAX, &autotemp_max, 0, HEATER_0_MAXTEMP - 15);
  719. MENU_ITEM_EDIT(float32, MSG_FACTOR, &autotemp_factor, 0.0, 1.0);
  720. #endif
  721. #ifdef PIDTEMP
  722. // set up temp variables - undo the default scaling
  723. raw_Ki = unscalePID_i(PID_PARAM(Ki,0));
  724. raw_Kd = unscalePID_d(PID_PARAM(Kd,0));
  725. MENU_ITEM_EDIT(float52, MSG_PID_P, &PID_PARAM(Kp,0), 1, 9990);
  726. // i is typically a small value so allows values below 1
  727. MENU_ITEM_EDIT_CALLBACK(float52, MSG_PID_I, &raw_Ki, 0.01, 9990, copy_and_scalePID_i_E1);
  728. MENU_ITEM_EDIT_CALLBACK(float52, MSG_PID_D, &raw_Kd, 1, 9990, copy_and_scalePID_d_E1);
  729. #ifdef PID_ADD_EXTRUSION_RATE
  730. MENU_ITEM_EDIT(float3, MSG_PID_C, &PID_PARAM(Kc,0), 1, 9990);
  731. #endif//PID_ADD_EXTRUSION_RATE
  732. #ifdef PID_PARAMS_PER_EXTRUDER
  733. #if EXTRUDERS > 1
  734. // set up temp variables - undo the default scaling
  735. raw_Ki = unscalePID_i(PID_PARAM(Ki,1));
  736. raw_Kd = unscalePID_d(PID_PARAM(Kd,1));
  737. MENU_ITEM_EDIT(float52, MSG_PID_P MSG_E2, &PID_PARAM(Kp,1), 1, 9990);
  738. // i is typically a small value so allows values below 1
  739. MENU_ITEM_EDIT_CALLBACK(float52, MSG_PID_I MSG_E2, &raw_Ki, 0.01, 9990, copy_and_scalePID_i_E2);
  740. MENU_ITEM_EDIT_CALLBACK(float52, MSG_PID_D MSG_E2, &raw_Kd, 1, 9990, copy_and_scalePID_d_E2);
  741. #ifdef PID_ADD_EXTRUSION_RATE
  742. MENU_ITEM_EDIT(float3, MSG_PID_C MSG_E2, &PID_PARAM(Kc,1), 1, 9990);
  743. #endif//PID_ADD_EXTRUSION_RATE
  744. #if EXTRUDERS > 2
  745. // set up temp variables - undo the default scaling
  746. raw_Ki = unscalePID_i(PID_PARAM(Ki,2));
  747. raw_Kd = unscalePID_d(PID_PARAM(Kd,2));
  748. MENU_ITEM_EDIT(float52, MSG_PID_P MSG_E3, &PID_PARAM(Kp,2), 1, 9990);
  749. // i is typically a small value so allows values below 1
  750. MENU_ITEM_EDIT_CALLBACK(float52, MSG_PID_I MSG_E3, &raw_Ki, 0.01, 9990, copy_and_scalePID_i_E3);
  751. MENU_ITEM_EDIT_CALLBACK(float52, MSG_PID_D MSG_E3, &raw_Kd, 1, 9990, copy_and_scalePID_d_E3);
  752. #ifdef PID_ADD_EXTRUSION_RATE
  753. MENU_ITEM_EDIT(float3, MSG_PID_C MSG_E3, &PID_PARAM(Kc,2), 1, 9990);
  754. #endif//PID_ADD_EXTRUSION_RATE
  755. #if EXTRUDERS > 3
  756. // set up temp variables - undo the default scaling
  757. raw_Ki = unscalePID_i(PID_PARAM(Ki,3));
  758. raw_Kd = unscalePID_d(PID_PARAM(Kd,3));
  759. MENU_ITEM_EDIT(float52, MSG_PID_P MSG_E4, &PID_PARAM(Kp,3), 1, 9990);
  760. // i is typically a small value so allows values below 1
  761. MENU_ITEM_EDIT_CALLBACK(float52, MSG_PID_I MSG_E4, &raw_Ki, 0.01, 9990, copy_and_scalePID_i_E4);
  762. MENU_ITEM_EDIT_CALLBACK(float52, MSG_PID_D MSG_E4, &raw_Kd, 1, 9990, copy_and_scalePID_d_E4);
  763. #ifdef PID_ADD_EXTRUSION_RATE
  764. MENU_ITEM_EDIT(float3, MSG_PID_C MSG_E4, &PID_PARAM(Kc,3), 1, 9990);
  765. #endif//PID_ADD_EXTRUSION_RATE
  766. #endif//EXTRUDERS > 3
  767. #endif//EXTRUDERS > 2
  768. #endif//EXTRUDERS > 1
  769. #endif //PID_PARAMS_PER_EXTRUDER
  770. #endif//PIDTEMP
  771. MENU_ITEM(submenu, MSG_PREHEAT_PLA_SETTINGS, lcd_control_temperature_preheat_pla_settings_menu);
  772. MENU_ITEM(submenu, MSG_PREHEAT_ABS_SETTINGS, lcd_control_temperature_preheat_abs_settings_menu);
  773. END_MENU();
  774. }
  775. static void lcd_control_temperature_preheat_pla_settings_menu() {
  776. START_MENU();
  777. MENU_ITEM(back, MSG_TEMPERATURE, lcd_control_temperature_menu);
  778. MENU_ITEM_EDIT(int3, MSG_FAN_SPEED, &plaPreheatFanSpeed, 0, 255);
  779. #if TEMP_SENSOR_0 != 0
  780. MENU_ITEM_EDIT(int3, MSG_NOZZLE, &plaPreheatHotendTemp, 0, HEATER_0_MAXTEMP - 15);
  781. #endif
  782. #if TEMP_SENSOR_BED != 0
  783. MENU_ITEM_EDIT(int3, MSG_BED, &plaPreheatHPBTemp, 0, BED_MAXTEMP - 15);
  784. #endif
  785. #ifdef EEPROM_SETTINGS
  786. MENU_ITEM(function, MSG_STORE_EPROM, Config_StoreSettings);
  787. #endif
  788. END_MENU();
  789. }
  790. static void lcd_control_temperature_preheat_abs_settings_menu() {
  791. START_MENU();
  792. MENU_ITEM(back, MSG_TEMPERATURE, lcd_control_temperature_menu);
  793. MENU_ITEM_EDIT(int3, MSG_FAN_SPEED, &absPreheatFanSpeed, 0, 255);
  794. #if TEMP_SENSOR_0 != 0
  795. MENU_ITEM_EDIT(int3, MSG_NOZZLE, &absPreheatHotendTemp, 0, HEATER_0_MAXTEMP - 15);
  796. #endif
  797. #if TEMP_SENSOR_BED != 0
  798. MENU_ITEM_EDIT(int3, MSG_BED, &absPreheatHPBTemp, 0, BED_MAXTEMP - 15);
  799. #endif
  800. #ifdef EEPROM_SETTINGS
  801. MENU_ITEM(function, MSG_STORE_EPROM, Config_StoreSettings);
  802. #endif
  803. END_MENU();
  804. }
  805. static void lcd_control_motion_menu() {
  806. START_MENU();
  807. MENU_ITEM(back, MSG_CONTROL, lcd_control_menu);
  808. #ifdef ENABLE_AUTO_BED_LEVELING
  809. MENU_ITEM_EDIT(float32, MSG_ZPROBE_ZOFFSET, &zprobe_zoffset, Z_PROBE_OFFSET_RANGE_MIN, Z_PROBE_OFFSET_RANGE_MAX);
  810. #endif
  811. MENU_ITEM_EDIT(float5, MSG_ACC, &acceleration, 10, 99000);
  812. MENU_ITEM_EDIT(float3, MSG_VXY_JERK, &max_xy_jerk, 1, 990);
  813. MENU_ITEM_EDIT(float52, MSG_VZ_JERK, &max_z_jerk, 0.1, 990);
  814. MENU_ITEM_EDIT(float3, MSG_VE_JERK, &max_e_jerk, 1, 990);
  815. MENU_ITEM_EDIT(float3, MSG_VMAX MSG_X, &max_feedrate[X_AXIS], 1, 999);
  816. MENU_ITEM_EDIT(float3, MSG_VMAX MSG_Y, &max_feedrate[Y_AXIS], 1, 999);
  817. MENU_ITEM_EDIT(float3, MSG_VMAX MSG_Z, &max_feedrate[Z_AXIS], 1, 999);
  818. MENU_ITEM_EDIT(float3, MSG_VMAX MSG_E, &max_feedrate[E_AXIS], 1, 999);
  819. MENU_ITEM_EDIT(float3, MSG_VMIN, &minimumfeedrate, 0, 999);
  820. MENU_ITEM_EDIT(float3, MSG_VTRAV_MIN, &mintravelfeedrate, 0, 999);
  821. MENU_ITEM_EDIT_CALLBACK(long5, MSG_AMAX MSG_X, &max_acceleration_units_per_sq_second[X_AXIS], 100, 99000, reset_acceleration_rates);
  822. MENU_ITEM_EDIT_CALLBACK(long5, MSG_AMAX MSG_Y, &max_acceleration_units_per_sq_second[Y_AXIS], 100, 99000, reset_acceleration_rates);
  823. MENU_ITEM_EDIT_CALLBACK(long5, MSG_AMAX MSG_Z, &max_acceleration_units_per_sq_second[Z_AXIS], 10, 99000, reset_acceleration_rates);
  824. MENU_ITEM_EDIT_CALLBACK(long5, MSG_AMAX MSG_E, &max_acceleration_units_per_sq_second[E_AXIS], 100, 99000, reset_acceleration_rates);
  825. MENU_ITEM_EDIT(float5, MSG_A_RETRACT, &retract_acceleration, 100, 99000);
  826. MENU_ITEM_EDIT(float5, MSG_A_TRAVEL, &travel_acceleration, 100, 99000);
  827. MENU_ITEM_EDIT(float52, MSG_XSTEPS, &axis_steps_per_unit[X_AXIS], 5, 9999);
  828. MENU_ITEM_EDIT(float52, MSG_YSTEPS, &axis_steps_per_unit[Y_AXIS], 5, 9999);
  829. MENU_ITEM_EDIT(float51, MSG_ZSTEPS, &axis_steps_per_unit[Z_AXIS], 5, 9999);
  830. MENU_ITEM_EDIT(float51, MSG_ESTEPS, &axis_steps_per_unit[E_AXIS], 5, 9999);
  831. #ifdef ABORT_ON_ENDSTOP_HIT_FEATURE_ENABLED
  832. MENU_ITEM_EDIT(bool, MSG_ENDSTOP_ABORT, &abort_on_endstop_hit);
  833. #endif
  834. #ifdef SCARA
  835. MENU_ITEM_EDIT(float74, MSG_XSCALE, &axis_scaling[X_AXIS],0.5,2);
  836. MENU_ITEM_EDIT(float74, MSG_YSCALE, &axis_scaling[Y_AXIS],0.5,2);
  837. #endif
  838. END_MENU();
  839. }
  840. static void lcd_control_volumetric_menu() {
  841. START_MENU();
  842. MENU_ITEM(back, MSG_CONTROL, lcd_control_menu);
  843. MENU_ITEM_EDIT_CALLBACK(bool, MSG_VOLUMETRIC_ENABLED, &volumetric_enabled, calculate_volumetric_multipliers);
  844. if (volumetric_enabled) {
  845. MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(float43, MSG_FILAMENT_SIZE_EXTRUDER_0, &filament_size[0], 1.5, 3.25, calculate_volumetric_multipliers);
  846. #if EXTRUDERS > 1
  847. MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(float43, MSG_FILAMENT_SIZE_EXTRUDER_1, &filament_size[1], 1.5, 3.25, calculate_volumetric_multipliers);
  848. #if EXTRUDERS > 2
  849. MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(float43, MSG_FILAMENT_SIZE_EXTRUDER_2, &filament_size[2], 1.5, 3.25, calculate_volumetric_multipliers);
  850. #if EXTRUDERS > 3
  851. MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(float43, MSG_FILAMENT_SIZE_EXTRUDER_3, &filament_size[3], 1.5, 3.25, calculate_volumetric_multipliers);
  852. #endif //EXTRUDERS > 3
  853. #endif //EXTRUDERS > 2
  854. #endif //EXTRUDERS > 1
  855. }
  856. END_MENU();
  857. }
  858. #ifdef HAS_LCD_CONTRAST
  859. static void lcd_set_contrast() {
  860. if (encoderPosition != 0) {
  861. lcd_contrast -= encoderPosition;
  862. lcd_contrast &= 0x3F;
  863. encoderPosition = 0;
  864. lcdDrawUpdate = 1;
  865. u8g.setContrast(lcd_contrast);
  866. }
  867. if (lcdDrawUpdate) lcd_implementation_drawedit(PSTR(MSG_CONTRAST), itostr2(lcd_contrast));
  868. if (LCD_CLICKED) lcd_goto_menu(lcd_control_menu);
  869. }
  870. #endif // HAS_LCD_CONTRAST
  871. #ifdef FWRETRACT
  872. static void lcd_control_retract_menu() {
  873. START_MENU();
  874. MENU_ITEM(back, MSG_CONTROL, lcd_control_menu);
  875. MENU_ITEM_EDIT(bool, MSG_AUTORETRACT, &autoretract_enabled);
  876. MENU_ITEM_EDIT(float52, MSG_CONTROL_RETRACT, &retract_length, 0, 100);
  877. #if EXTRUDERS > 1
  878. MENU_ITEM_EDIT(float52, MSG_CONTROL_RETRACT_SWAP, &retract_length_swap, 0, 100);
  879. #endif
  880. MENU_ITEM_EDIT(float3, MSG_CONTROL_RETRACTF, &retract_feedrate, 1, 999);
  881. MENU_ITEM_EDIT(float52, MSG_CONTROL_RETRACT_ZLIFT, &retract_zlift, 0, 999);
  882. MENU_ITEM_EDIT(float52, MSG_CONTROL_RETRACT_RECOVER, &retract_recover_length, 0, 100);
  883. #if EXTRUDERS > 1
  884. MENU_ITEM_EDIT(float52, MSG_CONTROL_RETRACT_RECOVER_SWAP, &retract_recover_length_swap, 0, 100);
  885. #endif
  886. MENU_ITEM_EDIT(float3, MSG_CONTROL_RETRACT_RECOVERF, &retract_recover_feedrate, 1, 999);
  887. END_MENU();
  888. }
  889. #endif // FWRETRACT
  890. #if SDCARDDETECT == -1
  891. static void lcd_sd_refresh() {
  892. card.initsd();
  893. currentMenuViewOffset = 0;
  894. }
  895. #endif
  896. static void lcd_sd_updir() {
  897. card.updir();
  898. currentMenuViewOffset = 0;
  899. }
  900. void lcd_sdcard_menu() {
  901. if (lcdDrawUpdate == 0 && LCD_CLICKED == 0) return; // nothing to do (so don't thrash the SD card)
  902. uint16_t fileCnt = card.getnrfilenames();
  903. START_MENU();
  904. MENU_ITEM(back, MSG_MAIN, lcd_main_menu);
  905. card.getWorkDirName();
  906. if (card.filename[0] == '/') {
  907. #if SDCARDDETECT == -1
  908. MENU_ITEM(function, LCD_STR_REFRESH MSG_REFRESH, lcd_sd_refresh);
  909. #endif
  910. }
  911. else {
  912. MENU_ITEM(function, LCD_STR_FOLDER "..", lcd_sd_updir);
  913. }
  914. for (uint16_t i = 0; i < fileCnt; i++) {
  915. if (_menuItemNr == _lineNr) {
  916. card.getfilename(
  917. #ifdef SDCARD_RATHERRECENTFIRST
  918. fileCnt-1 -
  919. #endif
  920. i
  921. );
  922. if (card.filenameIsDir)
  923. MENU_ITEM(sddirectory, MSG_CARD_MENU, card.filename, card.longFilename);
  924. else
  925. MENU_ITEM(sdfile, MSG_CARD_MENU, card.filename, card.longFilename);
  926. }
  927. else {
  928. MENU_ITEM_DUMMY();
  929. }
  930. }
  931. END_MENU();
  932. }
  933. #define menu_edit_type(_type, _name, _strFunc, scale) \
  934. bool _menu_edit_ ## _name () { \
  935. bool isClicked = LCD_CLICKED; \
  936. if ((int32_t)encoderPosition < 0) encoderPosition = 0; \
  937. if ((int32_t)encoderPosition > maxEditValue) encoderPosition = maxEditValue; \
  938. if (lcdDrawUpdate) \
  939. lcd_implementation_drawedit(editLabel, _strFunc(((_type)((int32_t)encoderPosition + minEditValue)) / scale)); \
  940. if (isClicked) { \
  941. *((_type*)editValue) = ((_type)((int32_t)encoderPosition + minEditValue)) / scale; \
  942. lcd_goto_menu(prevMenu, prevEncoderPosition); \
  943. } \
  944. return isClicked; \
  945. } \
  946. void menu_edit_ ## _name () { _menu_edit_ ## _name(); } \
  947. void menu_edit_callback_ ## _name () { if (_menu_edit_ ## _name ()) (*callbackFunc)(); } \
  948. static void _menu_action_setting_edit_ ## _name (const char* pstr, _type* ptr, _type minValue, _type maxValue) { \
  949. prevMenu = currentMenu; \
  950. prevEncoderPosition = encoderPosition; \
  951. \
  952. lcdDrawUpdate = 2; \
  953. currentMenu = menu_edit_ ## _name; \
  954. \
  955. editLabel = pstr; \
  956. editValue = ptr; \
  957. minEditValue = minValue * scale; \
  958. maxEditValue = maxValue * scale - minEditValue; \
  959. encoderPosition = (*ptr) * scale - minEditValue; \
  960. } \
  961. static void menu_action_setting_edit_ ## _name (const char* pstr, _type* ptr, _type minValue, _type maxValue) { \
  962. _menu_action_setting_edit_ ## _name(pstr, ptr, minValue, maxValue); \
  963. currentMenu = menu_edit_ ## _name; \
  964. }\
  965. static void menu_action_setting_edit_callback_ ## _name (const char* pstr, _type* ptr, _type minValue, _type maxValue, menuFunc_t callback) { \
  966. _menu_action_setting_edit_ ## _name(pstr, ptr, minValue, maxValue); \
  967. currentMenu = menu_edit_callback_ ## _name; \
  968. callbackFunc = callback; \
  969. }
  970. menu_edit_type(int, int3, itostr3, 1)
  971. menu_edit_type(float, float3, ftostr3, 1)
  972. menu_edit_type(float, float32, ftostr32, 100)
  973. menu_edit_type(float, float43, ftostr43, 1000)
  974. menu_edit_type(float, float5, ftostr5, 0.01)
  975. menu_edit_type(float, float51, ftostr51, 10)
  976. menu_edit_type(float, float52, ftostr52, 100)
  977. menu_edit_type(unsigned long, long5, ftostr5, 0.01)
  978. #ifdef REPRAPWORLD_KEYPAD
  979. static void reprapworld_keypad_move_z_up() {
  980. encoderPosition = 1;
  981. move_menu_scale = REPRAPWORLD_KEYPAD_MOVE_STEP;
  982. lcd_move_z();
  983. }
  984. static void reprapworld_keypad_move_z_down() {
  985. encoderPosition = -1;
  986. move_menu_scale = REPRAPWORLD_KEYPAD_MOVE_STEP;
  987. lcd_move_z();
  988. }
  989. static void reprapworld_keypad_move_x_left() {
  990. encoderPosition = -1;
  991. move_menu_scale = REPRAPWORLD_KEYPAD_MOVE_STEP;
  992. lcd_move_x();
  993. }
  994. static void reprapworld_keypad_move_x_right() {
  995. encoderPosition = 1;
  996. move_menu_scale = REPRAPWORLD_KEYPAD_MOVE_STEP;
  997. lcd_move_x();
  998. }
  999. static void reprapworld_keypad_move_y_down() {
  1000. encoderPosition = 1;
  1001. move_menu_scale = REPRAPWORLD_KEYPAD_MOVE_STEP;
  1002. lcd_move_y();
  1003. }
  1004. static void reprapworld_keypad_move_y_up() {
  1005. encoderPosition = -1;
  1006. move_menu_scale = REPRAPWORLD_KEYPAD_MOVE_STEP;
  1007. lcd_move_y();
  1008. }
  1009. static void reprapworld_keypad_move_home() {
  1010. enqueuecommands_P((PSTR("G28"))); // move all axis home
  1011. }
  1012. #endif //REPRAPWORLD_KEYPAD
  1013. /** End of menus **/
  1014. void lcd_quick_feedback() {
  1015. lcdDrawUpdate = 2;
  1016. next_button_update_ms = millis() + 500;
  1017. #ifdef LCD_USE_I2C_BUZZER
  1018. #ifndef LCD_FEEDBACK_FREQUENCY_HZ
  1019. #define LCD_FEEDBACK_FREQUENCY_HZ 100
  1020. #endif
  1021. #ifndef LCD_FEEDBACK_FREQUENCY_DURATION_MS
  1022. #define LCD_FEEDBACK_FREQUENCY_DURATION_MS (1000/6)
  1023. #endif
  1024. lcd_buzz(LCD_FEEDBACK_FREQUENCY_DURATION_MS, LCD_FEEDBACK_FREQUENCY_HZ);
  1025. #elif defined(BEEPER) && BEEPER > -1
  1026. SET_OUTPUT(BEEPER);
  1027. #ifndef LCD_FEEDBACK_FREQUENCY_HZ
  1028. #define LCD_FEEDBACK_FREQUENCY_HZ 5000
  1029. #endif
  1030. #ifndef LCD_FEEDBACK_FREQUENCY_DURATION_MS
  1031. #define LCD_FEEDBACK_FREQUENCY_DURATION_MS 2
  1032. #endif
  1033. const uint16_t delay = 1000000 / LCD_FEEDBACK_FREQUENCY_HZ / 2;
  1034. uint16_t i = LCD_FEEDBACK_FREQUENCY_DURATION_MS * LCD_FEEDBACK_FREQUENCY_HZ / 1000;
  1035. while (i--) {
  1036. WRITE(BEEPER,HIGH);
  1037. delayMicroseconds(delay);
  1038. WRITE(BEEPER,LOW);
  1039. delayMicroseconds(delay);
  1040. }
  1041. const uint16_t j = max(10000 - LCD_FEEDBACK_FREQUENCY_DURATION_MS * 1000, 0);
  1042. if (j) delayMicroseconds(j);
  1043. #endif
  1044. }
  1045. /** Menu action functions **/
  1046. static void menu_action_back(menuFunc_t data) { lcd_goto_menu(data); }
  1047. static void menu_action_submenu(menuFunc_t data) { lcd_goto_menu(data); }
  1048. static void menu_action_gcode(const char* pgcode) { enqueuecommands_P(pgcode); }
  1049. static void menu_action_function(menuFunc_t data) { (*data)(); }
  1050. static void menu_action_sdfile(const char* filename, char* longFilename) {
  1051. char cmd[30];
  1052. char* c;
  1053. sprintf_P(cmd, PSTR("M23 %s"), filename);
  1054. for(c = &cmd[4]; *c; c++) *c = tolower(*c);
  1055. enqueuecommand(cmd);
  1056. enqueuecommands_P(PSTR("M24"));
  1057. lcd_return_to_status();
  1058. }
  1059. static void menu_action_sddirectory(const char* filename, char* longFilename) {
  1060. card.chdir(filename);
  1061. encoderPosition = 0;
  1062. }
  1063. static void menu_action_setting_edit_bool(const char* pstr, bool* ptr) { *ptr = !(*ptr); }
  1064. static void menu_action_setting_edit_callback_bool(const char* pstr, bool* ptr, menuFunc_t callback) {
  1065. menu_action_setting_edit_bool(pstr, ptr);
  1066. (*callback)();
  1067. }
  1068. #endif //ULTIPANEL
  1069. /** LCD API **/
  1070. void lcd_init() {
  1071. lcd_implementation_init();
  1072. #ifdef NEWPANEL
  1073. SET_INPUT(BTN_EN1);
  1074. SET_INPUT(BTN_EN2);
  1075. WRITE(BTN_EN1,HIGH);
  1076. WRITE(BTN_EN2,HIGH);
  1077. #if BTN_ENC > 0
  1078. SET_INPUT(BTN_ENC);
  1079. WRITE(BTN_ENC,HIGH);
  1080. #endif
  1081. #ifdef REPRAPWORLD_KEYPAD
  1082. pinMode(SHIFT_CLK,OUTPUT);
  1083. pinMode(SHIFT_LD,OUTPUT);
  1084. pinMode(SHIFT_OUT,INPUT);
  1085. WRITE(SHIFT_OUT,HIGH);
  1086. WRITE(SHIFT_LD,HIGH);
  1087. #endif
  1088. #else // Not NEWPANEL
  1089. #ifdef SR_LCD_2W_NL // Non latching 2 wire shift register
  1090. pinMode (SR_DATA_PIN, OUTPUT);
  1091. pinMode (SR_CLK_PIN, OUTPUT);
  1092. #elif defined(SHIFT_CLK)
  1093. pinMode(SHIFT_CLK,OUTPUT);
  1094. pinMode(SHIFT_LD,OUTPUT);
  1095. pinMode(SHIFT_EN,OUTPUT);
  1096. pinMode(SHIFT_OUT,INPUT);
  1097. WRITE(SHIFT_OUT,HIGH);
  1098. WRITE(SHIFT_LD,HIGH);
  1099. WRITE(SHIFT_EN,LOW);
  1100. #endif // SR_LCD_2W_NL
  1101. #endif//!NEWPANEL
  1102. #if defined(SDSUPPORT) && defined(SDCARDDETECT) && (SDCARDDETECT > 0)
  1103. pinMode(SDCARDDETECT, INPUT);
  1104. WRITE(SDCARDDETECT, HIGH);
  1105. lcd_oldcardstatus = IS_SD_INSERTED;
  1106. #endif //(SDCARDDETECT > 0)
  1107. #ifdef LCD_HAS_SLOW_BUTTONS
  1108. slow_buttons = 0;
  1109. #endif
  1110. lcd_buttons_update();
  1111. #ifdef ULTIPANEL
  1112. encoderDiff = 0;
  1113. #endif
  1114. }
  1115. int lcd_strlen(char *s) {
  1116. int i = 0, j = 0;
  1117. while (s[i]) {
  1118. if ((s[i] & 0xc0) != 0x80) j++;
  1119. i++;
  1120. }
  1121. return j;
  1122. }
  1123. int lcd_strlen_P(const char *s) {
  1124. int j = 0;
  1125. while (pgm_read_byte(s)) {
  1126. if ((pgm_read_byte(s) & 0xc0) != 0x80) j++;
  1127. s++;
  1128. }
  1129. return j;
  1130. }
  1131. void lcd_update() {
  1132. #ifdef ULTIPANEL
  1133. static millis_t return_to_status_ms = 0;
  1134. #endif
  1135. #ifdef LCD_HAS_SLOW_BUTTONS
  1136. slow_buttons = lcd_implementation_read_slow_buttons(); // buttons which take too long to read in interrupt context
  1137. #endif
  1138. lcd_buttons_update();
  1139. #if (SDCARDDETECT > 0)
  1140. if (IS_SD_INSERTED != lcd_oldcardstatus && lcd_detected()) {
  1141. lcdDrawUpdate = 2;
  1142. lcd_oldcardstatus = IS_SD_INSERTED;
  1143. lcd_implementation_init( // to maybe revive the LCD if static electricity killed it.
  1144. #ifdef LCD_PROGRESS_BAR
  1145. currentMenu == lcd_status_screen
  1146. #endif
  1147. );
  1148. if (lcd_oldcardstatus) {
  1149. card.initsd();
  1150. LCD_MESSAGEPGM(MSG_SD_INSERTED);
  1151. }
  1152. else {
  1153. card.release();
  1154. LCD_MESSAGEPGM(MSG_SD_REMOVED);
  1155. }
  1156. }
  1157. #endif//CARDINSERTED
  1158. millis_t ms = millis();
  1159. if (ms > next_lcd_update_ms) {
  1160. #ifdef ULTIPANEL
  1161. #ifdef REPRAPWORLD_KEYPAD
  1162. if (REPRAPWORLD_KEYPAD_MOVE_Z_UP) reprapworld_keypad_move_z_up();
  1163. if (REPRAPWORLD_KEYPAD_MOVE_Z_DOWN) reprapworld_keypad_move_z_down();
  1164. if (REPRAPWORLD_KEYPAD_MOVE_X_LEFT) reprapworld_keypad_move_x_left();
  1165. if (REPRAPWORLD_KEYPAD_MOVE_X_RIGHT) reprapworld_keypad_move_x_right();
  1166. if (REPRAPWORLD_KEYPAD_MOVE_Y_DOWN) reprapworld_keypad_move_y_down();
  1167. if (REPRAPWORLD_KEYPAD_MOVE_Y_UP) reprapworld_keypad_move_y_up();
  1168. if (REPRAPWORLD_KEYPAD_MOVE_HOME) reprapworld_keypad_move_home();
  1169. #endif
  1170. bool encoderPastThreshold = (abs(encoderDiff) >= ENCODER_PULSES_PER_STEP);
  1171. if (encoderPastThreshold || LCD_CLICKED) {
  1172. if (encoderPastThreshold) {
  1173. int32_t encoderMultiplier = 1;
  1174. #ifdef ENCODER_RATE_MULTIPLIER
  1175. if (encoderRateMultiplierEnabled) {
  1176. int32_t encoderMovementSteps = abs(encoderDiff) / ENCODER_PULSES_PER_STEP;
  1177. if (lastEncoderMovementMillis != 0) {
  1178. // Note that the rate is always calculated between to passes through the
  1179. // loop and that the abs of the encoderDiff value is tracked.
  1180. float encoderStepRate = (float)(encoderMovementSteps) / ((float)(ms - lastEncoderMovementMillis)) * 1000.0;
  1181. if (encoderStepRate >= ENCODER_100X_STEPS_PER_SEC) encoderMultiplier = 100;
  1182. else if (encoderStepRate >= ENCODER_10X_STEPS_PER_SEC) encoderMultiplier = 10;
  1183. #ifdef ENCODER_RATE_MULTIPLIER_DEBUG
  1184. SERIAL_ECHO_START;
  1185. SERIAL_ECHO("Enc Step Rate: ");
  1186. SERIAL_ECHO(encoderStepRate);
  1187. SERIAL_ECHO(" Multiplier: ");
  1188. SERIAL_ECHO(encoderMultiplier);
  1189. SERIAL_ECHO(" ENCODER_10X_STEPS_PER_SEC: ");
  1190. SERIAL_ECHO(ENCODER_10X_STEPS_PER_SEC);
  1191. SERIAL_ECHO(" ENCODER_100X_STEPS_PER_SEC: ");
  1192. SERIAL_ECHOLN(ENCODER_100X_STEPS_PER_SEC);
  1193. #endif //ENCODER_RATE_MULTIPLIER_DEBUG
  1194. }
  1195. lastEncoderMovementMillis = ms;
  1196. } // encoderRateMultiplierEnabled
  1197. #endif //ENCODER_RATE_MULTIPLIER
  1198. encoderPosition += (encoderDiff * encoderMultiplier) / ENCODER_PULSES_PER_STEP;
  1199. encoderDiff = 0;
  1200. }
  1201. return_to_status_ms = ms + LCD_TIMEOUT_TO_STATUS;
  1202. lcdDrawUpdate = 1;
  1203. }
  1204. #endif //ULTIPANEL
  1205. if (currentMenu == lcd_status_screen) {
  1206. if (!lcd_status_update_delay) {
  1207. lcdDrawUpdate = 1;
  1208. lcd_status_update_delay = 10; /* redraw the main screen every second. This is easier then trying keep track of all things that change on the screen */
  1209. }
  1210. else {
  1211. lcd_status_update_delay--;
  1212. }
  1213. }
  1214. #ifdef DOGLCD // Changes due to different driver architecture of the DOGM display
  1215. if (lcdDrawUpdate) {
  1216. blink++; // Variable for fan animation and alive dot
  1217. u8g.firstPage();
  1218. do {
  1219. lcd_setFont(FONT_MENU);
  1220. u8g.setPrintPos(125, 0);
  1221. if (blink % 2) u8g.setColorIndex(1); else u8g.setColorIndex(0); // Set color for the alive dot
  1222. u8g.drawPixel(127, 63); // draw alive dot
  1223. u8g.setColorIndex(1); // black on white
  1224. (*currentMenu)();
  1225. } while( u8g.nextPage() );
  1226. }
  1227. #else
  1228. (*currentMenu)();
  1229. #endif
  1230. #ifdef LCD_HAS_STATUS_INDICATORS
  1231. lcd_implementation_update_indicators();
  1232. #endif
  1233. #ifdef ULTIPANEL
  1234. // Return to Status Screen after a timeout
  1235. if (currentMenu != lcd_status_screen &&
  1236. #ifdef MANUAL_BED_LEVELING
  1237. currentMenu != _lcd_level_bed &&
  1238. currentMenu != _lcd_level_bed_homing &&
  1239. #endif
  1240. millis() > return_to_status_ms
  1241. ) {
  1242. lcd_return_to_status();
  1243. lcdDrawUpdate = 2;
  1244. }
  1245. #endif // ULTIPANEL
  1246. if (lcdDrawUpdate == 2) lcd_implementation_clear();
  1247. if (lcdDrawUpdate) lcdDrawUpdate--;
  1248. next_lcd_update_ms = millis() + LCD_UPDATE_INTERVAL;
  1249. }
  1250. }
  1251. void lcd_ignore_click(bool b) {
  1252. ignore_click = b;
  1253. wait_for_unclick = false;
  1254. }
  1255. void lcd_finishstatus(bool persist=false) {
  1256. #ifdef LCD_PROGRESS_BAR
  1257. progressBarTick = millis();
  1258. #if PROGRESS_MSG_EXPIRE > 0
  1259. expireStatusMillis = persist ? 0 : progressBarTick + PROGRESS_MSG_EXPIRE;
  1260. #endif
  1261. #endif
  1262. lcdDrawUpdate = 2;
  1263. #ifdef FILAMENT_LCD_DISPLAY
  1264. previous_lcd_status_ms = millis(); //get status message to show up for a while
  1265. #endif
  1266. }
  1267. #if defined(LCD_PROGRESS_BAR) && PROGRESS_MSG_EXPIRE > 0
  1268. void dontExpireStatus() { expireStatusMillis = 0; }
  1269. #endif
  1270. void set_utf_strlen(char *s, uint8_t n) {
  1271. uint8_t i = 0, j = 0;
  1272. while (s[i] && (j < n)) {
  1273. if ((s[i] & 0xc0u) != 0x80u) j++;
  1274. i++;
  1275. }
  1276. while (j++ < n) s[i++] = ' ';
  1277. s[i] = 0;
  1278. }
  1279. void lcd_setstatus(const char* message, bool persist) {
  1280. if (lcd_status_message_level > 0) return;
  1281. strncpy(lcd_status_message, message, 3*LCD_WIDTH);
  1282. set_utf_strlen(lcd_status_message, LCD_WIDTH);
  1283. lcd_finishstatus(persist);
  1284. }
  1285. void lcd_setstatuspgm(const char* message, uint8_t level) {
  1286. if (level >= lcd_status_message_level) {
  1287. strncpy_P(lcd_status_message, message, 3*LCD_WIDTH);
  1288. set_utf_strlen(lcd_status_message, LCD_WIDTH);
  1289. lcd_status_message_level = level;
  1290. lcd_finishstatus(level > 0);
  1291. }
  1292. }
  1293. void lcd_setalertstatuspgm(const char* message) {
  1294. lcd_setstatuspgm(message, 1);
  1295. #ifdef ULTIPANEL
  1296. lcd_return_to_status();
  1297. #endif
  1298. }
  1299. void lcd_reset_alert_level() { lcd_status_message_level = 0; }
  1300. #ifdef HAS_LCD_CONTRAST
  1301. void lcd_setcontrast(uint8_t value) {
  1302. lcd_contrast = value & 0x3F;
  1303. u8g.setContrast(lcd_contrast);
  1304. }
  1305. #endif
  1306. #ifdef ULTIPANEL
  1307. ////////////////////////
  1308. // Setup Rotary Encoder Bit Values (for two pin encoders to indicate movement)
  1309. // These values are independent of which pins are used for EN_A and EN_B indications
  1310. // The rotary encoder part is also independent to the chipset used for the LCD
  1311. #if defined(EN_A) && defined(EN_B)
  1312. #define encrot0 0
  1313. #define encrot1 2
  1314. #define encrot2 3
  1315. #define encrot3 1
  1316. #endif
  1317. /* Warning: This function is called from interrupt context */
  1318. void lcd_buttons_update() {
  1319. #ifdef NEWPANEL
  1320. uint8_t newbutton = 0;
  1321. if (READ(BTN_EN1) == 0) newbutton |= EN_A;
  1322. if (READ(BTN_EN2) == 0) newbutton |= EN_B;
  1323. #if BTN_ENC > 0
  1324. if (millis() > next_button_update_ms && READ(BTN_ENC) == 0) newbutton |= EN_C;
  1325. #endif
  1326. buttons = newbutton;
  1327. #ifdef LCD_HAS_SLOW_BUTTONS
  1328. buttons |= slow_buttons;
  1329. #endif
  1330. #ifdef REPRAPWORLD_KEYPAD
  1331. // for the reprapworld_keypad
  1332. uint8_t newbutton_reprapworld_keypad=0;
  1333. WRITE(SHIFT_LD, LOW);
  1334. WRITE(SHIFT_LD, HIGH);
  1335. for(int8_t i = 0; i < 8; i++) {
  1336. newbutton_reprapworld_keypad >>= 1;
  1337. if (READ(SHIFT_OUT)) newbutton_reprapworld_keypad |= BIT(7);
  1338. WRITE(SHIFT_CLK, HIGH);
  1339. WRITE(SHIFT_CLK, LOW);
  1340. }
  1341. buttons_reprapworld_keypad=~newbutton_reprapworld_keypad; //invert it, because a pressed switch produces a logical 0
  1342. #endif
  1343. #else //read it from the shift register
  1344. uint8_t newbutton = 0;
  1345. WRITE(SHIFT_LD, LOW);
  1346. WRITE(SHIFT_LD, HIGH);
  1347. unsigned char tmp_buttons = 0;
  1348. for(int8_t i=0; i<8; i++) {
  1349. newbutton >>= 1;
  1350. if (READ(SHIFT_OUT)) newbutton |= BIT(7);
  1351. WRITE(SHIFT_CLK, HIGH);
  1352. WRITE(SHIFT_CLK, LOW);
  1353. }
  1354. buttons = ~newbutton; //invert it, because a pressed switch produces a logical 0
  1355. #endif //!NEWPANEL
  1356. //manage encoder rotation
  1357. uint8_t enc=0;
  1358. if (buttons & EN_A) enc |= B01;
  1359. if (buttons & EN_B) enc |= B10;
  1360. if (enc != lastEncoderBits) {
  1361. switch(enc) {
  1362. case encrot0:
  1363. if (lastEncoderBits==encrot3) encoderDiff++;
  1364. else if (lastEncoderBits==encrot1) encoderDiff--;
  1365. break;
  1366. case encrot1:
  1367. if (lastEncoderBits==encrot0) encoderDiff++;
  1368. else if (lastEncoderBits==encrot2) encoderDiff--;
  1369. break;
  1370. case encrot2:
  1371. if (lastEncoderBits==encrot1) encoderDiff++;
  1372. else if (lastEncoderBits==encrot3) encoderDiff--;
  1373. break;
  1374. case encrot3:
  1375. if (lastEncoderBits==encrot2) encoderDiff++;
  1376. else if (lastEncoderBits==encrot0) encoderDiff--;
  1377. break;
  1378. }
  1379. }
  1380. lastEncoderBits = enc;
  1381. }
  1382. bool lcd_detected(void) {
  1383. #if (defined(LCD_I2C_TYPE_MCP23017) || defined(LCD_I2C_TYPE_MCP23008)) && defined(DETECT_DEVICE)
  1384. return lcd.LcdDetected() == 1;
  1385. #else
  1386. return true;
  1387. #endif
  1388. }
  1389. void lcd_buzz(long duration, uint16_t freq) {
  1390. #ifdef LCD_USE_I2C_BUZZER
  1391. lcd.buzz(duration,freq);
  1392. #endif
  1393. }
  1394. bool lcd_clicked() { return LCD_CLICKED; }
  1395. #endif //ULTIPANEL
  1396. /*********************************/
  1397. /** Number to string conversion **/
  1398. /*********************************/
  1399. char conv[8];
  1400. // Convert float to string with +123.4 format
  1401. char *ftostr3(const float &x) {
  1402. return itostr3((int)x);
  1403. }
  1404. // Convert int to string with 12 format
  1405. char *itostr2(const uint8_t &x) {
  1406. //sprintf(conv,"%5.1f",x);
  1407. int xx = x;
  1408. conv[0] = (xx / 10) % 10 + '0';
  1409. conv[1] = xx % 10 + '0';
  1410. conv[2] = 0;
  1411. return conv;
  1412. }
  1413. // Convert float to string with +123.4 format
  1414. char *ftostr31(const float &x) {
  1415. int xx = abs(x * 10);
  1416. conv[0] = (x >= 0) ? '+' : '-';
  1417. conv[1] = (xx / 1000) % 10 + '0';
  1418. conv[2] = (xx / 100) % 10 + '0';
  1419. conv[3] = (xx / 10) % 10 + '0';
  1420. conv[4] = '.';
  1421. conv[5] = xx % 10 + '0';
  1422. conv[6] = 0;
  1423. return conv;
  1424. }
  1425. // Convert float to string with 123.4 format, dropping sign
  1426. char *ftostr31ns(const float &x) {
  1427. int xx = abs(x * 10);
  1428. conv[0] = (xx / 1000) % 10 + '0';
  1429. conv[1] = (xx / 100) % 10 + '0';
  1430. conv[2] = (xx / 10) % 10 + '0';
  1431. conv[3] = '.';
  1432. conv[4] = xx % 10 + '0';
  1433. conv[5] = 0;
  1434. return conv;
  1435. }
  1436. // Convert float to string with 123.4 format
  1437. char *ftostr32(const float &x) {
  1438. long xx = abs(x * 100);
  1439. conv[0] = x >= 0 ? (xx / 10000) % 10 + '0' : '-';
  1440. conv[1] = (xx / 1000) % 10 + '0';
  1441. conv[2] = (xx / 100) % 10 + '0';
  1442. conv[3] = '.';
  1443. conv[4] = (xx / 10) % 10 + '0';
  1444. conv[5] = xx % 10 + '0';
  1445. conv[6] = 0;
  1446. return conv;
  1447. }
  1448. // Convert float to string with 1.234 format
  1449. char *ftostr43(const float &x)
  1450. {
  1451. long xx = x * 1000;
  1452. if (xx >= 0)
  1453. conv[0] = (xx / 1000) % 10 + '0';
  1454. else
  1455. conv[0] = '-';
  1456. xx = abs(xx);
  1457. conv[1] = '.';
  1458. conv[2] = (xx / 100) % 10 + '0';
  1459. conv[3] = (xx / 10) % 10 + '0';
  1460. conv[4] = (xx) % 10 + '0';
  1461. conv[5] = 0;
  1462. return conv;
  1463. }
  1464. // Convert float to string with 1.23 format
  1465. char *ftostr12ns(const float &x)
  1466. {
  1467. long xx=x*100;
  1468. xx=abs(xx);
  1469. conv[0]=(xx/100)%10+'0';
  1470. conv[1]='.';
  1471. conv[2]=(xx/10)%10+'0';
  1472. conv[3]=(xx)%10+'0';
  1473. conv[4]=0;
  1474. return conv;
  1475. }
  1476. // Convert float to space-padded string with -_23.4_ format
  1477. char *ftostr32sp(const float &x) {
  1478. long xx = abs(x * 100);
  1479. uint8_t dig;
  1480. if (x < 0) { // negative val = -_0
  1481. conv[0] = '-';
  1482. dig = (xx / 1000) % 10;
  1483. conv[1] = dig ? '0' + dig : ' ';
  1484. }
  1485. else { // positive val = __0
  1486. dig = (xx / 10000) % 10;
  1487. if (dig) {
  1488. conv[0] = '0' + dig;
  1489. conv[1] = '0' + (xx / 1000) % 10;
  1490. }
  1491. else {
  1492. conv[0] = ' ';
  1493. dig = (xx / 1000) % 10;
  1494. conv[1] = dig ? '0' + dig : ' ';
  1495. }
  1496. }
  1497. conv[2] = '0' + (xx / 100) % 10; // lsd always
  1498. dig = xx % 10;
  1499. if (dig) { // 2 decimal places
  1500. conv[5] = '0' + dig;
  1501. conv[4] = '0' + (xx / 10) % 10;
  1502. conv[3] = '.';
  1503. }
  1504. else { // 1 or 0 decimal place
  1505. dig = (xx / 10) % 10;
  1506. if (dig) {
  1507. conv[4] = '0' + dig;
  1508. conv[3] = '.';
  1509. }
  1510. else {
  1511. conv[3] = conv[4] = ' ';
  1512. }
  1513. conv[5] = ' ';
  1514. }
  1515. conv[6] = '\0';
  1516. return conv;
  1517. }
  1518. // Convert int to lj string with +123.0 format
  1519. char *itostr31(const int &x) {
  1520. conv[0] = x >= 0 ? '+' : '-';
  1521. int xx = abs(x);
  1522. conv[1] = (xx / 100) % 10 + '0';
  1523. conv[2] = (xx / 10) % 10 + '0';
  1524. conv[3] = xx % 10 + '0';
  1525. conv[4] = '.';
  1526. conv[5] = '0';
  1527. conv[6] = 0;
  1528. return conv;
  1529. }
  1530. // Convert int to rj string with 123 or -12 format
  1531. char *itostr3(const int &x) {
  1532. int xx = x;
  1533. if (xx < 0) {
  1534. conv[0] = '-';
  1535. xx = -xx;
  1536. }
  1537. else
  1538. conv[0] = xx >= 100 ? (xx / 100) % 10 + '0' : ' ';
  1539. conv[1] = xx >= 10 ? (xx / 10) % 10 + '0' : ' ';
  1540. conv[2] = xx % 10 + '0';
  1541. conv[3] = 0;
  1542. return conv;
  1543. }
  1544. // Convert int to lj string with 123 format
  1545. char *itostr3left(const int &xx) {
  1546. if (xx >= 100) {
  1547. conv[0] = (xx / 100) % 10 + '0';
  1548. conv[1] = (xx / 10) % 10 + '0';
  1549. conv[2] = xx % 10 + '0';
  1550. conv[3] = 0;
  1551. }
  1552. else if (xx >= 10) {
  1553. conv[0] = (xx / 10) % 10 + '0';
  1554. conv[1] = xx % 10 + '0';
  1555. conv[2] = 0;
  1556. }
  1557. else {
  1558. conv[0] = xx % 10 + '0';
  1559. conv[1] = 0;
  1560. }
  1561. return conv;
  1562. }
  1563. // Convert int to rj string with 1234 format
  1564. char *itostr4(const int &xx) {
  1565. conv[0] = xx >= 1000 ? (xx / 1000) % 10 + '0' : ' ';
  1566. conv[1] = xx >= 100 ? (xx / 100) % 10 + '0' : ' ';
  1567. conv[2] = xx >= 10 ? (xx / 10) % 10 + '0' : ' ';
  1568. conv[3] = xx % 10 + '0';
  1569. conv[4] = 0;
  1570. return conv;
  1571. }
  1572. // Convert float to rj string with 12345 format
  1573. char *ftostr5(const float &x) {
  1574. long xx = abs(x);
  1575. conv[0] = xx >= 10000 ? (xx / 10000) % 10 + '0' : ' ';
  1576. conv[1] = xx >= 1000 ? (xx / 1000) % 10 + '0' : ' ';
  1577. conv[2] = xx >= 100 ? (xx / 100) % 10 + '0' : ' ';
  1578. conv[3] = xx >= 10 ? (xx / 10) % 10 + '0' : ' ';
  1579. conv[4] = xx % 10 + '0';
  1580. conv[5] = 0;
  1581. return conv;
  1582. }
  1583. // Convert float to string with +1234.5 format
  1584. char *ftostr51(const float &x) {
  1585. long xx = abs(x * 10);
  1586. conv[0] = (x >= 0) ? '+' : '-';
  1587. conv[1] = (xx / 10000) % 10 + '0';
  1588. conv[2] = (xx / 1000) % 10 + '0';
  1589. conv[3] = (xx / 100) % 10 + '0';
  1590. conv[4] = (xx / 10) % 10 + '0';
  1591. conv[5] = '.';
  1592. conv[6] = xx % 10 + '0';
  1593. conv[7] = 0;
  1594. return conv;
  1595. }
  1596. // Convert float to string with +123.45 format
  1597. char *ftostr52(const float &x) {
  1598. conv[0] = (x >= 0) ? '+' : '-';
  1599. long xx = abs(x * 100);
  1600. conv[1] = (xx / 10000) % 10 + '0';
  1601. conv[2] = (xx / 1000) % 10 + '0';
  1602. conv[3] = (xx / 100) % 10 + '0';
  1603. conv[4] = '.';
  1604. conv[5] = (xx / 10) % 10 + '0';
  1605. conv[6] = xx % 10 + '0';
  1606. conv[7] = 0;
  1607. return conv;
  1608. }
  1609. #ifdef MANUAL_BED_LEVELING
  1610. static int _lcd_level_bed_position;
  1611. static void _lcd_level_bed() {
  1612. if (encoderPosition != 0) {
  1613. refresh_cmd_timeout();
  1614. current_position[Z_AXIS] += float((int)encoderPosition) * MBL_Z_STEP;
  1615. if (min_software_endstops && current_position[Z_AXIS] < Z_MIN_POS) current_position[Z_AXIS] = Z_MIN_POS;
  1616. if (max_software_endstops && current_position[Z_AXIS] > Z_MAX_POS) current_position[Z_AXIS] = Z_MAX_POS;
  1617. encoderPosition = 0;
  1618. line_to_current();
  1619. lcdDrawUpdate = 2;
  1620. }
  1621. if (lcdDrawUpdate) lcd_implementation_drawedit(PSTR("Z"), ftostr43(current_position[Z_AXIS]));
  1622. static bool debounce_click = false;
  1623. if (LCD_CLICKED) {
  1624. if (!debounce_click) {
  1625. debounce_click = true;
  1626. int ix = _lcd_level_bed_position % MESH_NUM_X_POINTS;
  1627. int iy = _lcd_level_bed_position / MESH_NUM_X_POINTS;
  1628. if (iy&1) { // Zig zag
  1629. ix = (MESH_NUM_X_POINTS - 1) - ix;
  1630. }
  1631. mbl.set_z(ix, iy, current_position[Z_AXIS]);
  1632. _lcd_level_bed_position++;
  1633. if (_lcd_level_bed_position == MESH_NUM_X_POINTS*MESH_NUM_Y_POINTS) {
  1634. current_position[Z_AXIS] = MESH_HOME_SEARCH_Z;
  1635. line_to_current();
  1636. mbl.active = 1;
  1637. enqueuecommands_P(PSTR("G28"));
  1638. lcd_return_to_status();
  1639. } else {
  1640. current_position[Z_AXIS] = MESH_HOME_SEARCH_Z;
  1641. line_to_current();
  1642. ix = _lcd_level_bed_position % MESH_NUM_X_POINTS;
  1643. iy = _lcd_level_bed_position / MESH_NUM_X_POINTS;
  1644. if (iy&1) { // Zig zag
  1645. ix = (MESH_NUM_X_POINTS - 1) - ix;
  1646. }
  1647. current_position[X_AXIS] = mbl.get_x(ix);
  1648. current_position[Y_AXIS] = mbl.get_y(iy);
  1649. line_to_current();
  1650. lcdDrawUpdate = 2;
  1651. }
  1652. }
  1653. } else {
  1654. debounce_click = false;
  1655. }
  1656. }
  1657. static void _lcd_level_bed_homing() {
  1658. if (lcdDrawUpdate) lcd_implementation_drawedit(PSTR("XYZ"), "Homing");
  1659. if (axis_known_position[X_AXIS] &&
  1660. axis_known_position[Y_AXIS] &&
  1661. axis_known_position[Z_AXIS]) {
  1662. current_position[Z_AXIS] = MESH_HOME_SEARCH_Z;
  1663. plan_set_position(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS]);
  1664. current_position[X_AXIS] = MESH_MIN_X;
  1665. current_position[Y_AXIS] = MESH_MIN_Y;
  1666. line_to_current();
  1667. _lcd_level_bed_position = 0;
  1668. lcd_goto_menu(_lcd_level_bed);
  1669. }
  1670. lcdDrawUpdate = 2;
  1671. }
  1672. static void lcd_level_bed() {
  1673. axis_known_position[X_AXIS] = false;
  1674. axis_known_position[Y_AXIS] = false;
  1675. axis_known_position[Z_AXIS] = false;
  1676. mbl.reset();
  1677. enqueuecommands_P(PSTR("G28"));
  1678. lcdDrawUpdate = 2;
  1679. lcd_goto_menu(_lcd_level_bed_homing);
  1680. }
  1681. #endif // MANUAL_BED_LEVELING
  1682. #endif // ULTRA_LCD