My Marlin configs for Fabrikator Mini and CTC i3 Pro B
選択できるのは25トピックまでです。 トピックは、先頭が英数字で、英数字とダッシュ('-')を使用した35文字以内のものにしてください。

ultralcd.cpp 66KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086
  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 "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. #ifdef 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. #ifdef 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. #ifdef ULTIPANEL
  33. #if HAS_POWER_SWITCH
  34. extern bool powersupply;
  35. #endif
  36. static 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. #ifdef HAS_LCD_CONTRAST
  48. static void lcd_set_contrast();
  49. #endif
  50. #ifdef FWRETRACT
  51. static void lcd_control_retract_menu();
  52. #endif
  53. static void lcd_sdcard_menu();
  54. #ifdef DELTA_CALIBRATION_MENU
  55. static void lcd_delta_calibrate_menu();
  56. #endif
  57. #if defined(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 !defined(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. #ifdef 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. #ifdef 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. #ifdef REPRAPWORLD_KEYPAD
  189. volatile uint8_t buttons_reprapworld_keypad; // to store the keypad shift register values
  190. #endif
  191. #ifdef 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 (SDCARDDETECT > 0)
  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. #ifdef NEWPANEL
  225. encoderPosition = encoder;
  226. if (feedback) lcd_quick_feedback();
  227. #endif
  228. // For LCD_PROGRESS_BAR re-initialize the custom characters
  229. #ifdef 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. #ifdef 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. #ifdef 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. #ifdef LCD_PROGRESS_BAR
  291. currentMenu == lcd_status_screen
  292. #endif
  293. );
  294. #ifdef FILAMENT_LCD_DISPLAY
  295. previous_lcd_status_ms = millis(); // get status message to show up for a while
  296. #endif
  297. }
  298. #ifdef 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. #ifdef 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. #ifdef 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. #ifdef 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 SDCARDDETECT < 1
  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 SDCARDDETECT < 1
  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 defined(SDSUPPORT) && defined(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. #ifdef 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. #ifdef BABYSTEPPING
  444. #ifdef 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. #ifdef 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 TEMP_SENSOR_1 != 0 || TEMP_SENSOR_2 != 0 || TEMP_SENSOR_3 != 0 || TEMP_SENSOR_BED != 0 //more than one extruder present
  466. #if TEMP_SENSOR_1 != 0
  467. void lcd_preheat_pla1() { _lcd_preheat(1, plaPreheatHotendTemp, plaPreheatHPBTemp, plaPreheatFanSpeed); }
  468. void lcd_preheat_abs1() { _lcd_preheat(1, absPreheatHotendTemp, absPreheatHPBTemp, absPreheatFanSpeed); }
  469. #endif
  470. #if TEMP_SENSOR_2 != 0
  471. void lcd_preheat_pla2() { _lcd_preheat(2, plaPreheatHotendTemp, plaPreheatHPBTemp, plaPreheatFanSpeed); }
  472. void lcd_preheat_abs2() { _lcd_preheat(2, absPreheatHotendTemp, absPreheatHPBTemp, absPreheatFanSpeed); }
  473. #endif
  474. #if TEMP_SENSOR_3 != 0
  475. void lcd_preheat_pla3() { _lcd_preheat(3, plaPreheatHotendTemp, plaPreheatHPBTemp, plaPreheatFanSpeed); }
  476. void lcd_preheat_abs3() { _lcd_preheat(3, absPreheatHotendTemp, absPreheatHPBTemp, absPreheatFanSpeed); }
  477. #endif
  478. void lcd_preheat_pla0123() {
  479. setTargetHotend0(plaPreheatHotendTemp);
  480. setTargetHotend1(plaPreheatHotendTemp);
  481. setTargetHotend2(plaPreheatHotendTemp);
  482. _lcd_preheat(3, plaPreheatHotendTemp, plaPreheatHPBTemp, plaPreheatFanSpeed);
  483. }
  484. void lcd_preheat_abs0123() {
  485. setTargetHotend0(absPreheatHotendTemp);
  486. setTargetHotend1(absPreheatHotendTemp);
  487. setTargetHotend2(absPreheatHotendTemp);
  488. _lcd_preheat(3, absPreheatHotendTemp, absPreheatHPBTemp, absPreheatFanSpeed);
  489. }
  490. #if TEMP_SENSOR_0 != 0
  491. void lcd_preheat_pla_bedonly() { _lcd_preheat(0, 0, plaPreheatHPBTemp, plaPreheatFanSpeed); }
  492. void lcd_preheat_abs_bedonly() { _lcd_preheat(0, 0, absPreheatHPBTemp, absPreheatFanSpeed); }
  493. static void lcd_preheat_pla_menu() {
  494. START_MENU();
  495. MENU_ITEM(back, MSG_PREPARE, lcd_prepare_menu);
  496. MENU_ITEM(function, MSG_PREHEAT_PLA_N MSG_H1, lcd_preheat_pla0);
  497. #if TEMP_SENSOR_1 != 0
  498. MENU_ITEM(function, MSG_PREHEAT_PLA_N MSG_H2, lcd_preheat_pla1);
  499. #endif
  500. #if TEMP_SENSOR_2 != 0
  501. MENU_ITEM(function, MSG_PREHEAT_PLA_N MSG_H3, lcd_preheat_pla2);
  502. #endif
  503. #if TEMP_SENSOR_3 != 0
  504. MENU_ITEM(function, MSG_PREHEAT_PLA_N MSG_H4, lcd_preheat_pla3);
  505. #endif
  506. MENU_ITEM(function, MSG_PREHEAT_PLA_ALL, lcd_preheat_pla0123);
  507. #if TEMP_SENSOR_BED != 0
  508. MENU_ITEM(function, MSG_PREHEAT_PLA_BEDONLY, lcd_preheat_pla_bedonly);
  509. #endif
  510. END_MENU();
  511. }
  512. static void lcd_preheat_abs_menu() {
  513. START_MENU();
  514. MENU_ITEM(back, MSG_PREPARE, lcd_prepare_menu);
  515. MENU_ITEM(function, MSG_PREHEAT_ABS_N MSG_H1, lcd_preheat_abs0);
  516. #if TEMP_SENSOR_1 != 0
  517. MENU_ITEM(function, MSG_PREHEAT_ABS_N MSG_H2, lcd_preheat_abs1);
  518. #endif
  519. #if TEMP_SENSOR_2 != 0
  520. MENU_ITEM(function, MSG_PREHEAT_ABS_N MSG_H3, lcd_preheat_abs2);
  521. #endif
  522. #if TEMP_SENSOR_3 != 0
  523. MENU_ITEM(function, MSG_PREHEAT_ABS_N MSG_H4, lcd_preheat_abs3);
  524. #endif
  525. MENU_ITEM(function, MSG_PREHEAT_ABS_ALL, lcd_preheat_abs0123);
  526. #if TEMP_SENSOR_BED != 0
  527. MENU_ITEM(function, MSG_PREHEAT_ABS_BEDONLY, lcd_preheat_abs_bedonly);
  528. #endif
  529. END_MENU();
  530. }
  531. #endif
  532. #endif // more than one temperature sensor present
  533. void lcd_cooldown() {
  534. disable_all_heaters();
  535. fanSpeed = 0;
  536. lcd_return_to_status();
  537. }
  538. /**
  539. *
  540. * "Prepare" submenu
  541. *
  542. */
  543. static void lcd_prepare_menu() {
  544. START_MENU();
  545. //
  546. // ^ Main
  547. //
  548. MENU_ITEM(back, MSG_MAIN, lcd_main_menu);
  549. //
  550. // Auto Home
  551. //
  552. MENU_ITEM(gcode, MSG_AUTO_HOME, PSTR("G28"));
  553. //
  554. // Set Home Offsets
  555. //
  556. MENU_ITEM(function, MSG_SET_HOME_OFFSETS, lcd_set_home_offsets);
  557. //MENU_ITEM(gcode, MSG_SET_ORIGIN, PSTR("G92 X0 Y0 Z0"));
  558. //
  559. // Level Bed
  560. //
  561. #ifdef ENABLE_AUTO_BED_LEVELING
  562. if (axis_known_position[X_AXIS] && axis_known_position[Y_AXIS])
  563. MENU_ITEM(gcode, MSG_LEVEL_BED, PSTR("G29"));
  564. #elif defined(MANUAL_BED_LEVELING)
  565. MENU_ITEM(submenu, MSG_LEVEL_BED, lcd_level_bed);
  566. #endif
  567. //
  568. // Move Axis
  569. //
  570. MENU_ITEM(submenu, MSG_MOVE_AXIS, lcd_move_menu);
  571. //
  572. // Disable Steppers
  573. //
  574. MENU_ITEM(gcode, MSG_DISABLE_STEPPERS, PSTR("M84"));
  575. //
  576. // Preheat PLA
  577. // Preheat ABS
  578. //
  579. #if TEMP_SENSOR_0 != 0
  580. #if TEMP_SENSOR_1 != 0 || TEMP_SENSOR_2 != 0 || TEMP_SENSOR_3 != 0 || TEMP_SENSOR_BED != 0
  581. MENU_ITEM(submenu, MSG_PREHEAT_PLA, lcd_preheat_pla_menu);
  582. MENU_ITEM(submenu, MSG_PREHEAT_ABS, lcd_preheat_abs_menu);
  583. #else
  584. MENU_ITEM(function, MSG_PREHEAT_PLA, lcd_preheat_pla0);
  585. MENU_ITEM(function, MSG_PREHEAT_ABS, lcd_preheat_abs0);
  586. #endif
  587. #endif
  588. //
  589. // Cooldown
  590. //
  591. MENU_ITEM(function, MSG_COOLDOWN, lcd_cooldown);
  592. //
  593. // Switch power on/off
  594. //
  595. #if HAS_POWER_SWITCH
  596. if (powersupply)
  597. MENU_ITEM(gcode, MSG_SWITCH_PS_OFF, PSTR("M81"));
  598. else
  599. MENU_ITEM(gcode, MSG_SWITCH_PS_ON, PSTR("M80"));
  600. #endif
  601. //
  602. // Autostart
  603. //
  604. #if defined(SDSUPPORT) && defined(MENU_ADDAUTOSTART)
  605. MENU_ITEM(function, MSG_AUTOSTART, lcd_autostart_sd);
  606. #endif
  607. END_MENU();
  608. }
  609. #ifdef DELTA_CALIBRATION_MENU
  610. static void lcd_delta_calibrate_menu() {
  611. START_MENU();
  612. MENU_ITEM(back, MSG_MAIN, lcd_main_menu);
  613. MENU_ITEM(gcode, MSG_AUTO_HOME, PSTR("G28"));
  614. MENU_ITEM(gcode, MSG_DELTA_CALIBRATE_X, PSTR("G0 F8000 X-77.94 Y-45 Z0"));
  615. MENU_ITEM(gcode, MSG_DELTA_CALIBRATE_Y, PSTR("G0 F8000 X77.94 Y-45 Z0"));
  616. MENU_ITEM(gcode, MSG_DELTA_CALIBRATE_Z, PSTR("G0 F8000 X0 Y90 Z0"));
  617. MENU_ITEM(gcode, MSG_DELTA_CALIBRATE_CENTER, PSTR("G0 F8000 X0 Y0 Z0"));
  618. END_MENU();
  619. }
  620. #endif // DELTA_CALIBRATION_MENU
  621. inline void line_to_current(AxisEnum axis) {
  622. #ifdef DELTA
  623. calculate_delta(current_position);
  624. plan_buffer_line(delta[X_AXIS], delta[Y_AXIS], delta[Z_AXIS], current_position[E_AXIS], manual_feedrate[axis]/60, active_extruder);
  625. #else
  626. 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);
  627. #endif
  628. }
  629. /**
  630. *
  631. * "Prepare" > "Move Axis" submenu
  632. *
  633. */
  634. float move_menu_scale;
  635. static void lcd_move_menu_axis();
  636. static void _lcd_move(const char *name, AxisEnum axis, int min, int max) {
  637. if (encoderPosition != 0) {
  638. refresh_cmd_timeout();
  639. current_position[axis] += float((int)encoderPosition) * move_menu_scale;
  640. if (min_software_endstops && current_position[axis] < min) current_position[axis] = min;
  641. if (max_software_endstops && current_position[axis] > max) current_position[axis] = max;
  642. encoderPosition = 0;
  643. line_to_current(axis);
  644. lcdDrawUpdate = 1;
  645. }
  646. if (lcdDrawUpdate) lcd_implementation_drawedit(name, ftostr31(current_position[axis]));
  647. if (LCD_CLICKED) lcd_goto_menu(lcd_move_menu_axis);
  648. }
  649. static void lcd_move_x() { _lcd_move(PSTR("X"), X_AXIS, X_MIN_POS, X_MAX_POS); }
  650. static void lcd_move_y() { _lcd_move(PSTR("Y"), Y_AXIS, Y_MIN_POS, Y_MAX_POS); }
  651. static void lcd_move_z() { _lcd_move(PSTR("Z"), Z_AXIS, Z_MIN_POS, Z_MAX_POS); }
  652. static void lcd_move_e() {
  653. if (encoderPosition != 0) {
  654. current_position[E_AXIS] += float((int)encoderPosition) * move_menu_scale;
  655. encoderPosition = 0;
  656. line_to_current(E_AXIS);
  657. lcdDrawUpdate = 1;
  658. }
  659. if (lcdDrawUpdate) lcd_implementation_drawedit(PSTR("Extruder"), ftostr31(current_position[E_AXIS]));
  660. if (LCD_CLICKED) lcd_goto_menu(lcd_move_menu_axis);
  661. }
  662. /**
  663. *
  664. * "Prepare" > "Move Xmm" > "Move XYZ" submenu
  665. *
  666. */
  667. static void lcd_move_menu_axis() {
  668. START_MENU();
  669. MENU_ITEM(back, MSG_MOVE_AXIS, lcd_move_menu);
  670. MENU_ITEM(submenu, MSG_MOVE_X, lcd_move_x);
  671. MENU_ITEM(submenu, MSG_MOVE_Y, lcd_move_y);
  672. if (move_menu_scale < 10.0) {
  673. MENU_ITEM(submenu, MSG_MOVE_Z, lcd_move_z);
  674. MENU_ITEM(submenu, MSG_MOVE_E, lcd_move_e);
  675. }
  676. END_MENU();
  677. }
  678. static void lcd_move_menu_10mm() {
  679. move_menu_scale = 10.0;
  680. lcd_move_menu_axis();
  681. }
  682. static void lcd_move_menu_1mm() {
  683. move_menu_scale = 1.0;
  684. lcd_move_menu_axis();
  685. }
  686. static void lcd_move_menu_01mm() {
  687. move_menu_scale = 0.1;
  688. lcd_move_menu_axis();
  689. }
  690. /**
  691. *
  692. * "Prepare" > "Move Axis" submenu
  693. *
  694. */
  695. static void lcd_move_menu() {
  696. START_MENU();
  697. MENU_ITEM(back, MSG_PREPARE, lcd_prepare_menu);
  698. MENU_ITEM(submenu, MSG_MOVE_10MM, lcd_move_menu_10mm);
  699. MENU_ITEM(submenu, MSG_MOVE_1MM, lcd_move_menu_1mm);
  700. MENU_ITEM(submenu, MSG_MOVE_01MM, lcd_move_menu_01mm);
  701. //TODO:X,Y,Z,E
  702. END_MENU();
  703. }
  704. /**
  705. *
  706. * "Control" submenu
  707. *
  708. */
  709. static void lcd_control_menu() {
  710. START_MENU();
  711. MENU_ITEM(back, MSG_MAIN, lcd_main_menu);
  712. MENU_ITEM(submenu, MSG_TEMPERATURE, lcd_control_temperature_menu);
  713. MENU_ITEM(submenu, MSG_MOTION, lcd_control_motion_menu);
  714. MENU_ITEM(submenu, MSG_VOLUMETRIC, lcd_control_volumetric_menu);
  715. #ifdef HAS_LCD_CONTRAST
  716. //MENU_ITEM_EDIT(int3, MSG_CONTRAST, &lcd_contrast, 0, 63);
  717. MENU_ITEM(submenu, MSG_CONTRAST, lcd_set_contrast);
  718. #endif
  719. #ifdef FWRETRACT
  720. MENU_ITEM(submenu, MSG_RETRACT, lcd_control_retract_menu);
  721. #endif
  722. #ifdef EEPROM_SETTINGS
  723. MENU_ITEM(function, MSG_STORE_EPROM, Config_StoreSettings);
  724. MENU_ITEM(function, MSG_LOAD_EPROM, Config_RetrieveSettings);
  725. #endif
  726. MENU_ITEM(function, MSG_RESTORE_FAILSAFE, Config_ResetDefault);
  727. END_MENU();
  728. }
  729. /**
  730. *
  731. * "Temperature" submenu
  732. *
  733. */
  734. #ifdef PIDTEMP
  735. // Helpers for editing PID Ki & Kd values
  736. // grab the PID value out of the temp variable; scale it; then update the PID driver
  737. void copy_and_scalePID_i(int e) {
  738. PID_PARAM(Ki, e) = scalePID_i(raw_Ki);
  739. updatePID();
  740. }
  741. void copy_and_scalePID_d(int e) {
  742. PID_PARAM(Kd, e) = scalePID_d(raw_Kd);
  743. updatePID();
  744. }
  745. void copy_and_scalePID_i_E1() { copy_and_scalePID_i(0); }
  746. void copy_and_scalePID_d_E1() { copy_and_scalePID_d(0); }
  747. #ifdef PID_PARAMS_PER_EXTRUDER
  748. #if EXTRUDERS > 1
  749. void copy_and_scalePID_i_E2() { copy_and_scalePID_i(1); }
  750. void copy_and_scalePID_d_E2() { copy_and_scalePID_d(1); }
  751. #if EXTRUDERS > 2
  752. void copy_and_scalePID_i_E3() { copy_and_scalePID_i(2); }
  753. void copy_and_scalePID_d_E3() { copy_and_scalePID_d(2); }
  754. #if EXTRUDERS > 3
  755. void copy_and_scalePID_i_E4() { copy_and_scalePID_i(3); }
  756. void copy_and_scalePID_d_E4() { copy_and_scalePID_d(3); }
  757. #endif //EXTRUDERS > 3
  758. #endif //EXTRUDERS > 2
  759. #endif //EXTRUDERS > 1
  760. #endif //PID_PARAMS_PER_EXTRUDER
  761. #endif //PIDTEMP
  762. /**
  763. *
  764. * "Control" > "Temperature" submenu
  765. *
  766. */
  767. static void lcd_control_temperature_menu() {
  768. START_MENU();
  769. //
  770. // ^ Control
  771. //
  772. MENU_ITEM(back, MSG_CONTROL, lcd_control_menu);
  773. //
  774. // Nozzle, Nozzle 2, Nozzle 3, Nozzle 4
  775. //
  776. #if TEMP_SENSOR_0 != 0
  777. MENU_MULTIPLIER_ITEM_EDIT(int3, MSG_NOZZLE, &target_temperature[0], 0, HEATER_0_MAXTEMP - 15);
  778. #endif
  779. #if EXTRUDERS > 1
  780. #if TEMP_SENSOR_1 != 0
  781. MENU_MULTIPLIER_ITEM_EDIT(int3, MSG_NOZZLE MSG_N2, &target_temperature[1], 0, HEATER_1_MAXTEMP - 15);
  782. #endif
  783. #if EXTRUDERS > 2
  784. #if TEMP_SENSOR_2 != 0
  785. MENU_MULTIPLIER_ITEM_EDIT(int3, MSG_NOZZLE MSG_N3, &target_temperature[2], 0, HEATER_2_MAXTEMP - 15);
  786. #endif
  787. #if EXTRUDERS > 3
  788. #if TEMP_SENSOR_3 != 0
  789. MENU_MULTIPLIER_ITEM_EDIT(int3, MSG_NOZZLE MSG_N4, &target_temperature[3], 0, HEATER_3_MAXTEMP - 15);
  790. #endif
  791. #endif // EXTRUDERS > 3
  792. #endif // EXTRUDERS > 2
  793. #endif // EXTRUDERS > 1
  794. //
  795. // Bed
  796. //
  797. #if TEMP_SENSOR_BED != 0
  798. MENU_MULTIPLIER_ITEM_EDIT(int3, MSG_BED, &target_temperature_bed, 0, BED_MAXTEMP - 15);
  799. #endif
  800. //
  801. // Fan Speed
  802. //
  803. MENU_MULTIPLIER_ITEM_EDIT(int3, MSG_FAN_SPEED, &fanSpeed, 0, 255);
  804. //
  805. // Autotemp, Min, Max, Fact
  806. //
  807. #if defined(AUTOTEMP) && (TEMP_SENSOR_0 != 0)
  808. MENU_ITEM_EDIT(bool, MSG_AUTOTEMP, &autotemp_enabled);
  809. MENU_ITEM_EDIT(float3, MSG_MIN, &autotemp_min, 0, HEATER_0_MAXTEMP - 15);
  810. MENU_ITEM_EDIT(float3, MSG_MAX, &autotemp_max, 0, HEATER_0_MAXTEMP - 15);
  811. MENU_ITEM_EDIT(float32, MSG_FACTOR, &autotemp_factor, 0.0, 1.0);
  812. #endif
  813. //
  814. // PID-P, PID-I, PID-D, PID-C
  815. //
  816. #ifdef PIDTEMP
  817. // set up temp variables - undo the default scaling
  818. raw_Ki = unscalePID_i(PID_PARAM(Ki,0));
  819. raw_Kd = unscalePID_d(PID_PARAM(Kd,0));
  820. MENU_ITEM_EDIT(float52, MSG_PID_P, &PID_PARAM(Kp,0), 1, 9990);
  821. // i is typically a small value so allows values below 1
  822. MENU_ITEM_EDIT_CALLBACK(float52, MSG_PID_I, &raw_Ki, 0.01, 9990, copy_and_scalePID_i_E1);
  823. MENU_ITEM_EDIT_CALLBACK(float52, MSG_PID_D, &raw_Kd, 1, 9990, copy_and_scalePID_d_E1);
  824. #ifdef PID_ADD_EXTRUSION_RATE
  825. MENU_ITEM_EDIT(float3, MSG_PID_C, &PID_PARAM(Kc,0), 1, 9990);
  826. #endif//PID_ADD_EXTRUSION_RATE
  827. #ifdef PID_PARAMS_PER_EXTRUDER
  828. #if EXTRUDERS > 1
  829. // set up temp variables - undo the default scaling
  830. raw_Ki = unscalePID_i(PID_PARAM(Ki,1));
  831. raw_Kd = unscalePID_d(PID_PARAM(Kd,1));
  832. MENU_ITEM_EDIT(float52, MSG_PID_P MSG_E2, &PID_PARAM(Kp,1), 1, 9990);
  833. // i is typically a small value so allows values below 1
  834. MENU_ITEM_EDIT_CALLBACK(float52, MSG_PID_I MSG_E2, &raw_Ki, 0.01, 9990, copy_and_scalePID_i_E2);
  835. MENU_ITEM_EDIT_CALLBACK(float52, MSG_PID_D MSG_E2, &raw_Kd, 1, 9990, copy_and_scalePID_d_E2);
  836. #ifdef PID_ADD_EXTRUSION_RATE
  837. MENU_ITEM_EDIT(float3, MSG_PID_C MSG_E2, &PID_PARAM(Kc,1), 1, 9990);
  838. #endif//PID_ADD_EXTRUSION_RATE
  839. #if EXTRUDERS > 2
  840. // set up temp variables - undo the default scaling
  841. raw_Ki = unscalePID_i(PID_PARAM(Ki,2));
  842. raw_Kd = unscalePID_d(PID_PARAM(Kd,2));
  843. MENU_ITEM_EDIT(float52, MSG_PID_P MSG_E3, &PID_PARAM(Kp,2), 1, 9990);
  844. // i is typically a small value so allows values below 1
  845. MENU_ITEM_EDIT_CALLBACK(float52, MSG_PID_I MSG_E3, &raw_Ki, 0.01, 9990, copy_and_scalePID_i_E3);
  846. MENU_ITEM_EDIT_CALLBACK(float52, MSG_PID_D MSG_E3, &raw_Kd, 1, 9990, copy_and_scalePID_d_E3);
  847. #ifdef PID_ADD_EXTRUSION_RATE
  848. MENU_ITEM_EDIT(float3, MSG_PID_C MSG_E3, &PID_PARAM(Kc,2), 1, 9990);
  849. #endif//PID_ADD_EXTRUSION_RATE
  850. #if EXTRUDERS > 3
  851. // set up temp variables - undo the default scaling
  852. raw_Ki = unscalePID_i(PID_PARAM(Ki,3));
  853. raw_Kd = unscalePID_d(PID_PARAM(Kd,3));
  854. MENU_ITEM_EDIT(float52, MSG_PID_P MSG_E4, &PID_PARAM(Kp,3), 1, 9990);
  855. // i is typically a small value so allows values below 1
  856. MENU_ITEM_EDIT_CALLBACK(float52, MSG_PID_I MSG_E4, &raw_Ki, 0.01, 9990, copy_and_scalePID_i_E4);
  857. MENU_ITEM_EDIT_CALLBACK(float52, MSG_PID_D MSG_E4, &raw_Kd, 1, 9990, copy_and_scalePID_d_E4);
  858. #ifdef PID_ADD_EXTRUSION_RATE
  859. MENU_ITEM_EDIT(float3, MSG_PID_C MSG_E4, &PID_PARAM(Kc,3), 1, 9990);
  860. #endif//PID_ADD_EXTRUSION_RATE
  861. #endif//EXTRUDERS > 3
  862. #endif//EXTRUDERS > 2
  863. #endif//EXTRUDERS > 1
  864. #endif //PID_PARAMS_PER_EXTRUDER
  865. #endif//PIDTEMP
  866. //
  867. // Preheat PLA conf
  868. //
  869. MENU_ITEM(submenu, MSG_PREHEAT_PLA_SETTINGS, lcd_control_temperature_preheat_pla_settings_menu);
  870. //
  871. // Preheat ABS conf
  872. //
  873. MENU_ITEM(submenu, MSG_PREHEAT_ABS_SETTINGS, lcd_control_temperature_preheat_abs_settings_menu);
  874. END_MENU();
  875. }
  876. /**
  877. *
  878. * "Temperature" > "Preheat PLA conf" submenu
  879. *
  880. */
  881. static void lcd_control_temperature_preheat_pla_settings_menu() {
  882. START_MENU();
  883. MENU_ITEM(back, MSG_TEMPERATURE, lcd_control_temperature_menu);
  884. MENU_ITEM_EDIT(int3, MSG_FAN_SPEED, &plaPreheatFanSpeed, 0, 255);
  885. #if TEMP_SENSOR_0 != 0
  886. MENU_ITEM_EDIT(int3, MSG_NOZZLE, &plaPreheatHotendTemp, HEATER_0_MINTEMP, HEATER_0_MAXTEMP - 15);
  887. #endif
  888. #if TEMP_SENSOR_BED != 0
  889. MENU_ITEM_EDIT(int3, MSG_BED, &plaPreheatHPBTemp, BED_MINTEMP, BED_MAXTEMP - 15);
  890. #endif
  891. #ifdef EEPROM_SETTINGS
  892. MENU_ITEM(function, MSG_STORE_EPROM, Config_StoreSettings);
  893. #endif
  894. END_MENU();
  895. }
  896. /**
  897. *
  898. * "Temperature" > "Preheat ABS conf" submenu
  899. *
  900. */
  901. static void lcd_control_temperature_preheat_abs_settings_menu() {
  902. START_MENU();
  903. MENU_ITEM(back, MSG_TEMPERATURE, lcd_control_temperature_menu);
  904. MENU_ITEM_EDIT(int3, MSG_FAN_SPEED, &absPreheatFanSpeed, 0, 255);
  905. #if TEMP_SENSOR_0 != 0
  906. MENU_ITEM_EDIT(int3, MSG_NOZZLE, &absPreheatHotendTemp, HEATER_0_MINTEMP, HEATER_0_MAXTEMP - 15);
  907. #endif
  908. #if TEMP_SENSOR_BED != 0
  909. MENU_ITEM_EDIT(int3, MSG_BED, &absPreheatHPBTemp, BED_MINTEMP, BED_MAXTEMP - 15);
  910. #endif
  911. #ifdef EEPROM_SETTINGS
  912. MENU_ITEM(function, MSG_STORE_EPROM, Config_StoreSettings);
  913. #endif
  914. END_MENU();
  915. }
  916. /**
  917. *
  918. * "Control" > "Motion" submenu
  919. *
  920. */
  921. static void lcd_control_motion_menu() {
  922. START_MENU();
  923. MENU_ITEM(back, MSG_CONTROL, lcd_control_menu);
  924. #ifdef ENABLE_AUTO_BED_LEVELING
  925. MENU_ITEM_EDIT(float32, MSG_ZPROBE_ZOFFSET, &zprobe_zoffset, Z_PROBE_OFFSET_RANGE_MIN, Z_PROBE_OFFSET_RANGE_MAX);
  926. #endif
  927. MENU_ITEM_EDIT(float5, MSG_ACC, &acceleration, 10, 99000);
  928. MENU_ITEM_EDIT(float3, MSG_VXY_JERK, &max_xy_jerk, 1, 990);
  929. MENU_ITEM_EDIT(float52, MSG_VZ_JERK, &max_z_jerk, 0.1, 990);
  930. MENU_ITEM_EDIT(float3, MSG_VE_JERK, &max_e_jerk, 1, 990);
  931. MENU_ITEM_EDIT(float3, MSG_VMAX MSG_X, &max_feedrate[X_AXIS], 1, 999);
  932. MENU_ITEM_EDIT(float3, MSG_VMAX MSG_Y, &max_feedrate[Y_AXIS], 1, 999);
  933. MENU_ITEM_EDIT(float3, MSG_VMAX MSG_Z, &max_feedrate[Z_AXIS], 1, 999);
  934. MENU_ITEM_EDIT(float3, MSG_VMAX MSG_E, &max_feedrate[E_AXIS], 1, 999);
  935. MENU_ITEM_EDIT(float3, MSG_VMIN, &minimumfeedrate, 0, 999);
  936. MENU_ITEM_EDIT(float3, MSG_VTRAV_MIN, &mintravelfeedrate, 0, 999);
  937. MENU_ITEM_EDIT_CALLBACK(long5, MSG_AMAX MSG_X, &max_acceleration_units_per_sq_second[X_AXIS], 100, 99000, reset_acceleration_rates);
  938. MENU_ITEM_EDIT_CALLBACK(long5, MSG_AMAX MSG_Y, &max_acceleration_units_per_sq_second[Y_AXIS], 100, 99000, reset_acceleration_rates);
  939. MENU_ITEM_EDIT_CALLBACK(long5, MSG_AMAX MSG_Z, &max_acceleration_units_per_sq_second[Z_AXIS], 10, 99000, reset_acceleration_rates);
  940. MENU_ITEM_EDIT_CALLBACK(long5, MSG_AMAX MSG_E, &max_acceleration_units_per_sq_second[E_AXIS], 100, 99000, reset_acceleration_rates);
  941. MENU_ITEM_EDIT(float5, MSG_A_RETRACT, &retract_acceleration, 100, 99000);
  942. MENU_ITEM_EDIT(float5, MSG_A_TRAVEL, &travel_acceleration, 100, 99000);
  943. MENU_ITEM_EDIT(float52, MSG_XSTEPS, &axis_steps_per_unit[X_AXIS], 5, 9999);
  944. MENU_ITEM_EDIT(float52, MSG_YSTEPS, &axis_steps_per_unit[Y_AXIS], 5, 9999);
  945. MENU_ITEM_EDIT(float51, MSG_ZSTEPS, &axis_steps_per_unit[Z_AXIS], 5, 9999);
  946. MENU_ITEM_EDIT(float51, MSG_ESTEPS, &axis_steps_per_unit[E_AXIS], 5, 9999);
  947. #ifdef ABORT_ON_ENDSTOP_HIT_FEATURE_ENABLED
  948. MENU_ITEM_EDIT(bool, MSG_ENDSTOP_ABORT, &abort_on_endstop_hit);
  949. #endif
  950. #ifdef SCARA
  951. MENU_ITEM_EDIT(float74, MSG_XSCALE, &axis_scaling[X_AXIS],0.5,2);
  952. MENU_ITEM_EDIT(float74, MSG_YSCALE, &axis_scaling[Y_AXIS],0.5,2);
  953. #endif
  954. END_MENU();
  955. }
  956. /**
  957. *
  958. * "Control" > "Filament" submenu
  959. *
  960. */
  961. static void lcd_control_volumetric_menu() {
  962. START_MENU();
  963. MENU_ITEM(back, MSG_CONTROL, lcd_control_menu);
  964. MENU_ITEM_EDIT_CALLBACK(bool, MSG_VOLUMETRIC_ENABLED, &volumetric_enabled, calculate_volumetric_multipliers);
  965. if (volumetric_enabled) {
  966. MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(float43, MSG_FILAMENT_SIZE_EXTRUDER_0, &filament_size[0], 1.5, 3.25, calculate_volumetric_multipliers);
  967. #if EXTRUDERS > 1
  968. MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(float43, MSG_FILAMENT_SIZE_EXTRUDER_1, &filament_size[1], 1.5, 3.25, calculate_volumetric_multipliers);
  969. #if EXTRUDERS > 2
  970. MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(float43, MSG_FILAMENT_SIZE_EXTRUDER_2, &filament_size[2], 1.5, 3.25, calculate_volumetric_multipliers);
  971. #if EXTRUDERS > 3
  972. MENU_MULTIPLIER_ITEM_EDIT_CALLBACK(float43, MSG_FILAMENT_SIZE_EXTRUDER_3, &filament_size[3], 1.5, 3.25, calculate_volumetric_multipliers);
  973. #endif //EXTRUDERS > 3
  974. #endif //EXTRUDERS > 2
  975. #endif //EXTRUDERS > 1
  976. }
  977. END_MENU();
  978. }
  979. /**
  980. *
  981. * "Control" > "Contrast" submenu
  982. *
  983. */
  984. #ifdef HAS_LCD_CONTRAST
  985. static void lcd_set_contrast() {
  986. if (encoderPosition != 0) {
  987. #ifdef U8GLIB_LM6059_AF
  988. lcd_contrast += encoderPosition;
  989. lcd_contrast &= 0xFF;
  990. #else
  991. lcd_contrast -= encoderPosition;
  992. lcd_contrast &= 0x3F;
  993. #endif
  994. encoderPosition = 0;
  995. lcdDrawUpdate = 1;
  996. u8g.setContrast(lcd_contrast);
  997. }
  998. if (lcdDrawUpdate) {
  999. #ifdef U8GLIB_LM6059_AF
  1000. lcd_implementation_drawedit(PSTR(MSG_CONTRAST), itostr3(lcd_contrast));
  1001. #else
  1002. lcd_implementation_drawedit(PSTR(MSG_CONTRAST), itostr2(lcd_contrast));
  1003. #endif
  1004. }
  1005. if (LCD_CLICKED) lcd_goto_menu(lcd_control_menu);
  1006. }
  1007. #endif // HAS_LCD_CONTRAST
  1008. /**
  1009. *
  1010. * "Control" > "Retract" submenu
  1011. *
  1012. */
  1013. #ifdef FWRETRACT
  1014. static void lcd_control_retract_menu() {
  1015. START_MENU();
  1016. MENU_ITEM(back, MSG_CONTROL, lcd_control_menu);
  1017. MENU_ITEM_EDIT(bool, MSG_AUTORETRACT, &autoretract_enabled);
  1018. MENU_ITEM_EDIT(float52, MSG_CONTROL_RETRACT, &retract_length, 0, 100);
  1019. #if EXTRUDERS > 1
  1020. MENU_ITEM_EDIT(float52, MSG_CONTROL_RETRACT_SWAP, &retract_length_swap, 0, 100);
  1021. #endif
  1022. MENU_ITEM_EDIT(float3, MSG_CONTROL_RETRACTF, &retract_feedrate, 1, 999);
  1023. MENU_ITEM_EDIT(float52, MSG_CONTROL_RETRACT_ZLIFT, &retract_zlift, 0, 999);
  1024. MENU_ITEM_EDIT(float52, MSG_CONTROL_RETRACT_RECOVER, &retract_recover_length, 0, 100);
  1025. #if EXTRUDERS > 1
  1026. MENU_ITEM_EDIT(float52, MSG_CONTROL_RETRACT_RECOVER_SWAP, &retract_recover_length_swap, 0, 100);
  1027. #endif
  1028. MENU_ITEM_EDIT(float3, MSG_CONTROL_RETRACT_RECOVERF, &retract_recover_feedrate, 1, 999);
  1029. END_MENU();
  1030. }
  1031. #endif // FWRETRACT
  1032. #if SDCARDDETECT == -1
  1033. static void lcd_sd_refresh() {
  1034. card.initsd();
  1035. currentMenuViewOffset = 0;
  1036. }
  1037. #endif
  1038. static void lcd_sd_updir() {
  1039. card.updir();
  1040. currentMenuViewOffset = 0;
  1041. }
  1042. /**
  1043. *
  1044. * "Print from SD" submenu
  1045. *
  1046. */
  1047. void lcd_sdcard_menu() {
  1048. if (lcdDrawUpdate == 0 && LCD_CLICKED == 0) return; // nothing to do (so don't thrash the SD card)
  1049. uint16_t fileCnt = card.getnrfilenames();
  1050. START_MENU();
  1051. MENU_ITEM(back, MSG_MAIN, lcd_main_menu);
  1052. card.getWorkDirName();
  1053. if (card.filename[0] == '/') {
  1054. #if SDCARDDETECT == -1
  1055. MENU_ITEM(function, LCD_STR_REFRESH MSG_REFRESH, lcd_sd_refresh);
  1056. #endif
  1057. }
  1058. else {
  1059. MENU_ITEM(function, LCD_STR_FOLDER "..", lcd_sd_updir);
  1060. }
  1061. for (uint16_t i = 0; i < fileCnt; i++) {
  1062. if (_menuItemNr == _lineNr) {
  1063. card.getfilename(
  1064. #ifdef SDCARD_RATHERRECENTFIRST
  1065. fileCnt-1 -
  1066. #endif
  1067. i
  1068. );
  1069. if (card.filenameIsDir)
  1070. MENU_ITEM(sddirectory, MSG_CARD_MENU, card.filename, card.longFilename);
  1071. else
  1072. MENU_ITEM(sdfile, MSG_CARD_MENU, card.filename, card.longFilename);
  1073. }
  1074. else {
  1075. MENU_ITEM_DUMMY();
  1076. }
  1077. }
  1078. END_MENU();
  1079. }
  1080. /**
  1081. *
  1082. * Functions for editing single values
  1083. *
  1084. */
  1085. #define menu_edit_type(_type, _name, _strFunc, scale) \
  1086. bool _menu_edit_ ## _name () { \
  1087. bool isClicked = LCD_CLICKED; \
  1088. if ((int32_t)encoderPosition < 0) encoderPosition = 0; \
  1089. if ((int32_t)encoderPosition > maxEditValue) encoderPosition = maxEditValue; \
  1090. if (lcdDrawUpdate) \
  1091. lcd_implementation_drawedit(editLabel, _strFunc(((_type)((int32_t)encoderPosition + minEditValue)) / scale)); \
  1092. if (isClicked) { \
  1093. *((_type*)editValue) = ((_type)((int32_t)encoderPosition + minEditValue)) / scale; \
  1094. lcd_goto_menu(prevMenu, prevEncoderPosition); \
  1095. } \
  1096. return isClicked; \
  1097. } \
  1098. void menu_edit_ ## _name () { _menu_edit_ ## _name(); } \
  1099. void menu_edit_callback_ ## _name () { if (_menu_edit_ ## _name ()) (*callbackFunc)(); } \
  1100. static void _menu_action_setting_edit_ ## _name (const char* pstr, _type* ptr, _type minValue, _type maxValue) { \
  1101. prevMenu = currentMenu; \
  1102. prevEncoderPosition = encoderPosition; \
  1103. \
  1104. lcdDrawUpdate = 2; \
  1105. currentMenu = menu_edit_ ## _name; \
  1106. \
  1107. editLabel = pstr; \
  1108. editValue = ptr; \
  1109. minEditValue = minValue * scale; \
  1110. maxEditValue = maxValue * scale - minEditValue; \
  1111. encoderPosition = (*ptr) * scale - minEditValue; \
  1112. } \
  1113. static void menu_action_setting_edit_ ## _name (const char* pstr, _type* ptr, _type minValue, _type maxValue) { \
  1114. _menu_action_setting_edit_ ## _name(pstr, ptr, minValue, maxValue); \
  1115. currentMenu = menu_edit_ ## _name; \
  1116. }\
  1117. static void menu_action_setting_edit_callback_ ## _name (const char* pstr, _type* ptr, _type minValue, _type maxValue, menuFunc_t callback) { \
  1118. _menu_action_setting_edit_ ## _name(pstr, ptr, minValue, maxValue); \
  1119. currentMenu = menu_edit_callback_ ## _name; \
  1120. callbackFunc = callback; \
  1121. }
  1122. menu_edit_type(int, int3, itostr3, 1)
  1123. menu_edit_type(float, float3, ftostr3, 1)
  1124. menu_edit_type(float, float32, ftostr32, 100)
  1125. menu_edit_type(float, float43, ftostr43, 1000)
  1126. menu_edit_type(float, float5, ftostr5, 0.01)
  1127. menu_edit_type(float, float51, ftostr51, 10)
  1128. menu_edit_type(float, float52, ftostr52, 100)
  1129. menu_edit_type(unsigned long, long5, ftostr5, 0.01)
  1130. /**
  1131. *
  1132. * Handlers for RepRap World Keypad input
  1133. *
  1134. */
  1135. #ifdef REPRAPWORLD_KEYPAD
  1136. static void reprapworld_keypad_move_z_up() {
  1137. encoderPosition = 1;
  1138. move_menu_scale = REPRAPWORLD_KEYPAD_MOVE_STEP;
  1139. lcd_move_z();
  1140. }
  1141. static void reprapworld_keypad_move_z_down() {
  1142. encoderPosition = -1;
  1143. move_menu_scale = REPRAPWORLD_KEYPAD_MOVE_STEP;
  1144. lcd_move_z();
  1145. }
  1146. static void reprapworld_keypad_move_x_left() {
  1147. encoderPosition = -1;
  1148. move_menu_scale = REPRAPWORLD_KEYPAD_MOVE_STEP;
  1149. lcd_move_x();
  1150. }
  1151. static void reprapworld_keypad_move_x_right() {
  1152. encoderPosition = 1;
  1153. move_menu_scale = REPRAPWORLD_KEYPAD_MOVE_STEP;
  1154. lcd_move_x();
  1155. }
  1156. static void reprapworld_keypad_move_y_down() {
  1157. encoderPosition = 1;
  1158. move_menu_scale = REPRAPWORLD_KEYPAD_MOVE_STEP;
  1159. lcd_move_y();
  1160. }
  1161. static void reprapworld_keypad_move_y_up() {
  1162. encoderPosition = -1;
  1163. move_menu_scale = REPRAPWORLD_KEYPAD_MOVE_STEP;
  1164. lcd_move_y();
  1165. }
  1166. static void reprapworld_keypad_move_home() {
  1167. enqueuecommands_P((PSTR("G28"))); // move all axis home
  1168. }
  1169. #endif // REPRAPWORLD_KEYPAD
  1170. /**
  1171. *
  1172. * Audio feedback for controller clicks
  1173. *
  1174. */
  1175. void lcd_quick_feedback() {
  1176. lcdDrawUpdate = 2;
  1177. next_button_update_ms = millis() + 500;
  1178. #ifdef LCD_USE_I2C_BUZZER
  1179. #ifndef LCD_FEEDBACK_FREQUENCY_HZ
  1180. #define LCD_FEEDBACK_FREQUENCY_HZ 100
  1181. #endif
  1182. #ifndef LCD_FEEDBACK_FREQUENCY_DURATION_MS
  1183. #define LCD_FEEDBACK_FREQUENCY_DURATION_MS (1000/6)
  1184. #endif
  1185. lcd_buzz(LCD_FEEDBACK_FREQUENCY_DURATION_MS, LCD_FEEDBACK_FREQUENCY_HZ);
  1186. #elif defined(BEEPER) && BEEPER >= 0
  1187. #ifndef LCD_FEEDBACK_FREQUENCY_HZ
  1188. #define LCD_FEEDBACK_FREQUENCY_HZ 5000
  1189. #endif
  1190. #ifndef LCD_FEEDBACK_FREQUENCY_DURATION_MS
  1191. #define LCD_FEEDBACK_FREQUENCY_DURATION_MS 2
  1192. #endif
  1193. lcd_buzz(LCD_FEEDBACK_FREQUENCY_DURATION_MS, LCD_FEEDBACK_FREQUENCY_HZ);
  1194. #else
  1195. #ifndef LCD_FEEDBACK_FREQUENCY_DURATION_MS
  1196. #define LCD_FEEDBACK_FREQUENCY_DURATION_MS 2
  1197. #endif
  1198. delay(LCD_FEEDBACK_FREQUENCY_DURATION_MS);
  1199. #endif
  1200. }
  1201. /**
  1202. *
  1203. * Menu actions
  1204. *
  1205. */
  1206. static void menu_action_back(menuFunc_t func) { lcd_goto_menu(func); }
  1207. static void menu_action_submenu(menuFunc_t func) { lcd_goto_menu(func); }
  1208. static void menu_action_gcode(const char* pgcode) { enqueuecommands_P(pgcode); }
  1209. static void menu_action_function(menuFunc_t func) { (*func)(); }
  1210. static void menu_action_sdfile(const char* filename, char* longFilename) {
  1211. char cmd[30];
  1212. char* c;
  1213. sprintf_P(cmd, PSTR("M23 %s"), filename);
  1214. for(c = &cmd[4]; *c; c++) *c = tolower(*c);
  1215. enqueuecommand(cmd);
  1216. enqueuecommands_P(PSTR("M24"));
  1217. lcd_return_to_status();
  1218. }
  1219. static void menu_action_sddirectory(const char* filename, char* longFilename) {
  1220. card.chdir(filename);
  1221. encoderPosition = 0;
  1222. }
  1223. static void menu_action_setting_edit_bool(const char* pstr, bool* ptr) { *ptr = !(*ptr); }
  1224. static void menu_action_setting_edit_callback_bool(const char* pstr, bool* ptr, menuFunc_t callback) {
  1225. menu_action_setting_edit_bool(pstr, ptr);
  1226. (*callback)();
  1227. }
  1228. #endif //ULTIPANEL
  1229. /** LCD API **/
  1230. void lcd_init() {
  1231. lcd_implementation_init();
  1232. #ifdef NEWPANEL
  1233. SET_INPUT(BTN_EN1);
  1234. SET_INPUT(BTN_EN2);
  1235. WRITE(BTN_EN1,HIGH);
  1236. WRITE(BTN_EN2,HIGH);
  1237. #if BTN_ENC > 0
  1238. SET_INPUT(BTN_ENC);
  1239. WRITE(BTN_ENC,HIGH);
  1240. #endif
  1241. #ifdef REPRAPWORLD_KEYPAD
  1242. pinMode(SHIFT_CLK,OUTPUT);
  1243. pinMode(SHIFT_LD,OUTPUT);
  1244. pinMode(SHIFT_OUT,INPUT);
  1245. WRITE(SHIFT_OUT,HIGH);
  1246. WRITE(SHIFT_LD,HIGH);
  1247. #endif
  1248. #else // Not NEWPANEL
  1249. #ifdef SR_LCD_2W_NL // Non latching 2 wire shift register
  1250. pinMode (SR_DATA_PIN, OUTPUT);
  1251. pinMode (SR_CLK_PIN, OUTPUT);
  1252. #elif defined(SHIFT_CLK)
  1253. pinMode(SHIFT_CLK,OUTPUT);
  1254. pinMode(SHIFT_LD,OUTPUT);
  1255. pinMode(SHIFT_EN,OUTPUT);
  1256. pinMode(SHIFT_OUT,INPUT);
  1257. WRITE(SHIFT_OUT,HIGH);
  1258. WRITE(SHIFT_LD,HIGH);
  1259. WRITE(SHIFT_EN,LOW);
  1260. #endif // SR_LCD_2W_NL
  1261. #endif//!NEWPANEL
  1262. #if defined(SDSUPPORT) && defined(SDCARDDETECT) && (SDCARDDETECT > 0)
  1263. pinMode(SDCARDDETECT, INPUT);
  1264. WRITE(SDCARDDETECT, HIGH);
  1265. lcd_oldcardstatus = IS_SD_INSERTED;
  1266. #endif //(SDCARDDETECT > 0)
  1267. #ifdef LCD_HAS_SLOW_BUTTONS
  1268. slow_buttons = 0;
  1269. #endif
  1270. lcd_buttons_update();
  1271. #ifdef ULTIPANEL
  1272. encoderDiff = 0;
  1273. #endif
  1274. }
  1275. int lcd_strlen(char *s) {
  1276. int i = 0, j = 0;
  1277. while (s[i]) {
  1278. if ((s[i] & 0xc0) != 0x80) j++;
  1279. i++;
  1280. }
  1281. return j;
  1282. }
  1283. int lcd_strlen_P(const char *s) {
  1284. int j = 0;
  1285. while (pgm_read_byte(s)) {
  1286. if ((pgm_read_byte(s) & 0xc0) != 0x80) j++;
  1287. s++;
  1288. }
  1289. return j;
  1290. }
  1291. /**
  1292. * Update the LCD, read encoder buttons, etc.
  1293. * - Read button states
  1294. * - Check the SD Card slot state
  1295. * - Act on RepRap World keypad input
  1296. * - Update the encoder position
  1297. * - Apply acceleration to the encoder position
  1298. * - Reset the Info Screen timeout if there's any input
  1299. * - Update status indicators, if any
  1300. * - Clear the LCD if lcdDrawUpdate == 2
  1301. *
  1302. * Warning: This function is called from interrupt context!
  1303. */
  1304. void lcd_update() {
  1305. #ifdef ULTIPANEL
  1306. static millis_t return_to_status_ms = 0;
  1307. #endif
  1308. #ifdef LCD_HAS_SLOW_BUTTONS
  1309. slow_buttons = lcd_implementation_read_slow_buttons(); // buttons which take too long to read in interrupt context
  1310. #endif
  1311. lcd_buttons_update();
  1312. #if (SDCARDDETECT > 0)
  1313. if (IS_SD_INSERTED != lcd_oldcardstatus && lcd_detected()) {
  1314. lcdDrawUpdate = 2;
  1315. lcd_oldcardstatus = IS_SD_INSERTED;
  1316. lcd_implementation_init( // to maybe revive the LCD if static electricity killed it.
  1317. #ifdef LCD_PROGRESS_BAR
  1318. currentMenu == lcd_status_screen
  1319. #endif
  1320. );
  1321. if (lcd_oldcardstatus) {
  1322. card.initsd();
  1323. LCD_MESSAGEPGM(MSG_SD_INSERTED);
  1324. }
  1325. else {
  1326. card.release();
  1327. LCD_MESSAGEPGM(MSG_SD_REMOVED);
  1328. }
  1329. }
  1330. #endif//CARDINSERTED
  1331. millis_t ms = millis();
  1332. if (ms > next_lcd_update_ms) {
  1333. #ifdef ULTIPANEL
  1334. #ifdef REPRAPWORLD_KEYPAD
  1335. if (REPRAPWORLD_KEYPAD_MOVE_Z_UP) reprapworld_keypad_move_z_up();
  1336. if (REPRAPWORLD_KEYPAD_MOVE_Z_DOWN) reprapworld_keypad_move_z_down();
  1337. if (REPRAPWORLD_KEYPAD_MOVE_X_LEFT) reprapworld_keypad_move_x_left();
  1338. if (REPRAPWORLD_KEYPAD_MOVE_X_RIGHT) reprapworld_keypad_move_x_right();
  1339. if (REPRAPWORLD_KEYPAD_MOVE_Y_DOWN) reprapworld_keypad_move_y_down();
  1340. if (REPRAPWORLD_KEYPAD_MOVE_Y_UP) reprapworld_keypad_move_y_up();
  1341. if (REPRAPWORLD_KEYPAD_MOVE_HOME) reprapworld_keypad_move_home();
  1342. #endif
  1343. bool encoderPastThreshold = (abs(encoderDiff) >= ENCODER_PULSES_PER_STEP);
  1344. if (encoderPastThreshold || LCD_CLICKED) {
  1345. if (encoderPastThreshold) {
  1346. int32_t encoderMultiplier = 1;
  1347. #ifdef ENCODER_RATE_MULTIPLIER
  1348. if (encoderRateMultiplierEnabled) {
  1349. int32_t encoderMovementSteps = abs(encoderDiff) / ENCODER_PULSES_PER_STEP;
  1350. if (lastEncoderMovementMillis != 0) {
  1351. // Note that the rate is always calculated between to passes through the
  1352. // loop and that the abs of the encoderDiff value is tracked.
  1353. float encoderStepRate = (float)(encoderMovementSteps) / ((float)(ms - lastEncoderMovementMillis)) * 1000.0;
  1354. if (encoderStepRate >= ENCODER_100X_STEPS_PER_SEC) encoderMultiplier = 100;
  1355. else if (encoderStepRate >= ENCODER_10X_STEPS_PER_SEC) encoderMultiplier = 10;
  1356. #ifdef ENCODER_RATE_MULTIPLIER_DEBUG
  1357. SERIAL_ECHO_START;
  1358. SERIAL_ECHO("Enc Step Rate: ");
  1359. SERIAL_ECHO(encoderStepRate);
  1360. SERIAL_ECHO(" Multiplier: ");
  1361. SERIAL_ECHO(encoderMultiplier);
  1362. SERIAL_ECHO(" ENCODER_10X_STEPS_PER_SEC: ");
  1363. SERIAL_ECHO(ENCODER_10X_STEPS_PER_SEC);
  1364. SERIAL_ECHO(" ENCODER_100X_STEPS_PER_SEC: ");
  1365. SERIAL_ECHOLN(ENCODER_100X_STEPS_PER_SEC);
  1366. #endif //ENCODER_RATE_MULTIPLIER_DEBUG
  1367. }
  1368. lastEncoderMovementMillis = ms;
  1369. } // encoderRateMultiplierEnabled
  1370. #endif //ENCODER_RATE_MULTIPLIER
  1371. encoderPosition += (encoderDiff * encoderMultiplier) / ENCODER_PULSES_PER_STEP;
  1372. encoderDiff = 0;
  1373. }
  1374. return_to_status_ms = ms + LCD_TIMEOUT_TO_STATUS;
  1375. lcdDrawUpdate = 1;
  1376. }
  1377. #endif //ULTIPANEL
  1378. if (currentMenu == lcd_status_screen) {
  1379. if (!lcd_status_update_delay) {
  1380. lcdDrawUpdate = 1;
  1381. 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 */
  1382. }
  1383. else {
  1384. lcd_status_update_delay--;
  1385. }
  1386. }
  1387. #ifdef DOGLCD // Changes due to different driver architecture of the DOGM display
  1388. if (lcdDrawUpdate) {
  1389. blink++; // Variable for fan animation and alive dot
  1390. u8g.firstPage();
  1391. do {
  1392. lcd_setFont(FONT_MENU);
  1393. u8g.setPrintPos(125, 0);
  1394. if (blink % 2) u8g.setColorIndex(1); else u8g.setColorIndex(0); // Set color for the alive dot
  1395. u8g.drawPixel(127, 63); // draw alive dot
  1396. u8g.setColorIndex(1); // black on white
  1397. (*currentMenu)();
  1398. } while( u8g.nextPage() );
  1399. }
  1400. #else
  1401. (*currentMenu)();
  1402. #endif
  1403. #ifdef LCD_HAS_STATUS_INDICATORS
  1404. lcd_implementation_update_indicators();
  1405. #endif
  1406. #ifdef ULTIPANEL
  1407. // Return to Status Screen after a timeout
  1408. if (currentMenu != lcd_status_screen &&
  1409. #ifdef MANUAL_BED_LEVELING
  1410. currentMenu != _lcd_level_bed &&
  1411. currentMenu != _lcd_level_bed_homing &&
  1412. #endif
  1413. millis() > return_to_status_ms
  1414. ) {
  1415. lcd_return_to_status();
  1416. lcdDrawUpdate = 2;
  1417. }
  1418. #endif // ULTIPANEL
  1419. if (lcdDrawUpdate == 2) lcd_implementation_clear();
  1420. if (lcdDrawUpdate) lcdDrawUpdate--;
  1421. next_lcd_update_ms = ms + LCD_UPDATE_INTERVAL;
  1422. }
  1423. }
  1424. void lcd_ignore_click(bool b) {
  1425. ignore_click = b;
  1426. wait_for_unclick = false;
  1427. }
  1428. void lcd_finishstatus(bool persist=false) {
  1429. #ifdef LCD_PROGRESS_BAR
  1430. progress_bar_ms = millis();
  1431. #if PROGRESS_MSG_EXPIRE > 0
  1432. expire_status_ms = persist ? 0 : progress_bar_ms + PROGRESS_MSG_EXPIRE;
  1433. #endif
  1434. #endif
  1435. lcdDrawUpdate = 2;
  1436. #ifdef FILAMENT_LCD_DISPLAY
  1437. previous_lcd_status_ms = millis(); //get status message to show up for a while
  1438. #endif
  1439. }
  1440. #if defined(LCD_PROGRESS_BAR) && PROGRESS_MSG_EXPIRE > 0
  1441. void dontExpireStatus() { expire_status_ms = 0; }
  1442. #endif
  1443. void set_utf_strlen(char *s, uint8_t n) {
  1444. uint8_t i = 0, j = 0;
  1445. while (s[i] && (j < n)) {
  1446. if ((s[i] & 0xc0u) != 0x80u) j++;
  1447. i++;
  1448. }
  1449. while (j++ < n) s[i++] = ' ';
  1450. s[i] = 0;
  1451. }
  1452. bool lcd_hasstatus() { return (lcd_status_message[0] != '\0'); }
  1453. void lcd_setstatus(const char* message, bool persist) {
  1454. if (lcd_status_message_level > 0) return;
  1455. strncpy(lcd_status_message, message, 3*LCD_WIDTH);
  1456. set_utf_strlen(lcd_status_message, LCD_WIDTH);
  1457. lcd_finishstatus(persist);
  1458. }
  1459. void lcd_setstatuspgm(const char* message, uint8_t level) {
  1460. if (level >= lcd_status_message_level) {
  1461. strncpy_P(lcd_status_message, message, 3*LCD_WIDTH);
  1462. set_utf_strlen(lcd_status_message, LCD_WIDTH);
  1463. lcd_status_message_level = level;
  1464. lcd_finishstatus(level > 0);
  1465. }
  1466. }
  1467. void lcd_setalertstatuspgm(const char* message) {
  1468. lcd_setstatuspgm(message, 1);
  1469. #ifdef ULTIPANEL
  1470. lcd_return_to_status();
  1471. #endif
  1472. }
  1473. void lcd_reset_alert_level() { lcd_status_message_level = 0; }
  1474. #ifdef HAS_LCD_CONTRAST
  1475. void lcd_setcontrast(uint8_t value) {
  1476. lcd_contrast = value & 0x3F;
  1477. u8g.setContrast(lcd_contrast);
  1478. }
  1479. #endif
  1480. #ifdef ULTIPANEL
  1481. /**
  1482. * Setup Rotary Encoder Bit Values (for two pin encoders to indicate movement)
  1483. * These values are independent of which pins are used for EN_A and EN_B indications
  1484. * The rotary encoder part is also independent to the chipset used for the LCD
  1485. */
  1486. #if defined(EN_A) && defined(EN_B)
  1487. #define encrot0 0
  1488. #define encrot1 2
  1489. #define encrot2 3
  1490. #define encrot3 1
  1491. #endif
  1492. /**
  1493. * Read encoder buttons from the hardware registers
  1494. * Warning: This function is called from interrupt context!
  1495. */
  1496. void lcd_buttons_update() {
  1497. #ifdef NEWPANEL
  1498. uint8_t newbutton = 0;
  1499. if (READ(BTN_EN1) == 0) newbutton |= EN_A;
  1500. if (READ(BTN_EN2) == 0) newbutton |= EN_B;
  1501. #if BTN_ENC > 0
  1502. if (millis() > next_button_update_ms && READ(BTN_ENC) == 0) newbutton |= EN_C;
  1503. #endif
  1504. buttons = newbutton;
  1505. #ifdef LCD_HAS_SLOW_BUTTONS
  1506. buttons |= slow_buttons;
  1507. #endif
  1508. #ifdef REPRAPWORLD_KEYPAD
  1509. // for the reprapworld_keypad
  1510. uint8_t newbutton_reprapworld_keypad=0;
  1511. WRITE(SHIFT_LD, LOW);
  1512. WRITE(SHIFT_LD, HIGH);
  1513. for(int8_t i = 0; i < 8; i++) {
  1514. newbutton_reprapworld_keypad >>= 1;
  1515. if (READ(SHIFT_OUT)) newbutton_reprapworld_keypad |= BIT(7);
  1516. WRITE(SHIFT_CLK, HIGH);
  1517. WRITE(SHIFT_CLK, LOW);
  1518. }
  1519. buttons_reprapworld_keypad=~newbutton_reprapworld_keypad; //invert it, because a pressed switch produces a logical 0
  1520. #endif
  1521. #else //read it from the shift register
  1522. uint8_t newbutton = 0;
  1523. WRITE(SHIFT_LD, LOW);
  1524. WRITE(SHIFT_LD, HIGH);
  1525. unsigned char tmp_buttons = 0;
  1526. for(int8_t i=0; i<8; i++) {
  1527. newbutton >>= 1;
  1528. if (READ(SHIFT_OUT)) newbutton |= BIT(7);
  1529. WRITE(SHIFT_CLK, HIGH);
  1530. WRITE(SHIFT_CLK, LOW);
  1531. }
  1532. buttons = ~newbutton; //invert it, because a pressed switch produces a logical 0
  1533. #endif //!NEWPANEL
  1534. //manage encoder rotation
  1535. uint8_t enc=0;
  1536. if (buttons & EN_A) enc |= B01;
  1537. if (buttons & EN_B) enc |= B10;
  1538. if (enc != lastEncoderBits) {
  1539. switch(enc) {
  1540. case encrot0:
  1541. if (lastEncoderBits==encrot3) encoderDiff++;
  1542. else if (lastEncoderBits==encrot1) encoderDiff--;
  1543. break;
  1544. case encrot1:
  1545. if (lastEncoderBits==encrot0) encoderDiff++;
  1546. else if (lastEncoderBits==encrot2) encoderDiff--;
  1547. break;
  1548. case encrot2:
  1549. if (lastEncoderBits==encrot1) encoderDiff++;
  1550. else if (lastEncoderBits==encrot3) encoderDiff--;
  1551. break;
  1552. case encrot3:
  1553. if (lastEncoderBits==encrot2) encoderDiff++;
  1554. else if (lastEncoderBits==encrot0) encoderDiff--;
  1555. break;
  1556. }
  1557. }
  1558. lastEncoderBits = enc;
  1559. }
  1560. bool lcd_detected(void) {
  1561. #if (defined(LCD_I2C_TYPE_MCP23017) || defined(LCD_I2C_TYPE_MCP23008)) && defined(DETECT_DEVICE)
  1562. return lcd.LcdDetected() == 1;
  1563. #else
  1564. return true;
  1565. #endif
  1566. }
  1567. void lcd_buzz(long duration, uint16_t freq) {
  1568. if (freq > 0) {
  1569. #ifdef LCD_USE_I2C_BUZZER
  1570. lcd.buzz(duration, freq);
  1571. #elif defined(BEEPER) && BEEPER >= 0
  1572. SET_OUTPUT(BEEPER);
  1573. tone(BEEPER, freq, duration);
  1574. delay(duration);
  1575. #else
  1576. delay(duration);
  1577. #endif
  1578. }
  1579. else {
  1580. delay(duration);
  1581. }
  1582. }
  1583. bool lcd_clicked() { return LCD_CLICKED; }
  1584. #endif // ULTIPANEL
  1585. /*********************************/
  1586. /** Number to string conversion **/
  1587. /*********************************/
  1588. char conv[8];
  1589. // Convert float to string with +123.4 format
  1590. char *ftostr3(const float &x) {
  1591. return itostr3((int)x);
  1592. }
  1593. // Convert int to string with 12 format
  1594. char *itostr2(const uint8_t &x) {
  1595. //sprintf(conv,"%5.1f",x);
  1596. int xx = x;
  1597. conv[0] = (xx / 10) % 10 + '0';
  1598. conv[1] = xx % 10 + '0';
  1599. conv[2] = 0;
  1600. return conv;
  1601. }
  1602. // Convert float to string with +123.4 format
  1603. char *ftostr31(const float &x) {
  1604. int xx = abs(x * 10);
  1605. conv[0] = (x >= 0) ? '+' : '-';
  1606. conv[1] = (xx / 1000) % 10 + '0';
  1607. conv[2] = (xx / 100) % 10 + '0';
  1608. conv[3] = (xx / 10) % 10 + '0';
  1609. conv[4] = '.';
  1610. conv[5] = xx % 10 + '0';
  1611. conv[6] = 0;
  1612. return conv;
  1613. }
  1614. // Convert float to string with 123.4 format, dropping sign
  1615. char *ftostr31ns(const float &x) {
  1616. int xx = abs(x * 10);
  1617. conv[0] = (xx / 1000) % 10 + '0';
  1618. conv[1] = (xx / 100) % 10 + '0';
  1619. conv[2] = (xx / 10) % 10 + '0';
  1620. conv[3] = '.';
  1621. conv[4] = xx % 10 + '0';
  1622. conv[5] = 0;
  1623. return conv;
  1624. }
  1625. // Convert float to string with 123.4 format
  1626. char *ftostr32(const float &x) {
  1627. long xx = abs(x * 100);
  1628. conv[0] = x >= 0 ? (xx / 10000) % 10 + '0' : '-';
  1629. conv[1] = (xx / 1000) % 10 + '0';
  1630. conv[2] = (xx / 100) % 10 + '0';
  1631. conv[3] = '.';
  1632. conv[4] = (xx / 10) % 10 + '0';
  1633. conv[5] = xx % 10 + '0';
  1634. conv[6] = 0;
  1635. return conv;
  1636. }
  1637. // Convert float to string with 1.234 format
  1638. char *ftostr43(const float &x) {
  1639. long xx = x * 1000;
  1640. if (xx >= 0)
  1641. conv[0] = (xx / 1000) % 10 + '0';
  1642. else
  1643. conv[0] = '-';
  1644. xx = abs(xx);
  1645. conv[1] = '.';
  1646. conv[2] = (xx / 100) % 10 + '0';
  1647. conv[3] = (xx / 10) % 10 + '0';
  1648. conv[4] = (xx) % 10 + '0';
  1649. conv[5] = 0;
  1650. return conv;
  1651. }
  1652. // Convert float to string with 1.23 format
  1653. char *ftostr12ns(const float &x) {
  1654. long xx=x*100;
  1655. xx=abs(xx);
  1656. conv[0]=(xx/100)%10+'0';
  1657. conv[1]='.';
  1658. conv[2]=(xx/10)%10+'0';
  1659. conv[3]=(xx)%10+'0';
  1660. conv[4]=0;
  1661. return conv;
  1662. }
  1663. // Convert float to space-padded string with -_23.4_ format
  1664. char *ftostr32sp(const float &x) {
  1665. long xx = abs(x * 100);
  1666. uint8_t dig;
  1667. if (x < 0) { // negative val = -_0
  1668. conv[0] = '-';
  1669. dig = (xx / 1000) % 10;
  1670. conv[1] = dig ? '0' + dig : ' ';
  1671. }
  1672. else { // positive val = __0
  1673. dig = (xx / 10000) % 10;
  1674. if (dig) {
  1675. conv[0] = '0' + dig;
  1676. conv[1] = '0' + (xx / 1000) % 10;
  1677. }
  1678. else {
  1679. conv[0] = ' ';
  1680. dig = (xx / 1000) % 10;
  1681. conv[1] = dig ? '0' + dig : ' ';
  1682. }
  1683. }
  1684. conv[2] = '0' + (xx / 100) % 10; // lsd always
  1685. dig = xx % 10;
  1686. if (dig) { // 2 decimal places
  1687. conv[5] = '0' + dig;
  1688. conv[4] = '0' + (xx / 10) % 10;
  1689. conv[3] = '.';
  1690. }
  1691. else { // 1 or 0 decimal place
  1692. dig = (xx / 10) % 10;
  1693. if (dig) {
  1694. conv[4] = '0' + dig;
  1695. conv[3] = '.';
  1696. }
  1697. else {
  1698. conv[3] = conv[4] = ' ';
  1699. }
  1700. conv[5] = ' ';
  1701. }
  1702. conv[6] = '\0';
  1703. return conv;
  1704. }
  1705. // Convert int to lj string with +123.0 format
  1706. char *itostr31(const int &x) {
  1707. conv[0] = x >= 0 ? '+' : '-';
  1708. int xx = abs(x);
  1709. conv[1] = (xx / 100) % 10 + '0';
  1710. conv[2] = (xx / 10) % 10 + '0';
  1711. conv[3] = xx % 10 + '0';
  1712. conv[4] = '.';
  1713. conv[5] = '0';
  1714. conv[6] = 0;
  1715. return conv;
  1716. }
  1717. // Convert int to rj string with 123 or -12 format
  1718. char *itostr3(const int &x) {
  1719. int xx = x;
  1720. if (xx < 0) {
  1721. conv[0] = '-';
  1722. xx = -xx;
  1723. }
  1724. else
  1725. conv[0] = xx >= 100 ? (xx / 100) % 10 + '0' : ' ';
  1726. conv[1] = xx >= 10 ? (xx / 10) % 10 + '0' : ' ';
  1727. conv[2] = xx % 10 + '0';
  1728. conv[3] = 0;
  1729. return conv;
  1730. }
  1731. // Convert int to lj string with 123 format
  1732. char *itostr3left(const int &xx) {
  1733. if (xx >= 100) {
  1734. conv[0] = (xx / 100) % 10 + '0';
  1735. conv[1] = (xx / 10) % 10 + '0';
  1736. conv[2] = xx % 10 + '0';
  1737. conv[3] = 0;
  1738. }
  1739. else if (xx >= 10) {
  1740. conv[0] = (xx / 10) % 10 + '0';
  1741. conv[1] = xx % 10 + '0';
  1742. conv[2] = 0;
  1743. }
  1744. else {
  1745. conv[0] = xx % 10 + '0';
  1746. conv[1] = 0;
  1747. }
  1748. return conv;
  1749. }
  1750. // Convert int to rj string with 1234 format
  1751. char *itostr4(const int &xx) {
  1752. conv[0] = xx >= 1000 ? (xx / 1000) % 10 + '0' : ' ';
  1753. conv[1] = xx >= 100 ? (xx / 100) % 10 + '0' : ' ';
  1754. conv[2] = xx >= 10 ? (xx / 10) % 10 + '0' : ' ';
  1755. conv[3] = xx % 10 + '0';
  1756. conv[4] = 0;
  1757. return conv;
  1758. }
  1759. // Convert float to rj string with 12345 format
  1760. char *ftostr5(const float &x) {
  1761. long xx = abs(x);
  1762. conv[0] = xx >= 10000 ? (xx / 10000) % 10 + '0' : ' ';
  1763. conv[1] = xx >= 1000 ? (xx / 1000) % 10 + '0' : ' ';
  1764. conv[2] = xx >= 100 ? (xx / 100) % 10 + '0' : ' ';
  1765. conv[3] = xx >= 10 ? (xx / 10) % 10 + '0' : ' ';
  1766. conv[4] = xx % 10 + '0';
  1767. conv[5] = 0;
  1768. return conv;
  1769. }
  1770. // Convert float to string with +1234.5 format
  1771. char *ftostr51(const float &x) {
  1772. long xx = abs(x * 10);
  1773. conv[0] = (x >= 0) ? '+' : '-';
  1774. conv[1] = (xx / 10000) % 10 + '0';
  1775. conv[2] = (xx / 1000) % 10 + '0';
  1776. conv[3] = (xx / 100) % 10 + '0';
  1777. conv[4] = (xx / 10) % 10 + '0';
  1778. conv[5] = '.';
  1779. conv[6] = xx % 10 + '0';
  1780. conv[7] = 0;
  1781. return conv;
  1782. }
  1783. // Convert float to string with +123.45 format
  1784. char *ftostr52(const float &x) {
  1785. conv[0] = (x >= 0) ? '+' : '-';
  1786. long xx = abs(x * 100);
  1787. conv[1] = (xx / 10000) % 10 + '0';
  1788. conv[2] = (xx / 1000) % 10 + '0';
  1789. conv[3] = (xx / 100) % 10 + '0';
  1790. conv[4] = '.';
  1791. conv[5] = (xx / 10) % 10 + '0';
  1792. conv[6] = xx % 10 + '0';
  1793. conv[7] = 0;
  1794. return conv;
  1795. }
  1796. #ifdef MANUAL_BED_LEVELING
  1797. static int _lcd_level_bed_position;
  1798. /**
  1799. * MBL Wait for controller movement and clicks:
  1800. * - Movement adjusts the Z axis
  1801. * - Click saves the Z and goes to the next mesh point
  1802. */
  1803. static void _lcd_level_bed() {
  1804. if (encoderPosition != 0) {
  1805. refresh_cmd_timeout();
  1806. current_position[Z_AXIS] += float((int)encoderPosition) * MBL_Z_STEP;
  1807. if (min_software_endstops && current_position[Z_AXIS] < Z_MIN_POS) current_position[Z_AXIS] = Z_MIN_POS;
  1808. if (max_software_endstops && current_position[Z_AXIS] > Z_MAX_POS) current_position[Z_AXIS] = Z_MAX_POS;
  1809. encoderPosition = 0;
  1810. line_to_current(Z_AXIS);
  1811. lcdDrawUpdate = 2;
  1812. }
  1813. if (lcdDrawUpdate) lcd_implementation_drawedit(PSTR("Z"), ftostr43(current_position[Z_AXIS]));
  1814. static bool debounce_click = false;
  1815. if (LCD_CLICKED) {
  1816. if (!debounce_click) {
  1817. debounce_click = true;
  1818. int ix = _lcd_level_bed_position % MESH_NUM_X_POINTS,
  1819. iy = _lcd_level_bed_position / MESH_NUM_X_POINTS;
  1820. if (iy & 1) ix = (MESH_NUM_X_POINTS - 1) - ix; // Zig zag
  1821. mbl.set_z(ix, iy, current_position[Z_AXIS]);
  1822. _lcd_level_bed_position++;
  1823. if (_lcd_level_bed_position == MESH_NUM_X_POINTS*MESH_NUM_Y_POINTS) {
  1824. current_position[Z_AXIS] = MESH_HOME_SEARCH_Z;
  1825. line_to_current(Z_AXIS);
  1826. mbl.active = 1;
  1827. enqueuecommands_P(PSTR("G28"));
  1828. lcd_return_to_status();
  1829. }
  1830. else {
  1831. current_position[Z_AXIS] = MESH_HOME_SEARCH_Z;
  1832. line_to_current(Z_AXIS);
  1833. ix = _lcd_level_bed_position % MESH_NUM_X_POINTS;
  1834. iy = _lcd_level_bed_position / MESH_NUM_X_POINTS;
  1835. if (iy & 1) ix = (MESH_NUM_X_POINTS - 1) - ix; // Zig zag
  1836. current_position[X_AXIS] = mbl.get_x(ix);
  1837. current_position[Y_AXIS] = mbl.get_y(iy);
  1838. line_to_current(manual_feedrate[X_AXIS] <= manual_feedrate[Y_AXIS] ? X_AXIS : Y_AXIS);
  1839. lcdDrawUpdate = 2;
  1840. }
  1841. }
  1842. }
  1843. else {
  1844. debounce_click = false;
  1845. }
  1846. }
  1847. /**
  1848. * MBL Move to mesh starting point
  1849. */
  1850. static void _lcd_level_bed_homing() {
  1851. if (lcdDrawUpdate) lcd_implementation_drawedit(PSTR("XYZ"), "Homing");
  1852. if (axis_known_position[X_AXIS] && axis_known_position[Y_AXIS] && axis_known_position[Z_AXIS]) {
  1853. current_position[Z_AXIS] = MESH_HOME_SEARCH_Z;
  1854. plan_set_position(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], current_position[E_AXIS]);
  1855. current_position[X_AXIS] = MESH_MIN_X;
  1856. current_position[Y_AXIS] = MESH_MIN_Y;
  1857. line_to_current(manual_feedrate[X_AXIS] <= manual_feedrate[Y_AXIS] ? X_AXIS : Y_AXIS);
  1858. _lcd_level_bed_position = 0;
  1859. lcd_goto_menu(_lcd_level_bed);
  1860. }
  1861. lcdDrawUpdate = 2;
  1862. }
  1863. /**
  1864. * MBL entry-point
  1865. */
  1866. static void lcd_level_bed() {
  1867. axis_known_position[X_AXIS] = axis_known_position[Y_AXIS] = axis_known_position[Z_AXIS] = false;
  1868. mbl.reset();
  1869. enqueuecommands_P(PSTR("G28"));
  1870. lcdDrawUpdate = 2;
  1871. lcd_goto_menu(_lcd_level_bed_homing);
  1872. }
  1873. #endif // MANUAL_BED_LEVELING
  1874. #endif // ULTRA_LCD