My Marlin configs for Fabrikator Mini and CTC i3 Pro B
Du kannst nicht mehr als 25 Themen auswählen Themen müssen mit entweder einem Buchstaben oder einer Ziffer beginnen. Sie können Bindestriche („-“) enthalten und bis zu 35 Zeichen lang sein.

ultralcd.cpp 69KB

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