My Marlin configs for Fabrikator Mini and CTC i3 Pro B
Nevar pievienot vairāk kā 25 tēmas Tēmai ir jāsākas ar burtu vai ciparu, tā var saturēt domu zīmes ('-') un var būt līdz 35 simboliem gara.

ultralcd_impl_HD44780.h 50KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535
  1. /**
  2. * Marlin 3D Printer Firmware
  3. * Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
  4. *
  5. * Based on Sprinter and grbl.
  6. * Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm
  7. *
  8. * This program is free software: you can redistribute it and/or modify
  9. * it under the terms of the GNU General Public License as published by
  10. * the Free Software Foundation, either version 3 of the License, or
  11. * (at your option) any later version.
  12. *
  13. * This program is distributed in the hope that it will be useful,
  14. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  16. * GNU General Public License for more details.
  17. *
  18. * You should have received a copy of the GNU General Public License
  19. * along with this program. If not, see <http://www.gnu.org/licenses/>.
  20. *
  21. */
  22. #ifndef ULTRALCD_IMPL_HD44780_H
  23. #define ULTRALCD_IMPL_HD44780_H
  24. /**
  25. * Implementation of the LCD display routines for a Hitachi HD44780 display.
  26. * These are the most common LCD character displays.
  27. */
  28. #include "utility.h"
  29. #include "duration_t.h"
  30. #if ENABLED(AUTO_BED_LEVELING_UBL)
  31. #include "ubl.h"
  32. #if ENABLED(ULTIPANEL)
  33. #define ULTRA_X_PIXELS_PER_CHAR 5
  34. #define ULTRA_Y_PIXELS_PER_CHAR 8
  35. #define ULTRA_COLUMNS_FOR_MESH_MAP 7
  36. #define ULTRA_ROWS_FOR_MESH_MAP 4
  37. #define N_USER_CHARS 8
  38. #define TOP_LEFT _BV(0)
  39. #define TOP_RIGHT _BV(1)
  40. #define LOWER_LEFT _BV(2)
  41. #define LOWER_RIGHT _BV(3)
  42. #endif
  43. #endif
  44. extern volatile uint8_t buttons; //an extended version of the last checked buttons in a bit array.
  45. ////////////////////////////////////
  46. // Setup button and encode mappings for each panel (into 'buttons' variable
  47. //
  48. // This is just to map common functions (across different panels) onto the same
  49. // macro name. The mapping is independent of whether the button is directly connected or
  50. // via a shift/i2c register.
  51. #if ENABLED(ULTIPANEL)
  52. //
  53. // Setup other button mappings of each panel
  54. //
  55. #if ENABLED(LCD_I2C_VIKI)
  56. #define B_I2C_BTN_OFFSET 3 // (the first three bit positions reserved for EN_A, EN_B, EN_C)
  57. // button and encoder bit positions within 'buttons'
  58. #define B_LE (BUTTON_LEFT<<B_I2C_BTN_OFFSET) // The remaining normalized buttons are all read via I2C
  59. #define B_UP (BUTTON_UP<<B_I2C_BTN_OFFSET)
  60. #define B_MI (BUTTON_SELECT<<B_I2C_BTN_OFFSET)
  61. #define B_DW (BUTTON_DOWN<<B_I2C_BTN_OFFSET)
  62. #define B_RI (BUTTON_RIGHT<<B_I2C_BTN_OFFSET)
  63. #if BUTTON_EXISTS(ENC)
  64. // the pause/stop/restart button is connected to BTN_ENC when used
  65. #define B_ST (EN_C) // Map the pause/stop/resume button into its normalized functional name
  66. #undef LCD_CLICKED
  67. #define LCD_CLICKED (buttons&(B_MI|B_RI|B_ST)) // pause/stop button also acts as click until we implement proper pause/stop.
  68. #else
  69. #undef LCD_CLICKED
  70. #define LCD_CLICKED (buttons&(B_MI|B_RI))
  71. #endif
  72. // I2C buttons take too long to read inside an interrupt context and so we read them during lcd_update
  73. #define LCD_HAS_SLOW_BUTTONS
  74. #elif ENABLED(LCD_I2C_PANELOLU2)
  75. #if !BUTTON_EXISTS(ENC) // Use I2C if not directly connected to a pin
  76. #define B_I2C_BTN_OFFSET 3 // (the first three bit positions reserved for EN_A, EN_B, EN_C)
  77. #define B_MI (PANELOLU2_ENCODER_C<<B_I2C_BTN_OFFSET) // requires LiquidTWI2 library v1.2.3 or later
  78. #undef LCD_CLICKED
  79. #define LCD_CLICKED (buttons & B_MI)
  80. // I2C buttons take too long to read inside an interrupt context and so we read them during lcd_update
  81. #define LCD_HAS_SLOW_BUTTONS
  82. #endif
  83. #elif DISABLED(NEWPANEL) // old style ULTIPANEL
  84. // Shift register bits correspond to buttons:
  85. #define BL_LE 7 // Left
  86. #define BL_UP 6 // Up
  87. #define BL_MI 5 // Middle
  88. #define BL_DW 4 // Down
  89. #define BL_RI 3 // Right
  90. #define BL_ST 2 // Red Button
  91. #define B_LE (_BV(BL_LE))
  92. #define B_UP (_BV(BL_UP))
  93. #define B_MI (_BV(BL_MI))
  94. #define B_DW (_BV(BL_DW))
  95. #define B_RI (_BV(BL_RI))
  96. #define B_ST (_BV(BL_ST))
  97. #define LCD_CLICKED ((buttons & B_MI) || (buttons & B_ST))
  98. #endif
  99. #endif // ULTIPANEL
  100. ////////////////////////////////////
  101. // Create LCD class instance and chipset-specific information
  102. #if ENABLED(LCD_I2C_TYPE_PCF8575)
  103. // note: these are register mapped pins on the PCF8575 controller not Arduino pins
  104. #define LCD_I2C_PIN_BL 3
  105. #define LCD_I2C_PIN_EN 2
  106. #define LCD_I2C_PIN_RW 1
  107. #define LCD_I2C_PIN_RS 0
  108. #define LCD_I2C_PIN_D4 4
  109. #define LCD_I2C_PIN_D5 5
  110. #define LCD_I2C_PIN_D6 6
  111. #define LCD_I2C_PIN_D7 7
  112. #include <Wire.h>
  113. #include <LCD.h>
  114. #include <LiquidCrystal_I2C.h>
  115. #define LCD_CLASS LiquidCrystal_I2C
  116. LCD_CLASS lcd(LCD_I2C_ADDRESS, LCD_I2C_PIN_EN, LCD_I2C_PIN_RW, LCD_I2C_PIN_RS, LCD_I2C_PIN_D4, LCD_I2C_PIN_D5, LCD_I2C_PIN_D6, LCD_I2C_PIN_D7);
  117. #elif ENABLED(LCD_I2C_TYPE_MCP23017)
  118. //for the LED indicators (which maybe mapped to different things in lcd_implementation_update_indicators())
  119. #define LED_A 0x04 //100
  120. #define LED_B 0x02 //010
  121. #define LED_C 0x01 //001
  122. #define LCD_HAS_STATUS_INDICATORS
  123. #include <Wire.h>
  124. #include <LiquidTWI2.h>
  125. #define LCD_CLASS LiquidTWI2
  126. #if ENABLED(DETECT_DEVICE)
  127. LCD_CLASS lcd(LCD_I2C_ADDRESS, 1);
  128. #else
  129. LCD_CLASS lcd(LCD_I2C_ADDRESS);
  130. #endif
  131. #elif ENABLED(LCD_I2C_TYPE_MCP23008)
  132. #include <Wire.h>
  133. #include <LiquidTWI2.h>
  134. #define LCD_CLASS LiquidTWI2
  135. #if ENABLED(DETECT_DEVICE)
  136. LCD_CLASS lcd(LCD_I2C_ADDRESS, 1);
  137. #else
  138. LCD_CLASS lcd(LCD_I2C_ADDRESS);
  139. #endif
  140. #elif ENABLED(LCD_I2C_TYPE_PCA8574)
  141. #include <LiquidCrystal_I2C.h>
  142. #define LCD_CLASS LiquidCrystal_I2C
  143. LCD_CLASS lcd(LCD_I2C_ADDRESS, LCD_WIDTH, LCD_HEIGHT);
  144. // 2 wire Non-latching LCD SR from:
  145. // https://bitbucket.org/fmalpartida/new-liquidcrystal/wiki/schematics#!shiftregister-connection
  146. #elif ENABLED(SR_LCD_2W_NL)
  147. extern "C" void __cxa_pure_virtual() { while (1); }
  148. #include <LCD.h>
  149. #include <LiquidCrystal_SR.h>
  150. #define LCD_CLASS LiquidCrystal_SR
  151. #if PIN_EXISTS(SR_STROBE)
  152. LCD_CLASS lcd(SR_DATA_PIN, SR_CLK_PIN, SR_STROBE_PIN);
  153. #else
  154. LCD_CLASS lcd(SR_DATA_PIN, SR_CLK_PIN);
  155. #endif
  156. #elif ENABLED(LCM1602)
  157. #include <Wire.h>
  158. #include <LCD.h>
  159. #include <LiquidCrystal_I2C.h>
  160. #define LCD_CLASS LiquidCrystal_I2C
  161. LCD_CLASS lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);
  162. #else
  163. // Standard directly connected LCD implementations
  164. #include <LiquidCrystal.h>
  165. #define LCD_CLASS LiquidCrystal
  166. LCD_CLASS lcd(LCD_PINS_RS, LCD_PINS_ENABLE, LCD_PINS_D4, LCD_PINS_D5, LCD_PINS_D6, LCD_PINS_D7); //RS,Enable,D4,D5,D6,D7
  167. #endif
  168. #include "utf_mapper.h"
  169. #if ENABLED(LCD_PROGRESS_BAR)
  170. static millis_t progress_bar_ms = 0;
  171. #if PROGRESS_MSG_EXPIRE > 0
  172. static millis_t expire_status_ms = 0;
  173. #endif
  174. #define LCD_STR_PROGRESS "\x03\x04\x05"
  175. #endif
  176. #if ENABLED(LCD_HAS_STATUS_INDICATORS)
  177. static void lcd_implementation_update_indicators();
  178. #endif
  179. static void createChar_P(const char c, const byte * const ptr) {
  180. byte temp[8];
  181. for (uint8_t i = 0; i < 8; i++)
  182. temp[i] = pgm_read_byte(&ptr[i]);
  183. lcd.createChar(c, temp);
  184. }
  185. static void lcd_set_custom_characters(
  186. #if ENABLED(LCD_PROGRESS_BAR)
  187. const bool info_screen_charset = true
  188. #endif
  189. ) {
  190. const static PROGMEM byte bedTemp[8] = {
  191. B00000,
  192. B11111,
  193. B10101,
  194. B10001,
  195. B10101,
  196. B11111,
  197. B00000,
  198. B00000
  199. };
  200. const static PROGMEM byte degree[8] = {
  201. B01100,
  202. B10010,
  203. B10010,
  204. B01100,
  205. B00000,
  206. B00000,
  207. B00000,
  208. B00000
  209. };
  210. const static PROGMEM byte thermometer[8] = {
  211. B00100,
  212. B01010,
  213. B01010,
  214. B01010,
  215. B01010,
  216. B10001,
  217. B10001,
  218. B01110
  219. };
  220. const static PROGMEM byte uplevel[8] = {
  221. B00100,
  222. B01110,
  223. B11111,
  224. B00100,
  225. B11100,
  226. B00000,
  227. B00000,
  228. B00000
  229. };
  230. const static PROGMEM byte feedrate[8] = {
  231. B11100,
  232. B10000,
  233. B11000,
  234. B10111,
  235. B00101,
  236. B00110,
  237. B00101,
  238. B00000
  239. };
  240. const static PROGMEM byte clock[8] = {
  241. B00000,
  242. B01110,
  243. B10011,
  244. B10101,
  245. B10001,
  246. B01110,
  247. B00000,
  248. B00000
  249. };
  250. #if ENABLED(SDSUPPORT)
  251. const static PROGMEM byte refresh[8] = {
  252. B00000,
  253. B00110,
  254. B11001,
  255. B11000,
  256. B00011,
  257. B10011,
  258. B01100,
  259. B00000,
  260. };
  261. const static PROGMEM byte folder[8] = {
  262. B00000,
  263. B11100,
  264. B11111,
  265. B10001,
  266. B10001,
  267. B11111,
  268. B00000,
  269. B00000
  270. };
  271. #if ENABLED(LCD_PROGRESS_BAR)
  272. const static PROGMEM byte progress[3][8] = { {
  273. B00000,
  274. B10000,
  275. B10000,
  276. B10000,
  277. B10000,
  278. B10000,
  279. B10000,
  280. B00000
  281. }, {
  282. B00000,
  283. B10100,
  284. B10100,
  285. B10100,
  286. B10100,
  287. B10100,
  288. B10100,
  289. B00000
  290. }, {
  291. B00000,
  292. B10101,
  293. B10101,
  294. B10101,
  295. B10101,
  296. B10101,
  297. B10101,
  298. B00000
  299. } };
  300. #endif
  301. #endif
  302. createChar_P(LCD_BEDTEMP_CHAR, bedTemp);
  303. createChar_P(LCD_DEGREE_CHAR, degree);
  304. createChar_P(LCD_STR_THERMOMETER[0], thermometer);
  305. createChar_P(LCD_FEEDRATE_CHAR, feedrate);
  306. createChar_P(LCD_CLOCK_CHAR, clock);
  307. #if ENABLED(SDSUPPORT)
  308. #if ENABLED(LCD_PROGRESS_BAR)
  309. static bool char_mode = false;
  310. if (info_screen_charset != char_mode) {
  311. char_mode = info_screen_charset;
  312. if (info_screen_charset) { // Progress bar characters for info screen
  313. for (int16_t i = 3; i--;) createChar_P(LCD_STR_PROGRESS[i], progress[i]);
  314. }
  315. else { // Custom characters for submenus
  316. createChar_P(LCD_UPLEVEL_CHAR, uplevel);
  317. createChar_P(LCD_STR_REFRESH[0], refresh);
  318. createChar_P(LCD_STR_FOLDER[0], folder);
  319. }
  320. }
  321. #else
  322. createChar_P(LCD_UPLEVEL_CHAR, uplevel);
  323. createChar_P(LCD_STR_REFRESH[0], refresh);
  324. createChar_P(LCD_STR_FOLDER[0], folder);
  325. #endif
  326. #else
  327. createChar_P(LCD_UPLEVEL_CHAR, uplevel);
  328. #endif
  329. }
  330. static void lcd_implementation_init(
  331. #if ENABLED(LCD_PROGRESS_BAR)
  332. const bool info_screen_charset = true
  333. #endif
  334. ) {
  335. #if ENABLED(LCD_I2C_TYPE_PCF8575)
  336. lcd.begin(LCD_WIDTH, LCD_HEIGHT);
  337. #ifdef LCD_I2C_PIN_BL
  338. lcd.setBacklightPin(LCD_I2C_PIN_BL, POSITIVE);
  339. lcd.setBacklight(HIGH);
  340. #endif
  341. #elif ENABLED(LCD_I2C_TYPE_MCP23017)
  342. lcd.setMCPType(LTI_TYPE_MCP23017);
  343. lcd.begin(LCD_WIDTH, LCD_HEIGHT);
  344. lcd_implementation_update_indicators();
  345. #elif ENABLED(LCD_I2C_TYPE_MCP23008)
  346. lcd.setMCPType(LTI_TYPE_MCP23008);
  347. lcd.begin(LCD_WIDTH, LCD_HEIGHT);
  348. #elif ENABLED(LCD_I2C_TYPE_PCA8574)
  349. lcd.init();
  350. lcd.backlight();
  351. #else
  352. lcd.begin(LCD_WIDTH, LCD_HEIGHT);
  353. #endif
  354. lcd_set_custom_characters(
  355. #if ENABLED(LCD_PROGRESS_BAR)
  356. info_screen_charset
  357. #endif
  358. );
  359. lcd.clear();
  360. }
  361. void lcd_implementation_clear() { lcd.clear(); }
  362. void lcd_print(const char c) { charset_mapper(c); }
  363. void lcd_print(const char *str) { while (*str) lcd.print(*str++); }
  364. void lcd_printPGM(const char *str) { while (const char c = pgm_read_byte(str)) lcd.print(c), ++str; }
  365. void lcd_print_utf(const char *str, uint8_t n=LCD_WIDTH) {
  366. char c;
  367. while (n && (c = *str)) n -= charset_mapper(c), ++str;
  368. }
  369. void lcd_printPGM_utf(const char *str, uint8_t n=LCD_WIDTH) {
  370. char c;
  371. while (n && (c = pgm_read_byte(str))) n -= charset_mapper(c), ++str;
  372. }
  373. #if ENABLED(SHOW_BOOTSCREEN)
  374. void lcd_erase_line(const int16_t line) {
  375. lcd.setCursor(0, line);
  376. for (uint8_t i = LCD_WIDTH + 1; --i;)
  377. lcd.write(' ');
  378. }
  379. // Scroll the PSTR 'text' in a 'len' wide field for 'time' milliseconds at position col,line
  380. void lcd_scroll(const int16_t col, const int16_t line, const char* const text, const int16_t len, const int16_t time) {
  381. char tmp[LCD_WIDTH + 1] = {0};
  382. int16_t n = max(lcd_strlen_P(text) - len, 0);
  383. for (int16_t i = 0; i <= n; i++) {
  384. strncpy_P(tmp, text + i, min(len, LCD_WIDTH));
  385. lcd.setCursor(col, line);
  386. lcd_print(tmp);
  387. delay(time / max(n, 1));
  388. }
  389. }
  390. static void logo_lines(const char* const extra) {
  391. int16_t indent = (LCD_WIDTH - 8 - lcd_strlen_P(extra)) / 2;
  392. lcd.setCursor(indent, 0); lcd.print('\x00'); lcd_printPGM(PSTR( "------" )); lcd.write('\x01');
  393. lcd.setCursor(indent, 1); lcd_printPGM(PSTR("|Marlin|")); lcd_printPGM(extra);
  394. lcd.setCursor(indent, 2); lcd.write('\x02'); lcd_printPGM(PSTR( "------" )); lcd.write('\x03');
  395. }
  396. void lcd_bootscreen() {
  397. const static PROGMEM byte corner[4][8] = { {
  398. B00000,
  399. B00000,
  400. B00000,
  401. B00000,
  402. B00001,
  403. B00010,
  404. B00100,
  405. B00100
  406. }, {
  407. B00000,
  408. B00000,
  409. B00000,
  410. B11100,
  411. B11100,
  412. B01100,
  413. B00100,
  414. B00100
  415. }, {
  416. B00100,
  417. B00010,
  418. B00001,
  419. B00000,
  420. B00000,
  421. B00000,
  422. B00000,
  423. B00000
  424. }, {
  425. B00100,
  426. B01000,
  427. B10000,
  428. B00000,
  429. B00000,
  430. B00000,
  431. B00000,
  432. B00000
  433. } };
  434. for (uint8_t i = 0; i < 4; i++)
  435. createChar_P(i, corner[i]);
  436. lcd.clear();
  437. #define LCD_EXTRA_SPACE (LCD_WIDTH-8)
  438. #define CENTER_OR_SCROLL(STRING,DELAY) \
  439. lcd_erase_line(3); \
  440. if (strlen(STRING) <= LCD_WIDTH) { \
  441. lcd.setCursor((LCD_WIDTH - lcd_strlen_P(PSTR(STRING))) / 2, 3); \
  442. lcd_printPGM(PSTR(STRING)); \
  443. safe_delay(DELAY); \
  444. } \
  445. else { \
  446. lcd_scroll(0, 3, PSTR(STRING), LCD_WIDTH, DELAY); \
  447. }
  448. #ifdef STRING_SPLASH_LINE1
  449. //
  450. // Show the Marlin logo with splash line 1
  451. //
  452. if (LCD_EXTRA_SPACE >= strlen(STRING_SPLASH_LINE1) + 1) {
  453. //
  454. // Show the Marlin logo, splash line1, and splash line 2
  455. //
  456. logo_lines(PSTR(" " STRING_SPLASH_LINE1));
  457. #ifdef STRING_SPLASH_LINE2
  458. CENTER_OR_SCROLL(STRING_SPLASH_LINE2, 2000);
  459. #else
  460. safe_delay(2000);
  461. #endif
  462. }
  463. else {
  464. //
  465. // Show the Marlin logo with splash line 1
  466. // After a delay show splash line 2, if it exists
  467. //
  468. #ifdef STRING_SPLASH_LINE2
  469. #define _SPLASH_WAIT_1 1500
  470. #else
  471. #define _SPLASH_WAIT_1 2000
  472. #endif
  473. logo_lines(PSTR(""));
  474. CENTER_OR_SCROLL(STRING_SPLASH_LINE1, _SPLASH_WAIT_1);
  475. #ifdef STRING_SPLASH_LINE2
  476. CENTER_OR_SCROLL(STRING_SPLASH_LINE2, 1500);
  477. #endif
  478. }
  479. #elif defined(STRING_SPLASH_LINE2)
  480. //
  481. // Show splash line 2 only, alongside the logo if possible
  482. //
  483. if (LCD_EXTRA_SPACE >= strlen(STRING_SPLASH_LINE2) + 1) {
  484. logo_lines(PSTR(" " STRING_SPLASH_LINE2));
  485. safe_delay(2000);
  486. }
  487. else {
  488. logo_lines(PSTR(""));
  489. CENTER_OR_SCROLL(STRING_SPLASH_LINE2, 2000);
  490. }
  491. #else
  492. //
  493. // Show only the Marlin logo
  494. //
  495. logo_lines(PSTR(""));
  496. safe_delay(2000);
  497. #endif
  498. lcd.clear();
  499. safe_delay(100);
  500. lcd_set_custom_characters(
  501. #if ENABLED(LCD_PROGRESS_BAR)
  502. false
  503. #endif
  504. );
  505. }
  506. #endif // SHOW_BOOTSCREEN
  507. void lcd_kill_screen() {
  508. lcd.setCursor(0, 0);
  509. lcd_print_utf(lcd_status_message);
  510. #if LCD_HEIGHT < 4
  511. lcd.setCursor(0, 2);
  512. #else
  513. lcd.setCursor(0, 2);
  514. lcd_printPGM(PSTR(MSG_HALTED));
  515. lcd.setCursor(0, 3);
  516. #endif
  517. lcd_printPGM(PSTR(MSG_PLEASE_RESET));
  518. }
  519. FORCE_INLINE void _draw_axis_label(const AxisEnum axis, const char* const pstr, const bool blink) {
  520. if (blink)
  521. lcd_printPGM(pstr);
  522. else {
  523. if (!axis_homed[axis])
  524. lcd.write('?');
  525. else {
  526. #if DISABLED(DISABLE_REDUCED_ACCURACY_WARNING)
  527. if (!axis_known_position[axis])
  528. lcd.write(' ');
  529. else
  530. #endif
  531. lcd_printPGM(pstr);
  532. }
  533. }
  534. }
  535. FORCE_INLINE void _draw_heater_status(const int8_t heater, const char prefix, const bool blink) {
  536. const bool isBed = heater < 0;
  537. const float t1 = (isBed ? thermalManager.degBed() : thermalManager.degHotend(heater)),
  538. t2 = (isBed ? thermalManager.degTargetBed() : thermalManager.degTargetHotend(heater));
  539. if (prefix >= 0) lcd.print(prefix);
  540. lcd.print(itostr3(t1 + 0.5));
  541. lcd.write('/');
  542. #if HEATER_IDLE_HANDLER
  543. const bool is_idle = (!isBed ? thermalManager.is_heater_idle(heater) :
  544. #if HAS_TEMP_BED
  545. thermalManager.is_bed_idle()
  546. #else
  547. false
  548. #endif
  549. );
  550. if (!blink && is_idle) {
  551. lcd.write(' ');
  552. if (t2 >= 10) lcd.write(' ');
  553. if (t2 >= 100) lcd.write(' ');
  554. }
  555. else
  556. #endif
  557. lcd.print(itostr3left(t2 + 0.5));
  558. if (prefix >= 0) {
  559. lcd.print((char)LCD_DEGREE_CHAR);
  560. lcd.write(' ');
  561. if (t2 < 10) lcd.write(' ');
  562. }
  563. }
  564. #if ENABLED(LCD_PROGRESS_BAR)
  565. inline void lcd_draw_progress_bar(const uint8_t percent) {
  566. const int16_t tix = (int16_t)(percent * (LCD_WIDTH) * 3) / 100,
  567. cel = tix / 3,
  568. rem = tix % 3;
  569. uint8_t i = LCD_WIDTH;
  570. char msg[LCD_WIDTH + 1], b = ' ';
  571. msg[LCD_WIDTH] = '\0';
  572. while (i--) {
  573. if (i == cel - 1)
  574. b = LCD_STR_PROGRESS[2];
  575. else if (i == cel && rem != 0)
  576. b = LCD_STR_PROGRESS[rem - 1];
  577. msg[i] = b;
  578. }
  579. lcd.print(msg);
  580. }
  581. #endif // LCD_PROGRESS_BAR
  582. /**
  583. Possible status screens:
  584. 16x2 |000/000 B000/000|
  585. |0123456789012345|
  586. 16x4 |000/000 B000/000|
  587. |SD100% Z 000.00|
  588. |F100% T--:--|
  589. |0123456789012345|
  590. 20x2 |T000/000D B000/000D |
  591. |01234567890123456789|
  592. 20x4 |T000/000D B000/000D |
  593. |X 000 Y 000 Z 000.00|
  594. |F100% SD100% T--:--|
  595. |01234567890123456789|
  596. 20x4 |T000/000D B000/000D |
  597. |T000/000D Z 000.00|
  598. |F100% SD100% T--:--|
  599. |01234567890123456789|
  600. */
  601. static void lcd_implementation_status_screen() {
  602. const bool blink = lcd_blink();
  603. //
  604. // Line 1
  605. //
  606. lcd.setCursor(0, 0);
  607. #if LCD_WIDTH < 20
  608. //
  609. // Hotend 0 Temperature
  610. //
  611. _draw_heater_status(0, -1, blink);
  612. //
  613. // Hotend 1 or Bed Temperature
  614. //
  615. #if HOTENDS > 1 || TEMP_SENSOR_BED != 0
  616. lcd.setCursor(8, 0);
  617. #if HOTENDS > 1
  618. lcd.print((CHAR)LCD_STR_THERMOMETER[0]);
  619. _draw_heater_status(1, -1, blink);
  620. #else
  621. lcd.print((CHAR)LCD_BEDTEMP_CHAR);
  622. _draw_heater_status(-1, -1, blink);
  623. #endif
  624. #endif // HOTENDS > 1 || TEMP_SENSOR_BED != 0
  625. #else // LCD_WIDTH >= 20
  626. //
  627. // Hotend 0 Temperature
  628. //
  629. _draw_heater_status(0, LCD_STR_THERMOMETER[0], blink);
  630. //
  631. // Hotend 1 or Bed Temperature
  632. //
  633. #if HOTENDS > 1 || TEMP_SENSOR_BED != 0
  634. lcd.setCursor(10, 0);
  635. #if HOTENDS > 1
  636. _draw_heater_status(1, LCD_STR_THERMOMETER[0], blink);
  637. #else
  638. _draw_heater_status(-1, LCD_BEDTEMP_CHAR, blink);
  639. #endif
  640. #endif // HOTENDS > 1 || TEMP_SENSOR_BED != 0
  641. #endif // LCD_WIDTH >= 20
  642. //
  643. // Line 2
  644. //
  645. #if LCD_HEIGHT > 2
  646. #if LCD_WIDTH < 20
  647. #if ENABLED(SDSUPPORT)
  648. lcd.setCursor(0, 2);
  649. lcd_printPGM(PSTR("SD"));
  650. if (IS_SD_PRINTING)
  651. lcd.print(itostr3(card.percentDone()));
  652. else
  653. lcd_printPGM(PSTR("---"));
  654. lcd.write('%');
  655. #endif // SDSUPPORT
  656. #else // LCD_WIDTH >= 20
  657. lcd.setCursor(0, 1);
  658. #if HOTENDS > 1 && TEMP_SENSOR_BED != 0
  659. // If we both have a 2nd extruder and a heated bed,
  660. // show the heated bed temp on the left,
  661. // since the first line is filled with extruder temps
  662. _draw_heater_status(-1, LCD_BEDTEMP_CHAR, blink);
  663. #else
  664. // Before homing the axis letters are blinking 'X' <-> '?'.
  665. // When axis is homed but axis_known_position is false the axis letters are blinking 'X' <-> ' '.
  666. // When everything is ok you see a constant 'X'.
  667. _draw_axis_label(X_AXIS, PSTR(MSG_X), blink);
  668. lcd.print(ftostr4sign(current_position[X_AXIS]));
  669. lcd.write(' ');
  670. _draw_axis_label(Y_AXIS, PSTR(MSG_Y), blink);
  671. lcd.print(ftostr4sign(current_position[Y_AXIS]));
  672. #endif // HOTENDS > 1 || TEMP_SENSOR_BED != 0
  673. #endif // LCD_WIDTH >= 20
  674. lcd.setCursor(LCD_WIDTH - 8, 1);
  675. _draw_axis_label(Z_AXIS, PSTR(MSG_Z), blink);
  676. lcd.print(ftostr52sp(FIXFLOAT(current_position[Z_AXIS])));
  677. #endif // LCD_HEIGHT > 2
  678. //
  679. // Line 3
  680. //
  681. #if LCD_HEIGHT > 3
  682. lcd.setCursor(0, 2);
  683. lcd.print((char)LCD_FEEDRATE_CHAR);
  684. lcd.print(itostr3(feedrate_percentage));
  685. lcd.write('%');
  686. #if LCD_WIDTH >= 20 && ENABLED(SDSUPPORT)
  687. lcd.setCursor(7, 2);
  688. lcd_printPGM(PSTR("SD"));
  689. if (IS_SD_PRINTING)
  690. lcd.print(itostr3(card.percentDone()));
  691. else
  692. lcd_printPGM(PSTR("---"));
  693. lcd.write('%');
  694. #endif // LCD_WIDTH >= 20 && SDSUPPORT
  695. char buffer[10];
  696. duration_t elapsed = print_job_timer.duration();
  697. uint8_t len = elapsed.toDigital(buffer);
  698. lcd.setCursor(LCD_WIDTH - len - 1, 2);
  699. lcd.print((char)LCD_CLOCK_CHAR);
  700. lcd_print(buffer);
  701. #endif // LCD_HEIGHT > 3
  702. //
  703. // Last Line
  704. // Status Message (which may be a Progress Bar or Filament display)
  705. //
  706. lcd.setCursor(0, LCD_HEIGHT - 1);
  707. #if ENABLED(LCD_PROGRESS_BAR)
  708. // Draw the progress bar if the message has shown long enough
  709. // or if there is no message set.
  710. if (card.isFileOpen() && (ELAPSED(millis(), progress_bar_ms + PROGRESS_BAR_MSG_TIME) || !lcd_status_message[0])) {
  711. const uint8_t percent = card.percentDone();
  712. if (percent) return lcd_draw_progress_bar(percent);
  713. }
  714. #elif ENABLED(FILAMENT_LCD_DISPLAY) && ENABLED(SDSUPPORT)
  715. // Show Filament Diameter and Volumetric Multiplier %
  716. // After allowing lcd_status_message to show for 5 seconds
  717. if (ELAPSED(millis(), previous_lcd_status_ms + 5000UL)) {
  718. lcd_printPGM(PSTR("Dia "));
  719. lcd.print(ftostr12ns(filament_width_meas));
  720. lcd_printPGM(PSTR(" V"));
  721. lcd.print(itostr3(100.0 * volumetric_multiplier[FILAMENT_SENSOR_EXTRUDER_NUM]));
  722. lcd.write('%');
  723. return;
  724. }
  725. #endif // FILAMENT_LCD_DISPLAY && SDSUPPORT
  726. #if ENABLED(STATUS_MESSAGE_SCROLLING)
  727. static bool last_blink = false;
  728. const uint8_t slen = lcd_strlen(lcd_status_message);
  729. const char *stat = lcd_status_message + status_scroll_pos;
  730. if (slen <= LCD_WIDTH)
  731. lcd_print_utf(stat); // The string isn't scrolling
  732. else {
  733. if (status_scroll_pos <= slen - LCD_WIDTH)
  734. lcd_print_utf(stat); // The string fills the screen
  735. else {
  736. uint8_t chars = LCD_WIDTH;
  737. if (status_scroll_pos < slen) { // First string still visible
  738. lcd_print_utf(stat); // The string leaves space
  739. chars -= slen - status_scroll_pos; // Amount of space left
  740. }
  741. lcd.write('.'); // Always at 1+ spaces left, draw a dot
  742. if (--chars) {
  743. if (status_scroll_pos < slen + 1) // Draw a second dot if there's space
  744. --chars, lcd.write('.');
  745. if (chars) lcd_print_utf(lcd_status_message, chars); // Print a second copy of the message
  746. }
  747. }
  748. if (last_blink != blink) {
  749. last_blink = blink;
  750. // Skip any non-printing bytes
  751. if (status_scroll_pos < slen) while (!PRINTABLE(lcd_status_message[status_scroll_pos])) status_scroll_pos++;
  752. if (++status_scroll_pos >= slen + 2) status_scroll_pos = 0;
  753. }
  754. }
  755. #else
  756. lcd_print_utf(lcd_status_message);
  757. #endif
  758. }
  759. #if ENABLED(ULTIPANEL)
  760. #if ENABLED(ADVANCED_PAUSE_FEATURE)
  761. static void lcd_implementation_hotend_status(const uint8_t row) {
  762. if (row < LCD_HEIGHT) {
  763. lcd.setCursor(LCD_WIDTH - 9, row);
  764. _draw_heater_status(active_extruder, LCD_STR_THERMOMETER[0], lcd_blink());
  765. }
  766. }
  767. #endif // ADVANCED_PAUSE_FEATURE
  768. static void lcd_implementation_drawmenu_static(const uint8_t row, const char* pstr, const bool center=true, const bool invert=false, const char *valstr=NULL) {
  769. UNUSED(invert);
  770. char c;
  771. int8_t n = LCD_WIDTH;
  772. lcd.setCursor(0, row);
  773. if (center && !valstr) {
  774. int8_t pad = (LCD_WIDTH - lcd_strlen_P(pstr)) / 2;
  775. while (--pad >= 0) { lcd.write(' '); n--; }
  776. }
  777. while (n > 0 && (c = pgm_read_byte(pstr))) {
  778. n -= charset_mapper(c);
  779. pstr++;
  780. }
  781. if (valstr) while (n > 0 && (c = *valstr)) {
  782. n -= charset_mapper(c);
  783. valstr++;
  784. }
  785. while (n-- > 0) lcd.write(' ');
  786. }
  787. static void lcd_implementation_drawmenu_generic(const bool sel, const uint8_t row, const char* pstr, const char pre_char, const char post_char) {
  788. char c;
  789. uint8_t n = LCD_WIDTH - 2;
  790. lcd.setCursor(0, row);
  791. lcd.print(sel ? pre_char : ' ');
  792. while ((c = pgm_read_byte(pstr)) && n > 0) {
  793. n -= charset_mapper(c);
  794. pstr++;
  795. }
  796. while (n--) lcd.write(' ');
  797. lcd.print(post_char);
  798. }
  799. static void lcd_implementation_drawmenu_setting_edit_generic(const bool sel, const uint8_t row, const char* pstr, const char pre_char, const char* const data) {
  800. char c;
  801. uint8_t n = LCD_WIDTH - 2 - lcd_strlen(data);
  802. lcd.setCursor(0, row);
  803. lcd.print(sel ? pre_char : ' ');
  804. while ((c = pgm_read_byte(pstr)) && n > 0) {
  805. n -= charset_mapper(c);
  806. pstr++;
  807. }
  808. lcd.write(':');
  809. while (n--) lcd.write(' ');
  810. lcd_print(data);
  811. }
  812. static void lcd_implementation_drawmenu_setting_edit_generic_P(const bool sel, const uint8_t row, const char* pstr, const char pre_char, const char* const data) {
  813. char c;
  814. uint8_t n = LCD_WIDTH - 2 - lcd_strlen_P(data);
  815. lcd.setCursor(0, row);
  816. lcd.print(sel ? pre_char : ' ');
  817. while ((c = pgm_read_byte(pstr)) && n > 0) {
  818. n -= charset_mapper(c);
  819. pstr++;
  820. }
  821. lcd.write(':');
  822. while (n--) lcd.write(' ');
  823. lcd_printPGM(data);
  824. }
  825. #define DEFINE_LCD_IMPLEMENTATION_DRAWMENU_SETTING_EDIT_TYPE(_type, _name, _strFunc) \
  826. inline void lcd_implementation_drawmenu_setting_edit_ ## _name (const bool sel, const uint8_t row, const char* pstr, const char* pstr2, _type * const data, ...) { \
  827. lcd_implementation_drawmenu_setting_edit_generic(sel, row, pstr, '>', _strFunc(*(data))); \
  828. } \
  829. inline void lcd_implementation_drawmenu_setting_edit_callback_ ## _name (const bool sel, const uint8_t row, const char* pstr, const char* pstr2, _type * const data, ...) { \
  830. lcd_implementation_drawmenu_setting_edit_generic(sel, row, pstr, '>', _strFunc(*(data))); \
  831. } \
  832. inline void lcd_implementation_drawmenu_setting_edit_accessor_ ## _name (const bool sel, const uint8_t row, const char* pstr, const char* pstr2, _type (*pget)(), void (*pset)(_type), ...) { \
  833. lcd_implementation_drawmenu_setting_edit_generic(sel, row, pstr, '>', _strFunc(pget())); \
  834. } \
  835. typedef void _name##_void
  836. DEFINE_LCD_IMPLEMENTATION_DRAWMENU_SETTING_EDIT_TYPE(int16_t, int3, itostr3);
  837. DEFINE_LCD_IMPLEMENTATION_DRAWMENU_SETTING_EDIT_TYPE(uint8_t, int8, i8tostr3);
  838. DEFINE_LCD_IMPLEMENTATION_DRAWMENU_SETTING_EDIT_TYPE(float, float3, ftostr3);
  839. DEFINE_LCD_IMPLEMENTATION_DRAWMENU_SETTING_EDIT_TYPE(float, float32, ftostr32);
  840. DEFINE_LCD_IMPLEMENTATION_DRAWMENU_SETTING_EDIT_TYPE(float, float43, ftostr43sign);
  841. DEFINE_LCD_IMPLEMENTATION_DRAWMENU_SETTING_EDIT_TYPE(float, float5, ftostr5rj);
  842. DEFINE_LCD_IMPLEMENTATION_DRAWMENU_SETTING_EDIT_TYPE(float, float51, ftostr51sign);
  843. DEFINE_LCD_IMPLEMENTATION_DRAWMENU_SETTING_EDIT_TYPE(float, float52, ftostr52sign);
  844. DEFINE_LCD_IMPLEMENTATION_DRAWMENU_SETTING_EDIT_TYPE(float, float62, ftostr62rj);
  845. DEFINE_LCD_IMPLEMENTATION_DRAWMENU_SETTING_EDIT_TYPE(uint32_t, long5, ftostr5rj);
  846. #define lcd_implementation_drawmenu_setting_edit_bool(sel, row, pstr, pstr2, data) lcd_implementation_drawmenu_setting_edit_generic_P(sel, row, pstr, '>', (*(data))?PSTR(MSG_ON):PSTR(MSG_OFF))
  847. #define lcd_implementation_drawmenu_setting_edit_callback_bool(sel, row, pstr, pstr2, data, callback) lcd_implementation_drawmenu_setting_edit_generic_P(sel, row, pstr, '>', (*(data))?PSTR(MSG_ON):PSTR(MSG_OFF))
  848. #define lcd_implementation_drawmenu_setting_edit_accessor_bool(sel, row, pstr, pstr2, pget, pset, callback) lcd_implementation_drawmenu_setting_edit_generic_P(sel, row, pstr, '>', (*(data))?PSTR(MSG_ON):PSTR(MSG_OFF))
  849. void lcd_implementation_drawedit(const char* pstr, const char* const value=NULL) {
  850. lcd.setCursor(1, 1);
  851. lcd_printPGM(pstr);
  852. if (value != NULL) {
  853. lcd.write(':');
  854. const uint8_t valrow = (lcd_strlen_P(pstr) + 1 + lcd_strlen(value) + 1) > (LCD_WIDTH - 2) ? 2 : 1; // Value on the next row if it won't fit
  855. lcd.setCursor((LCD_WIDTH - 1) - (lcd_strlen(value) + 1), valrow); // Right-justified, padded by spaces
  856. lcd.write(' '); // overwrite char if value gets shorter
  857. lcd_print(value);
  858. }
  859. }
  860. #if ENABLED(SDSUPPORT)
  861. static void lcd_implementation_drawmenu_sd(const bool sel, const uint8_t row, const char* const pstr, const char* filename, char* const longFilename, const uint8_t concat, const char post_char) {
  862. UNUSED(pstr);
  863. char c;
  864. uint8_t n = LCD_WIDTH - concat;
  865. lcd.setCursor(0, row);
  866. lcd.print(sel ? '>' : ' ');
  867. if (longFilename[0]) {
  868. filename = longFilename;
  869. longFilename[n] = '\0';
  870. }
  871. while ((c = *filename) && n > 0) {
  872. n -= charset_mapper(c);
  873. filename++;
  874. }
  875. while (n--) lcd.write(' ');
  876. lcd.print(post_char);
  877. }
  878. static void lcd_implementation_drawmenu_sdfile(const bool sel, const uint8_t row, const char* pstr, const char* filename, char* const longFilename) {
  879. lcd_implementation_drawmenu_sd(sel, row, pstr, filename, longFilename, 2, ' ');
  880. }
  881. static void lcd_implementation_drawmenu_sddirectory(const bool sel, const uint8_t row, const char* pstr, const char* filename, char* const longFilename) {
  882. lcd_implementation_drawmenu_sd(sel, row, pstr, filename, longFilename, 2, LCD_STR_FOLDER[0]);
  883. }
  884. #endif // SDSUPPORT
  885. #define lcd_implementation_drawmenu_back(sel, row, pstr, dummy) lcd_implementation_drawmenu_generic(sel, row, pstr, LCD_UPLEVEL_CHAR, LCD_UPLEVEL_CHAR)
  886. #define lcd_implementation_drawmenu_submenu(sel, row, pstr, data) lcd_implementation_drawmenu_generic(sel, row, pstr, '>', LCD_STR_ARROW_RIGHT[0])
  887. #define lcd_implementation_drawmenu_gcode(sel, row, pstr, gcode) lcd_implementation_drawmenu_generic(sel, row, pstr, '>', ' ')
  888. #define lcd_implementation_drawmenu_function(sel, row, pstr, data) lcd_implementation_drawmenu_generic(sel, row, pstr, '>', ' ')
  889. #if ENABLED(LCD_HAS_SLOW_BUTTONS)
  890. extern millis_t next_button_update_ms;
  891. static uint8_t lcd_implementation_read_slow_buttons() {
  892. #if ENABLED(LCD_I2C_TYPE_MCP23017)
  893. // Reading these buttons this is likely to be too slow to call inside interrupt context
  894. // so they are called during normal lcd_update
  895. uint8_t slow_bits = lcd.readButtons() << B_I2C_BTN_OFFSET;
  896. #if ENABLED(LCD_I2C_VIKI)
  897. if ((slow_bits & (B_MI | B_RI)) && PENDING(millis(), next_button_update_ms)) // LCD clicked
  898. slow_bits &= ~(B_MI | B_RI); // Disable LCD clicked buttons if screen is updated
  899. #endif // LCD_I2C_VIKI
  900. return slow_bits;
  901. #endif // LCD_I2C_TYPE_MCP23017
  902. }
  903. #endif // LCD_HAS_SLOW_BUTTONS
  904. #if ENABLED(LCD_HAS_STATUS_INDICATORS)
  905. static void lcd_implementation_update_indicators() {
  906. // Set the LEDS - referred to as backlights by the LiquidTWI2 library
  907. static uint8_t ledsprev = 0;
  908. uint8_t leds = 0;
  909. if (thermalManager.degTargetBed() > 0) leds |= LED_A;
  910. if (thermalManager.degTargetHotend(0) > 0) leds |= LED_B;
  911. #if FAN_COUNT > 0
  912. if (0
  913. #if HAS_FAN0
  914. || fanSpeeds[0]
  915. #endif
  916. #if HAS_FAN1
  917. || fanSpeeds[1]
  918. #endif
  919. #if HAS_FAN2
  920. || fanSpeeds[2]
  921. #endif
  922. ) leds |= LED_C;
  923. #endif // FAN_COUNT > 0
  924. #if HOTENDS > 1
  925. if (thermalManager.degTargetHotend(1) > 0) leds |= LED_C;
  926. #endif
  927. if (leds != ledsprev) {
  928. lcd.setBacklight(leds);
  929. ledsprev = leds;
  930. }
  931. }
  932. #endif // LCD_HAS_STATUS_INDICATORS
  933. #if ENABLED(AUTO_BED_LEVELING_UBL)
  934. /**
  935. Possible map screens:
  936. 16x2 |X000.00 Y000.00|
  937. |(00,00) Z00.000|
  938. 20x2 | X:000.00 Y:000.00 |
  939. | (00,00) Z:00.000 |
  940. 16x4 |+-------+(00,00)|
  941. || |X000.00|
  942. || |Y000.00|
  943. |+-------+Z00.000|
  944. 20x4 | +-------+ (00,00) |
  945. | | | X:000.00|
  946. | | | Y:000.00|
  947. | +-------+ Z:00.000|
  948. */
  949. typedef struct {
  950. uint8_t custom_char_bits[ULTRA_Y_PIXELS_PER_CHAR];
  951. } custom_char;
  952. typedef struct {
  953. uint8_t column, row;
  954. uint8_t y_pixel_offset, x_pixel_offset;
  955. uint8_t x_pixel_mask;
  956. } coordinate;
  957. void add_edges_to_custom_char(custom_char * const custom, coordinate * const ul, coordinate * const lr, coordinate * const brc, const uint8_t cell_location);
  958. FORCE_INLINE static void clear_custom_char(custom_char * const cc) { ZERO(cc->custom_char_bits); }
  959. /*
  960. // This debug routine should be deleted by anybody that sees it. It doesn't belong here
  961. // But I'm leaving it for now until we know the 20x4 Radar Map is working right.
  962. // We may need it again if any funny lines show up on the mesh points.
  963. void dump_custom_char(char *title, custom_char *c) {
  964. SERIAL_PROTOCOLLN(title);
  965. for (uint8_t j = 0; j < 8; j++) {
  966. for (uint8_t i = 7; i >= 0; i--)
  967. SERIAL_PROTOCOLCHAR(TEST(c->custom_char_bits[j], i) ? '1' : '0');
  968. SERIAL_EOL();
  969. }
  970. SERIAL_EOL();
  971. }
  972. //*/
  973. coordinate pixel_location(int16_t x, int16_t y) {
  974. coordinate ret_val;
  975. int16_t xp, yp, r, c;
  976. x++; y++; // +1 because lines on the left and top
  977. c = x / (ULTRA_X_PIXELS_PER_CHAR);
  978. r = y / (ULTRA_Y_PIXELS_PER_CHAR);
  979. ret_val.column = c;
  980. ret_val.row = r;
  981. xp = x - c * (ULTRA_X_PIXELS_PER_CHAR); // get the pixel offsets into the character cell
  982. xp = ULTRA_X_PIXELS_PER_CHAR - 1 - xp; // column within relevant character cell (0 on the right)
  983. yp = y - r * (ULTRA_Y_PIXELS_PER_CHAR);
  984. ret_val.x_pixel_mask = _BV(xp);
  985. ret_val.x_pixel_offset = xp;
  986. ret_val.y_pixel_offset = yp;
  987. return ret_val;
  988. }
  989. coordinate pixel_location(uint8_t x, uint8_t y) { return pixel_location((int16_t)x, (int16_t)y); }
  990. void lcd_implementation_ubl_plot(uint8_t x, uint8_t inverted_y) {
  991. #if LCD_WIDTH >= 20
  992. #define _LCD_W_POS 12
  993. #define _PLOT_X 1
  994. #define _MAP_X 3
  995. #define _LABEL(C,X,Y) lcd.setCursor(X, Y); lcd.print(C)
  996. #define _XLABEL(X,Y) _LABEL("X:",X,Y)
  997. #define _YLABEL(X,Y) _LABEL("Y:",X,Y)
  998. #define _ZLABEL(X,Y) _LABEL("Z:",X,Y)
  999. #else
  1000. #define _LCD_W_POS 8
  1001. #define _PLOT_X 0
  1002. #define _MAP_X 1
  1003. #define _LABEL(X,Y,C) lcd.setCursor(X, Y); lcd.write(C)
  1004. #define _XLABEL(X,Y) _LABEL('X',X,Y)
  1005. #define _YLABEL(X,Y) _LABEL('Y',X,Y)
  1006. #define _ZLABEL(X,Y) _LABEL('Z',X,Y)
  1007. #endif
  1008. #if LCD_HEIGHT <= 3 // 16x2 or 20x2 display
  1009. /**
  1010. * Show X and Y positions
  1011. */
  1012. _XLABEL(_PLOT_X, 0);
  1013. lcd.print(ftostr32(LOGICAL_X_POSITION(pgm_read_float(&ubl._mesh_index_to_xpos[x]))));
  1014. _YLABEL(_LCD_W_POS, 0);
  1015. lcd.print(ftostr32(LOGICAL_Y_POSITION(pgm_read_float(&ubl._mesh_index_to_ypos[inverted_y]))));
  1016. lcd.setCursor(_PLOT_X, 0);
  1017. #else // 16x4 or 20x4 display
  1018. coordinate upper_left, lower_right, bottom_right_corner;
  1019. custom_char new_char;
  1020. uint8_t i, j, k, l, m, n, n_rows, n_cols, y,
  1021. bottom_line, right_edge,
  1022. x_map_pixels, y_map_pixels,
  1023. pixels_per_x_mesh_pnt, pixels_per_y_mesh_pnt,
  1024. suppress_x_offset = 0, suppress_y_offset = 0;
  1025. y = GRID_MAX_POINTS_Y - inverted_y - 1;
  1026. upper_left.column = 0;
  1027. upper_left.row = 0;
  1028. lower_right.column = 0;
  1029. lower_right.row = 0;
  1030. lcd_implementation_clear();
  1031. x_map_pixels = (ULTRA_X_PIXELS_PER_CHAR) * (ULTRA_COLUMNS_FOR_MESH_MAP) - 2; // minus 2 because we are drawing a box around the map
  1032. y_map_pixels = (ULTRA_Y_PIXELS_PER_CHAR) * (ULTRA_ROWS_FOR_MESH_MAP) - 2;
  1033. pixels_per_x_mesh_pnt = x_map_pixels / (GRID_MAX_POINTS_X);
  1034. pixels_per_y_mesh_pnt = y_map_pixels / (GRID_MAX_POINTS_Y);
  1035. if (pixels_per_x_mesh_pnt >= ULTRA_X_PIXELS_PER_CHAR) { // There are only 2 custom characters available, so the X
  1036. pixels_per_x_mesh_pnt = ULTRA_X_PIXELS_PER_CHAR; // size of the mesh point needs to fit within them independent
  1037. suppress_x_offset = 1; // of where the starting pixel is located.
  1038. }
  1039. if (pixels_per_y_mesh_pnt >= ULTRA_Y_PIXELS_PER_CHAR) { // There are only 2 custom characters available, so the Y
  1040. pixels_per_y_mesh_pnt = ULTRA_Y_PIXELS_PER_CHAR; // size of the mesh point needs to fit within them independent
  1041. suppress_y_offset = 1; // of where the starting pixel is located.
  1042. }
  1043. x_map_pixels = pixels_per_x_mesh_pnt * (GRID_MAX_POINTS_X); // now we have the right number of pixels to make both
  1044. y_map_pixels = pixels_per_y_mesh_pnt * (GRID_MAX_POINTS_Y); // directions fit nicely
  1045. right_edge = pixels_per_x_mesh_pnt * (GRID_MAX_POINTS_X) + 1; // find location of right edge within the character cell
  1046. bottom_line= pixels_per_y_mesh_pnt * (GRID_MAX_POINTS_Y) + 1; // find location of bottome line within the character cell
  1047. n_rows = bottom_line / (ULTRA_Y_PIXELS_PER_CHAR) + 1;
  1048. n_cols = right_edge / (ULTRA_X_PIXELS_PER_CHAR) + 1;
  1049. for (i = 0; i < n_cols; i++) {
  1050. lcd.setCursor(i, 0);
  1051. lcd.print((char)0x00); // top line of the box
  1052. lcd.setCursor(i, n_rows - 1);
  1053. lcd.write(0x01); // bottom line of the box
  1054. }
  1055. for (j = 0; j < n_rows; j++) {
  1056. lcd.setCursor(0, j);
  1057. lcd.write(0x02); // Left edge of the box
  1058. lcd.setCursor(n_cols - 1, j);
  1059. lcd.write(0x03); // right edge of the box
  1060. }
  1061. /**
  1062. * If the entire 4th row is not in use, do not put vertical bars all the way down to the bottom of the display
  1063. */
  1064. k = pixels_per_y_mesh_pnt * (GRID_MAX_POINTS_Y) + 2;
  1065. l = (ULTRA_Y_PIXELS_PER_CHAR) * n_rows;
  1066. if (l > k && l - k >= (ULTRA_Y_PIXELS_PER_CHAR) / 2) {
  1067. lcd.setCursor(0, n_rows - 1); // left edge of the box
  1068. lcd.write(' ');
  1069. lcd.setCursor(n_cols - 1, n_rows - 1); // right edge of the box
  1070. lcd.write(' ');
  1071. }
  1072. clear_custom_char(&new_char);
  1073. new_char.custom_char_bits[0] = 0B11111U; // char #0 is used for the top line of the box
  1074. lcd.createChar(0, (uint8_t*)&new_char);
  1075. clear_custom_char(&new_char);
  1076. k = (GRID_MAX_POINTS_Y) * pixels_per_y_mesh_pnt + 1; // row of pixels for the bottom box line
  1077. l = k % (ULTRA_Y_PIXELS_PER_CHAR); // row within relevant character cell
  1078. new_char.custom_char_bits[l] = 0B11111U; // char #1 is used for the bottom line of the box
  1079. lcd.createChar(1, (uint8_t*)&new_char);
  1080. clear_custom_char(&new_char);
  1081. for (j = 0; j < ULTRA_Y_PIXELS_PER_CHAR; j++)
  1082. new_char.custom_char_bits[j] = 0B10000U; // char #2 is used for the left edge of the box
  1083. lcd.createChar(2, (uint8_t*)&new_char);
  1084. clear_custom_char(&new_char);
  1085. m = (GRID_MAX_POINTS_X) * pixels_per_x_mesh_pnt + 1; // Column of pixels for the right box line
  1086. n = m % (ULTRA_X_PIXELS_PER_CHAR); // Column within relevant character cell
  1087. i = ULTRA_X_PIXELS_PER_CHAR - 1 - n; // Column within relevant character cell (0 on the right)
  1088. for (j = 0; j < ULTRA_Y_PIXELS_PER_CHAR; j++)
  1089. new_char.custom_char_bits[j] = (uint8_t)_BV(i); // Char #3 is used for the right edge of the box
  1090. lcd.createChar(3, (uint8_t*)&new_char);
  1091. i = x * pixels_per_x_mesh_pnt - suppress_x_offset;
  1092. j = y * pixels_per_y_mesh_pnt - suppress_y_offset;
  1093. upper_left = pixel_location(i, j);
  1094. k = (x + 1) * pixels_per_x_mesh_pnt - 1 - suppress_x_offset;
  1095. l = (y + 1) * pixels_per_y_mesh_pnt - 1 - suppress_y_offset;
  1096. lower_right = pixel_location(k, l);
  1097. bottom_right_corner = pixel_location(x_map_pixels, y_map_pixels);
  1098. /**
  1099. * First, handle the simple case where everything is within a single character cell.
  1100. * If part of the Mesh Plot is outside of this character cell, we will follow up
  1101. * and deal with that next.
  1102. */
  1103. //dump_custom_char("at entry:", &new_char);
  1104. clear_custom_char(&new_char);
  1105. const uint8_t ypix = min(upper_left.y_pixel_offset + pixels_per_y_mesh_pnt, ULTRA_Y_PIXELS_PER_CHAR);
  1106. for (j = upper_left.y_pixel_offset; j < ypix; j++) {
  1107. i = upper_left.x_pixel_mask;
  1108. for (k = 0; k < pixels_per_x_mesh_pnt; k++) {
  1109. new_char.custom_char_bits[j] |= i;
  1110. i >>= 1;
  1111. }
  1112. }
  1113. //dump_custom_char("after loops:", &new_char);
  1114. add_edges_to_custom_char(&new_char, &upper_left, &lower_right, &bottom_right_corner, TOP_LEFT);
  1115. //dump_custom_char("after add edges", &new_char);
  1116. lcd.createChar(4, (uint8_t*)&new_char);
  1117. lcd.setCursor(upper_left.column, upper_left.row);
  1118. lcd.write(0x04);
  1119. //dump_custom_char("after lcd update:", &new_char);
  1120. /**
  1121. * Next, check for two side by side character cells being used to display the Mesh Point
  1122. * If found... do the right hand character cell next.
  1123. */
  1124. if (upper_left.column == lower_right.column - 1) {
  1125. l = upper_left.x_pixel_offset;
  1126. clear_custom_char(&new_char);
  1127. for (j = upper_left.y_pixel_offset; j < ypix; j++) {
  1128. i = _BV(ULTRA_X_PIXELS_PER_CHAR - 1); // Fill in the left side of the right character cell
  1129. for (k = 0; k < pixels_per_x_mesh_pnt - 1 - l; k++) {
  1130. new_char.custom_char_bits[j] |= i;
  1131. i >>= 1;
  1132. }
  1133. }
  1134. add_edges_to_custom_char(&new_char, &upper_left, &lower_right, &bottom_right_corner, TOP_RIGHT);
  1135. lcd.createChar(5, (uint8_t *) &new_char);
  1136. lcd.setCursor(lower_right.column, upper_left.row);
  1137. lcd.write(0x05);
  1138. }
  1139. /**
  1140. * Next, check for two character cells stacked on top of each other being used to display the Mesh Point
  1141. */
  1142. if (upper_left.row == lower_right.row - 1) {
  1143. l = ULTRA_Y_PIXELS_PER_CHAR - upper_left.y_pixel_offset; // Number of pixel rows in top character cell
  1144. k = pixels_per_y_mesh_pnt - l; // Number of pixel rows in bottom character cell
  1145. clear_custom_char(&new_char);
  1146. for (j = 0; j < k; j++) {
  1147. i = upper_left.x_pixel_mask;
  1148. for (m = 0; m < pixels_per_x_mesh_pnt; m++) { // Fill in the top side of the bottom character cell
  1149. new_char.custom_char_bits[j] |= i;
  1150. if (!(i >>= 1)) break;
  1151. }
  1152. }
  1153. add_edges_to_custom_char(&new_char, &upper_left, &lower_right, &bottom_right_corner, LOWER_LEFT);
  1154. lcd.createChar(6, (uint8_t *) &new_char);
  1155. lcd.setCursor(upper_left.column, lower_right.row);
  1156. lcd.write(0x06);
  1157. }
  1158. /**
  1159. * Next, check for four character cells being used to display the Mesh Point. If that is
  1160. * what is here, we work to fill in the character cell that is down one and to the right one
  1161. * from the upper_left character cell.
  1162. */
  1163. if (upper_left.column == lower_right.column - 1 && upper_left.row == lower_right.row - 1) {
  1164. l = ULTRA_Y_PIXELS_PER_CHAR - upper_left.y_pixel_offset; // Number of pixel rows in top character cell
  1165. k = pixels_per_y_mesh_pnt - l; // Number of pixel rows in bottom character cell
  1166. clear_custom_char(&new_char);
  1167. for (j = 0; j < k; j++) {
  1168. l = upper_left.x_pixel_offset;
  1169. i = _BV(ULTRA_X_PIXELS_PER_CHAR - 1); // Fill in the left side of the right character cell
  1170. for (m = 0; m < pixels_per_x_mesh_pnt - 1 - l; m++) { // Fill in the top side of the bottom character cell
  1171. new_char.custom_char_bits[j] |= i;
  1172. i >>= 1;
  1173. }
  1174. }
  1175. add_edges_to_custom_char(&new_char, &upper_left, &lower_right, &bottom_right_corner, LOWER_RIGHT);
  1176. lcd.createChar(7, (uint8_t*)&new_char);
  1177. lcd.setCursor(lower_right.column, lower_right.row);
  1178. lcd.write(0x07);
  1179. }
  1180. #endif
  1181. /**
  1182. * Print plot position
  1183. */
  1184. lcd.setCursor(_LCD_W_POS, 0);
  1185. lcd.write('(');
  1186. lcd.print(x);
  1187. lcd.write(',');
  1188. lcd.print(inverted_y);
  1189. lcd.write(')');
  1190. #if LCD_HEIGHT <= 3 // 16x2 or 20x2 display
  1191. /**
  1192. * Print Z values
  1193. */
  1194. _ZLABEL(_LCD_W_POS, 1);
  1195. if (!isnan(ubl.z_values[x][inverted_y]))
  1196. lcd.print(ftostr43sign(ubl.z_values[x][inverted_y]));
  1197. else
  1198. lcd_printPGM(PSTR(" -----"));
  1199. #else // 16x4 or 20x4 display
  1200. /**
  1201. * Show all values at right of screen
  1202. */
  1203. _XLABEL(_LCD_W_POS, 1);
  1204. lcd.print(ftostr32(LOGICAL_X_POSITION(pgm_read_float(&ubl._mesh_index_to_xpos[x]))));
  1205. _YLABEL(_LCD_W_POS, 2);
  1206. lcd.print(ftostr32(LOGICAL_Y_POSITION(pgm_read_float(&ubl._mesh_index_to_ypos[inverted_y]))));
  1207. /**
  1208. * Show the location value
  1209. */
  1210. _ZLABEL(_LCD_W_POS, 3);
  1211. if (!isnan(ubl.z_values[x][inverted_y]))
  1212. lcd.print(ftostr43sign(ubl.z_values[x][inverted_y]));
  1213. else
  1214. lcd_printPGM(PSTR(" -----"));
  1215. #endif // LCD_HEIGHT > 3
  1216. }
  1217. void add_edges_to_custom_char(custom_char * const custom, coordinate * const ul, coordinate * const lr, coordinate * const brc, uint8_t cell_location) {
  1218. uint8_t i, k;
  1219. int16_t n_rows = lr->row - ul->row + 1,
  1220. n_cols = lr->column - ul->column + 1;
  1221. /**
  1222. * Check if Top line of box needs to be filled in
  1223. */
  1224. if (ul->row == 0 && ((cell_location & TOP_LEFT) || (cell_location & TOP_RIGHT))) { // Only fill in the top line for the top character cells
  1225. if (n_cols == 1) {
  1226. if (ul->column != brc->column)
  1227. custom->custom_char_bits[0] = 0xFF; // Single column in middle
  1228. else
  1229. for (i = brc->x_pixel_offset; i < ULTRA_X_PIXELS_PER_CHAR; i++) // Single column on right side
  1230. SBI(custom->custom_char_bits[0], i);
  1231. }
  1232. else if ((cell_location & TOP_LEFT) || lr->column != brc->column) // Multiple column in the middle or with right cell in middle
  1233. custom->custom_char_bits[0] = 0xFF;
  1234. else
  1235. for (i = brc->x_pixel_offset; i < ULTRA_X_PIXELS_PER_CHAR; i++)
  1236. SBI(custom->custom_char_bits[0], i);
  1237. }
  1238. /**
  1239. * Check if left line of box needs to be filled in
  1240. */
  1241. if ((cell_location & TOP_LEFT) || (cell_location & LOWER_LEFT)) {
  1242. if (ul->column == 0) { // Left column of characters on LCD Display
  1243. k = ul->row == brc->row ? brc->y_pixel_offset : ULTRA_Y_PIXELS_PER_CHAR; // If it isn't the last row... do the full character cell
  1244. for (i = 0; i < k; i++)
  1245. SBI(custom->custom_char_bits[i], ULTRA_X_PIXELS_PER_CHAR - 1);
  1246. }
  1247. }
  1248. /**
  1249. * Check if bottom line of box needs to be filled in
  1250. */
  1251. // Single row of mesh plot cells
  1252. if (n_rows == 1 /* && (cell_location == TOP_LEFT || cell_location == TOP_RIGHT) */ && ul->row == brc->row) {
  1253. if (n_cols == 1) // Single row, single column case
  1254. k = ul->column == brc->column ? brc->x_pixel_mask : 0x01;
  1255. else if (cell_location & TOP_RIGHT) // Single row, multiple column case
  1256. k = lr->column == brc->column ? brc->x_pixel_mask : 0x01;
  1257. else // Single row, left of multiple columns
  1258. k = 0x01;
  1259. while (k < _BV(ULTRA_X_PIXELS_PER_CHAR)) {
  1260. custom->custom_char_bits[brc->y_pixel_offset] |= k;
  1261. k <<= 1;
  1262. }
  1263. }
  1264. // Double row of characters on LCD Display
  1265. // And this is a bottom custom character
  1266. if (n_rows == 2 && (cell_location == LOWER_LEFT || cell_location == LOWER_RIGHT) && lr->row == brc->row) {
  1267. if (n_cols == 1) // Double row, single column case
  1268. k = ul->column == brc->column ? brc->x_pixel_mask : 0x01;
  1269. else if (cell_location & LOWER_RIGHT) // Double row, multiple column case
  1270. k = lr->column == brc->column ? brc->x_pixel_mask : 0x01;
  1271. else // Double row, left of multiple columns
  1272. k = 0x01;
  1273. while (k < _BV(ULTRA_X_PIXELS_PER_CHAR)) {
  1274. custom->custom_char_bits[brc->y_pixel_offset] |= k;
  1275. k <<= 1;
  1276. }
  1277. }
  1278. /**
  1279. * Check if right line of box needs to be filled in
  1280. */
  1281. // Nothing to do if the lower right part of the mesh pnt isn't in the same column as the box line
  1282. if (lr->column == brc->column) {
  1283. // This mesh point is in the same character cell as the right box line
  1284. if (ul->column == brc->column || (cell_location & TOP_RIGHT) || (cell_location & LOWER_RIGHT)) {
  1285. // If not the last row... do the full character cell
  1286. k = ul->row == brc->row ? brc->y_pixel_offset : ULTRA_Y_PIXELS_PER_CHAR;
  1287. for (i = 0; i < k; i++) custom->custom_char_bits[i] |= brc->x_pixel_mask;
  1288. }
  1289. }
  1290. }
  1291. #endif // AUTO_BED_LEVELING_UBL
  1292. #endif // ULTIPANEL
  1293. #endif // ULTRALCD_IMPL_HD44780_H