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 66KB

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