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

ultralcd.cpp 66KB

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