ultralcd_implementation_hitachi_HD44780.h 41 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423
  1. #ifndef ULTRA_LCD_IMPLEMENTATION_HITACHI_HD44780_H
  2. #define ULTRA_LCD_IMPLEMENTATION_HITACHI_HD44780_H
  3. int scrollstuff = 0;
  4. char longFilenameOLD[LONG_FILENAME_LENGTH];
  5. #include "Configuration_prusa.h"
  6. #include "Marlin.h"
  7. /**
  8. * Implementation of the LCD display routines for a Hitachi HD44780 display. These are common LCD character displays.
  9. * When selecting the Russian language, a slightly different LCD implementation is used to handle UTF8 characters.
  10. **/
  11. #ifndef REPRAPWORLD_KEYPAD
  12. extern volatile uint8_t buttons; //the last checked buttons in a bit array.
  13. #else
  14. extern volatile uint16_t buttons; //an extended version of the last checked buttons in a bit array.
  15. #endif
  16. ////////////////////////////////////
  17. // Setup button and encode mappings for each panel (into 'buttons' variable
  18. //
  19. // This is just to map common functions (across different panels) onto the same
  20. // macro name. The mapping is independent of whether the button is directly connected or
  21. // via a shift/i2c register.
  22. #ifdef ULTIPANEL
  23. // All UltiPanels might have an encoder - so this is always be mapped onto first two bits
  24. #define BLEN_B 1
  25. #define BLEN_A 0
  26. #define EN_B (1<<BLEN_B) // The two encoder pins are connected through BTN_EN1 and BTN_EN2
  27. #define EN_A (1<<BLEN_A)
  28. #if defined(BTN_ENC) && BTN_ENC > -1
  29. // encoder click is directly connected
  30. #define BLEN_C 2
  31. #define EN_C (1<<BLEN_C)
  32. #endif
  33. //
  34. // Setup other button mappings of each panel
  35. //
  36. #if defined(LCD_I2C_VIKI)
  37. #define B_I2C_BTN_OFFSET 3 // (the first three bit positions reserved for EN_A, EN_B, EN_C)
  38. // button and encoder bit positions within 'buttons'
  39. #define B_LE (BUTTON_LEFT<<B_I2C_BTN_OFFSET) // The remaining normalized buttons are all read via I2C
  40. #define B_UP (BUTTON_UP<<B_I2C_BTN_OFFSET)
  41. #define B_MI (BUTTON_SELECT<<B_I2C_BTN_OFFSET)
  42. #define B_DW (BUTTON_DOWN<<B_I2C_BTN_OFFSET)
  43. #define B_RI (BUTTON_RIGHT<<B_I2C_BTN_OFFSET)
  44. #if defined(BTN_ENC) && BTN_ENC > -1
  45. // the pause/stop/restart button is connected to BTN_ENC when used
  46. #define B_ST (EN_C) // Map the pause/stop/resume button into its normalized functional name
  47. #define LCD_CLICKED (buttons&(B_MI|B_RI|B_ST)) // pause/stop button also acts as click until we implement proper pause/stop.
  48. #else
  49. #define LCD_CLICKED (buttons&(B_MI|B_RI))
  50. #endif
  51. // I2C buttons take too long to read inside an interrupt context and so we read them during lcd_update
  52. #define LCD_HAS_SLOW_BUTTONS
  53. #elif defined(LCD_I2C_PANELOLU2)
  54. // encoder click can be read through I2C if not directly connected
  55. #if BTN_ENC <= 0
  56. #define B_I2C_BTN_OFFSET 3 // (the first three bit positions reserved for EN_A, EN_B, EN_C)
  57. #define B_MI (PANELOLU2_ENCODER_C<<B_I2C_BTN_OFFSET) // requires LiquidTWI2 library v1.2.3 or later
  58. #define LCD_CLICKED (buttons&B_MI)
  59. // I2C buttons take too long to read inside an interrupt context and so we read them during lcd_update
  60. #define LCD_HAS_SLOW_BUTTONS
  61. #else
  62. #define LCD_CLICKED (buttons&EN_C)
  63. #endif
  64. #elif defined(REPRAPWORLD_KEYPAD)
  65. // define register bit values, don't change it
  66. #define BLEN_REPRAPWORLD_KEYPAD_F3 0
  67. #define BLEN_REPRAPWORLD_KEYPAD_F2 1
  68. #define BLEN_REPRAPWORLD_KEYPAD_F1 2
  69. #define BLEN_REPRAPWORLD_KEYPAD_UP 3
  70. #define BLEN_REPRAPWORLD_KEYPAD_RIGHT 4
  71. #define BLEN_REPRAPWORLD_KEYPAD_MIDDLE 5
  72. #define BLEN_REPRAPWORLD_KEYPAD_DOWN 6
  73. #define BLEN_REPRAPWORLD_KEYPAD_LEFT 7
  74. #define REPRAPWORLD_BTN_OFFSET 3 // bit offset into buttons for shift register values
  75. #define EN_REPRAPWORLD_KEYPAD_F3 (1<<(BLEN_REPRAPWORLD_KEYPAD_F3+REPRAPWORLD_BTN_OFFSET))
  76. #define EN_REPRAPWORLD_KEYPAD_F2 (1<<(BLEN_REPRAPWORLD_KEYPAD_F2+REPRAPWORLD_BTN_OFFSET))
  77. #define EN_REPRAPWORLD_KEYPAD_F1 (1<<(BLEN_REPRAPWORLD_KEYPAD_F1+REPRAPWORLD_BTN_OFFSET))
  78. #define EN_REPRAPWORLD_KEYPAD_UP (1<<(BLEN_REPRAPWORLD_KEYPAD_UP+REPRAPWORLD_BTN_OFFSET))
  79. #define EN_REPRAPWORLD_KEYPAD_RIGHT (1<<(BLEN_REPRAPWORLD_KEYPAD_RIGHT+REPRAPWORLD_BTN_OFFSET))
  80. #define EN_REPRAPWORLD_KEYPAD_MIDDLE (1<<(BLEN_REPRAPWORLD_KEYPAD_MIDDLE+REPRAPWORLD_BTN_OFFSET))
  81. #define EN_REPRAPWORLD_KEYPAD_DOWN (1<<(BLEN_REPRAPWORLD_KEYPAD_DOWN+REPRAPWORLD_BTN_OFFSET))
  82. #define EN_REPRAPWORLD_KEYPAD_LEFT (1<<(BLEN_REPRAPWORLD_KEYPAD_LEFT+REPRAPWORLD_BTN_OFFSET))
  83. #define LCD_CLICKED ((buttons&EN_C) || (buttons&EN_REPRAPWORLD_KEYPAD_F1))
  84. #define REPRAPWORLD_KEYPAD_MOVE_Y_DOWN (buttons&EN_REPRAPWORLD_KEYPAD_DOWN)
  85. #define REPRAPWORLD_KEYPAD_MOVE_Y_UP (buttons&EN_REPRAPWORLD_KEYPAD_UP)
  86. #define REPRAPWORLD_KEYPAD_MOVE_HOME (buttons&EN_REPRAPWORLD_KEYPAD_MIDDLE)
  87. #elif defined(NEWPANEL)
  88. #define LCD_CLICKED (buttons&EN_C)
  89. #else // old style ULTIPANEL
  90. //bits in the shift register that carry the buttons for:
  91. // left up center down right red(stop)
  92. #define BL_LE 7
  93. #define BL_UP 6
  94. #define BL_MI 5
  95. #define BL_DW 4
  96. #define BL_RI 3
  97. #define BL_ST 2
  98. //automatic, do not change
  99. #define B_LE (1<<BL_LE)
  100. #define B_UP (1<<BL_UP)
  101. #define B_MI (1<<BL_MI)
  102. #define B_DW (1<<BL_DW)
  103. #define B_RI (1<<BL_RI)
  104. #define B_ST (1<<BL_ST)
  105. #define LCD_CLICKED (buttons&(B_MI|B_ST))
  106. #endif
  107. ////////////////////////
  108. // Setup Rotary Encoder Bit Values (for two pin encoders to indicate movement)
  109. // These values are independent of which pins are used for EN_A and EN_B indications
  110. // The rotary encoder part is also independent to the chipset used for the LCD
  111. #if defined(EN_A) && defined(EN_B)
  112. #define encrot0 0
  113. #define encrot1 2
  114. #define encrot2 3
  115. #define encrot3 1
  116. #endif
  117. #endif //ULTIPANEL
  118. ////////////////////////////////////
  119. // Create LCD class instance and chipset-specific information
  120. #if defined(LCD_I2C_TYPE_PCF8575)
  121. // note: these are register mapped pins on the PCF8575 controller not Arduino pins
  122. #define LCD_I2C_PIN_BL 3
  123. #define LCD_I2C_PIN_EN 2
  124. #define LCD_I2C_PIN_RW 1
  125. #define LCD_I2C_PIN_RS 0
  126. #define LCD_I2C_PIN_D4 4
  127. #define LCD_I2C_PIN_D5 5
  128. #define LCD_I2C_PIN_D6 6
  129. #define LCD_I2C_PIN_D7 7
  130. #include <Wire.h>
  131. #include <LCD.h>
  132. #include <LiquidCrystal_I2C.h>
  133. #define LCD_CLASS LiquidCrystal_I2C
  134. 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);
  135. #elif defined(LCD_I2C_TYPE_MCP23017)
  136. //for the LED indicators (which maybe mapped to different things in lcd_implementation_update_indicators())
  137. #define LED_A 0x04 //100
  138. #define LED_B 0x02 //010
  139. #define LED_C 0x01 //001
  140. #define LCD_HAS_STATUS_INDICATORS
  141. #include <Wire.h>
  142. #include <LiquidTWI2.h>
  143. #define LCD_CLASS LiquidTWI2
  144. #if defined(DETECT_DEVICE)
  145. LCD_CLASS lcd(LCD_I2C_ADDRESS, 1);
  146. #else
  147. LCD_CLASS lcd(LCD_I2C_ADDRESS);
  148. #endif
  149. #elif defined(LCD_I2C_TYPE_MCP23008)
  150. #include <Wire.h>
  151. #include <LiquidTWI2.h>
  152. #define LCD_CLASS LiquidTWI2
  153. #if defined(DETECT_DEVICE)
  154. LCD_CLASS lcd(LCD_I2C_ADDRESS, 1);
  155. #else
  156. LCD_CLASS lcd(LCD_I2C_ADDRESS);
  157. #endif
  158. #elif defined(LCD_I2C_TYPE_PCA8574)
  159. #include <LiquidCrystal_I2C.h>
  160. #define LCD_CLASS LiquidCrystal_I2C
  161. LCD_CLASS lcd(LCD_I2C_ADDRESS, LCD_WIDTH, LCD_HEIGHT);
  162. // 2 wire Non-latching LCD SR from:
  163. // https://bitbucket.org/fmalpartida/new-LiquidCrystal_Prusa/wiki/schematics#!shiftregister-connection
  164. #elif defined(SR_LCD_2W_NL)
  165. extern "C" void __cxa_pure_virtual() { while (1); }
  166. #include <LCD.h>
  167. #include <LiquidCrystal_SR.h>
  168. #define LCD_CLASS LiquidCrystal_SR
  169. LCD_CLASS lcd(SR_DATA_PIN, SR_CLK_PIN);
  170. #else
  171. // Standard directly connected LCD implementations
  172. #ifdef LANGUAGE_RU
  173. #include "LiquidCrystal_Rus.h"
  174. #define LCD_CLASS LiquidCrystal_Rus
  175. #else
  176. #include "LiquidCrystal_Prusa.h"
  177. #define LCD_CLASS LiquidCrystal_Prusa
  178. #endif
  179. 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
  180. #endif
  181. #if defined(LCD_PROGRESS_BAR) && defined(SDSUPPORT)
  182. static uint16_t progressBarTick = 0;
  183. #if PROGRESS_MSG_EXPIRE > 0
  184. static uint16_t messageTick = 0;
  185. #endif
  186. #define LCD_STR_PROGRESS "\x03\x04\x05"
  187. #endif
  188. /* Custom characters defined in the first 8 characters of the LCD */
  189. #define LCD_STR_BEDTEMP "\x00"
  190. #define LCD_STR_DEGREE "\x01"
  191. #define LCD_STR_THERMOMETER "\x02"
  192. #define LCD_STR_UPLEVEL "\x03"
  193. #define LCD_STR_REFRESH "\x04"
  194. #define LCD_STR_FOLDER "\x05"
  195. #define LCD_STR_FEEDRATE "\x06"
  196. #define LCD_STR_CLOCK "\x07"
  197. #define LCD_STR_ARROW_UP "\x0B"
  198. #define LCD_STR_ARROW_DOWN "\x01"
  199. #define LCD_STR_ARROW_RIGHT "\x7E" /* from the default character set */
  200. static void lcd_set_custom_characters(
  201. #if defined(LCD_PROGRESS_BAR) && defined(SDSUPPORT)
  202. bool progress_bar_set=true
  203. #endif
  204. ) {
  205. byte bedTemp[8] = {
  206. B00000,
  207. B11111,
  208. B10101,
  209. B10001,
  210. B10101,
  211. B11111,
  212. B00000,
  213. B00000
  214. }; //thanks Sonny Mounicou
  215. byte degree[8] = {
  216. B01100,
  217. B10010,
  218. B10010,
  219. B01100,
  220. B00000,
  221. B00000,
  222. B00000,
  223. B00000
  224. };
  225. byte thermometer[8] = {
  226. B00100,
  227. B01010,
  228. B01010,
  229. B01010,
  230. B01010,
  231. B10001,
  232. B10001,
  233. B01110
  234. };
  235. byte uplevel[8] = {
  236. B00100,
  237. B01110,
  238. B11111,
  239. B00100,
  240. B11100,
  241. B00000,
  242. B00000,
  243. B00000
  244. }; //thanks joris
  245. byte refresh[8] = {
  246. B00000,
  247. B00110,
  248. B11001,
  249. B11000,
  250. B00011,
  251. B10011,
  252. B01100,
  253. B00000,
  254. }; //thanks joris
  255. byte folder[8] = {
  256. B00000,
  257. B11100,
  258. B11111,
  259. B10001,
  260. B10001,
  261. B11111,
  262. B00000,
  263. B00000
  264. }; //thanks joris
  265. #ifdef LANGUAGE_EN_H
  266. byte feedrate[8] = {
  267. B11100,
  268. B10000,
  269. B11000,
  270. B10111,
  271. B00101,
  272. B00110,
  273. B00101,
  274. B00000
  275. }; //thanks Sonny Mounicou
  276. #else
  277. /*
  278. byte feedrate[8] = {
  279. B11100,
  280. B10100,
  281. B11000,
  282. B10100,
  283. B00000,
  284. B00111,
  285. B00010,
  286. B00010
  287. };
  288. */
  289. /*
  290. byte feedrate[8] = {
  291. B01100,
  292. B10011,
  293. B00000,
  294. B01100,
  295. B10011,
  296. B00000,
  297. B01100,
  298. B10011
  299. };
  300. */
  301. byte feedrate[8] = {
  302. B00000,
  303. B00100,
  304. B10010,
  305. B01001,
  306. B10010,
  307. B00100,
  308. B00000,
  309. B00000
  310. };
  311. #endif
  312. byte clock[8] = {
  313. B00000,
  314. B01110,
  315. B10011,
  316. B10101,
  317. B10001,
  318. B01110,
  319. B00000,
  320. B00000
  321. }; //thanks Sonny Mounicou
  322. byte arrup[8] = {
  323. B00100,
  324. B01110,
  325. B11111,
  326. B00000,
  327. B00000,
  328. B00000,
  329. B00000,
  330. B00000
  331. };
  332. byte arrdown[8] = {
  333. B00000,
  334. B00000,
  335. B00000,
  336. B00000,
  337. B00000,
  338. B10001,
  339. B01010,
  340. B00100
  341. };
  342. #if defined(LCD_PROGRESS_BAR) && defined(SDSUPPORT)
  343. static bool char_mode = false;
  344. byte progress[3][8] = { {
  345. B00000,
  346. B10000,
  347. B10000,
  348. B10000,
  349. B10000,
  350. B10000,
  351. B10000,
  352. B00000
  353. }, {
  354. B00000,
  355. B10100,
  356. B10100,
  357. B10100,
  358. B10100,
  359. B10100,
  360. B10100,
  361. B00000
  362. }, {
  363. B00000,
  364. B10101,
  365. B10101,
  366. B10101,
  367. B10101,
  368. B10101,
  369. B10101,
  370. B00000
  371. } };
  372. if (progress_bar_set != char_mode) {
  373. char_mode = progress_bar_set;
  374. lcd.createChar(LCD_STR_BEDTEMP[0], bedTemp);
  375. lcd.createChar(LCD_STR_DEGREE[0], degree);
  376. lcd.createChar(LCD_STR_THERMOMETER[0], thermometer);
  377. lcd.createChar(LCD_STR_FEEDRATE[0], feedrate);
  378. lcd.createChar(LCD_STR_CLOCK[0], clock);
  379. if (progress_bar_set) {
  380. // Progress bar characters for info screen
  381. for (int i=3; i--;) lcd.createChar(LCD_STR_PROGRESS[i], progress[i]);
  382. }
  383. else {
  384. // Custom characters for submenus
  385. lcd.createChar(LCD_STR_UPLEVEL[0], uplevel);
  386. lcd.createChar(LCD_STR_REFRESH[0], refresh);
  387. lcd.createChar(LCD_STR_FOLDER[0], folder);
  388. }
  389. }
  390. #else
  391. lcd.createChar(LCD_STR_BEDTEMP[0], bedTemp);
  392. lcd.createChar(LCD_STR_DEGREE[0], degree);
  393. lcd.createChar(LCD_STR_THERMOMETER[0], thermometer);
  394. lcd.createChar(LCD_STR_UPLEVEL[0], uplevel);
  395. lcd.createChar(LCD_STR_REFRESH[0], refresh);
  396. lcd.createChar(LCD_STR_FOLDER[0], folder);
  397. lcd.createChar(LCD_STR_FEEDRATE[0], feedrate);
  398. lcd.createChar(LCD_STR_CLOCK[0], clock);
  399. //lcd.createChar(LCD_STR_ARROW_UP[0], arrup);
  400. //lcd.createChar(LCD_STR_ARROW_DOWN[0], arrdown);
  401. #endif
  402. }
  403. void lcd_set_custom_characters_arrows()
  404. {
  405. byte arrdown[8] = {
  406. B00000,
  407. B00000,
  408. B00000,
  409. B00000,
  410. B00000,
  411. B10001,
  412. B01010,
  413. B00100
  414. };
  415. lcd.createChar(1, arrdown);
  416. }
  417. void lcd_set_custom_characters_progress()
  418. {
  419. byte progress[8] = {
  420. B11111,
  421. B11111,
  422. B11111,
  423. B11111,
  424. B11111,
  425. B11111,
  426. B11111,
  427. B11111,
  428. };
  429. lcd.createChar(1, progress);
  430. }
  431. void lcd_set_custom_characters_nextpage()
  432. {
  433. byte arrdown[8] = {
  434. B00000,
  435. B00000,
  436. B10001,
  437. B01010,
  438. B00100,
  439. B10001,
  440. B01010,
  441. B00100
  442. };
  443. byte confirm[8] = {
  444. B00000,
  445. B00001,
  446. B00011,
  447. B10110,
  448. B11100,
  449. B01000,
  450. B00000
  451. };
  452. lcd.createChar(1, arrdown);
  453. lcd.createChar(2, confirm);
  454. }
  455. void lcd_set_custom_characters_degree()
  456. {
  457. byte degree[8] = {
  458. B01100,
  459. B10010,
  460. B10010,
  461. B01100,
  462. B00000,
  463. B00000,
  464. B00000,
  465. B00000
  466. };
  467. lcd.createChar(1, degree);
  468. }
  469. static void lcd_implementation_init(
  470. #if defined(LCD_PROGRESS_BAR) && defined(SDSUPPORT)
  471. bool progress_bar_set=true
  472. #endif
  473. ) {
  474. #if defined(LCD_I2C_TYPE_PCF8575)
  475. lcd.begin(LCD_WIDTH, LCD_HEIGHT);
  476. #ifdef LCD_I2C_PIN_BL
  477. lcd.setBacklightPin(LCD_I2C_PIN_BL,POSITIVE);
  478. lcd.setBacklight(HIGH);
  479. #endif
  480. #elif defined(LCD_I2C_TYPE_MCP23017)
  481. lcd.setMCPType(LTI_TYPE_MCP23017);
  482. lcd.begin(LCD_WIDTH, LCD_HEIGHT);
  483. lcd.setBacklight(0); //set all the LEDs off to begin with
  484. #elif defined(LCD_I2C_TYPE_MCP23008)
  485. lcd.setMCPType(LTI_TYPE_MCP23008);
  486. lcd.begin(LCD_WIDTH, LCD_HEIGHT);
  487. #elif defined(LCD_I2C_TYPE_PCA8574)
  488. lcd.init();
  489. lcd.backlight();
  490. #else
  491. lcd.begin(LCD_WIDTH, LCD_HEIGHT);
  492. #endif
  493. lcd_set_custom_characters(
  494. #if defined(LCD_PROGRESS_BAR) && defined(SDSUPPORT)
  495. progress_bar_set
  496. #endif
  497. );
  498. lcd.clear();
  499. }
  500. static void lcd_implementation_init_noclear(
  501. #if defined(LCD_PROGRESS_BAR) && defined(SDSUPPORT)
  502. bool progress_bar_set=true
  503. #endif
  504. ) {
  505. #if defined(LCD_I2C_TYPE_PCF8575)
  506. lcd.begin_noclear(LCD_WIDTH, LCD_HEIGHT);
  507. #ifdef LCD_I2C_PIN_BL
  508. lcd.setBacklightPin(LCD_I2C_PIN_BL,POSITIVE);
  509. lcd.setBacklight(HIGH);
  510. #endif
  511. #elif defined(LCD_I2C_TYPE_MCP23017)
  512. lcd.setMCPType(LTI_TYPE_MCP23017);
  513. lcd.begin_noclear(LCD_WIDTH, LCD_HEIGHT);
  514. lcd.setBacklight(0); //set all the LEDs off to begin with
  515. #elif defined(LCD_I2C_TYPE_MCP23008)
  516. lcd.setMCPType(LTI_TYPE_MCP23008);
  517. lcd.begin_noclear(LCD_WIDTH, LCD_HEIGHT);
  518. #elif defined(LCD_I2C_TYPE_PCA8574)
  519. lcd.init();
  520. lcd.backlight();
  521. #else
  522. lcd.begin_noclear(LCD_WIDTH, LCD_HEIGHT);
  523. #endif
  524. lcd_set_custom_characters(
  525. #if defined(LCD_PROGRESS_BAR) && defined(SDSUPPORT)
  526. progress_bar_set
  527. #endif
  528. );
  529. }
  530. static void lcd_implementation_nodisplay()
  531. {
  532. lcd.noDisplay();
  533. }
  534. static void lcd_implementation_display()
  535. {
  536. lcd.display();
  537. }
  538. void lcd_implementation_clear()
  539. {
  540. lcd.clear();
  541. }
  542. /* Arduino < 1.0.0 is missing a function to print PROGMEM strings, so we need to implement our own */
  543. void lcd_printPGM(const char* str)
  544. {
  545. char c;
  546. while((c = pgm_read_byte(str++)) != '\0')
  547. {
  548. lcd.write(c);
  549. }
  550. }
  551. void lcd_print_at_PGM(uint8_t x, uint8_t y, const char* str)
  552. {
  553. lcd.setCursor(x, y);
  554. char c;
  555. while((c = pgm_read_byte(str++)) != '\0')
  556. {
  557. lcd.write(c);
  558. }
  559. }
  560. void lcd_implementation_write(char c)
  561. {
  562. lcd.write(c);
  563. }
  564. void lcd_implementation_print(int8_t i)
  565. {
  566. lcd.print(i);
  567. }
  568. void lcd_implementation_print_at(uint8_t x, uint8_t y, int8_t i)
  569. {
  570. lcd.setCursor(x, y);
  571. lcd.print(i);
  572. }
  573. void lcd_implementation_print(int i)
  574. {
  575. lcd.print(i);
  576. }
  577. void lcd_implementation_print_at(uint8_t x, uint8_t y, int i)
  578. {
  579. lcd.setCursor(x, y);
  580. lcd.print(i);
  581. }
  582. void lcd_implementation_print(float f)
  583. {
  584. lcd.print(f);
  585. }
  586. void lcd_implementation_print(const char *str)
  587. {
  588. lcd.print(str);
  589. }
  590. void lcd_implementation_print_at(uint8_t x, uint8_t y, const char *str)
  591. {
  592. lcd.setCursor(x, y);
  593. lcd.print(str);
  594. }
  595. /*
  596. 20x4 |01234567890123456789|
  597. |T 000/000D Z000.0 |
  598. |B 000/000D F100% |
  599. |SD100% T--:-- |
  600. |Status line.........|
  601. */
  602. static void lcd_implementation_status_screen()
  603. {
  604. int tHotend=int(degHotend(0) + 0.5);
  605. int tTarget=int(degTargetHotend(0) + 0.5);
  606. //Print the hotend temperature
  607. lcd.setCursor(0, 0);
  608. lcd.print(LCD_STR_THERMOMETER[0]);
  609. lcd.print(itostr3(tHotend));
  610. lcd.print('/');
  611. lcd.print(itostr3left(tTarget));
  612. lcd_printPGM(PSTR(LCD_STR_DEGREE " "));
  613. lcd_printPGM(PSTR(" "));
  614. //Print the Z coordinates
  615. lcd.setCursor(LCD_WIDTH - 8-2, 0);
  616. #if 1
  617. lcd_printPGM(PSTR(" Z"));
  618. if (custom_message_type == 1) {
  619. // In a bed calibration mode.
  620. lcd_printPGM(PSTR(" --- "));
  621. } else {
  622. lcd.print(ftostr32sp(current_position[Z_AXIS] + 0.00001));
  623. lcd.print(' ');
  624. }
  625. #else
  626. lcd_printPGM(PSTR(" Queue:"));
  627. lcd.print(int(moves_planned()));
  628. lcd.print(' ');
  629. #endif
  630. //Print the Bedtemperature
  631. lcd.setCursor(0, 1);
  632. tHotend=int(degBed() + 0.5);
  633. tTarget=int(degTargetBed() + 0.5);
  634. lcd.print(LCD_STR_BEDTEMP[0]);
  635. lcd.print(itostr3(tHotend));
  636. lcd.print('/');
  637. lcd.print(itostr3left(tTarget));
  638. lcd_printPGM(PSTR(LCD_STR_DEGREE " "));
  639. lcd_printPGM(PSTR(" "));
  640. #ifdef PLANNER_DIAGNOSTICS
  641. //Print Feedrate
  642. lcd.setCursor(LCD_WIDTH - 8-2, 1);
  643. lcd.print(LCD_STR_FEEDRATE[0]);
  644. lcd.print(itostr3(feedmultiply));
  645. lcd_printPGM(PSTR("% Q"));
  646. {
  647. uint8_t queue = planner_queue_min();
  648. if (queue < (BLOCK_BUFFER_SIZE >> 1)) {
  649. lcd.write('!');
  650. } else {
  651. lcd.write((char)(queue / 10) + '0');
  652. queue %= 10;
  653. }
  654. lcd.write((char)queue + '0');
  655. planner_queue_min_reset();
  656. }
  657. #else /* PLANNER_DIAGNOSTICS */
  658. //Print Feedrate
  659. lcd.setCursor(LCD_WIDTH - 8-2, 1);
  660. lcd_printPGM(PSTR(" "));
  661. lcd.print(LCD_STR_FEEDRATE[0]);
  662. lcd.print(itostr3(feedmultiply));
  663. lcd_printPGM(PSTR("% "));
  664. #endif /* PLANNER_DIAGNOSTICS */
  665. bool print_sd_status = true;
  666. #ifdef PINDA_THERMISTOR
  667. // if (farm_mode && (custom_message_type == 4))
  668. if (false)
  669. {
  670. lcd.setCursor(0, 2);
  671. lcd_printPGM(PSTR("P"));
  672. lcd.print(ftostr3(current_temperature_pinda));
  673. lcd_printPGM(PSTR(LCD_STR_DEGREE " "));
  674. print_sd_status = false;
  675. }
  676. #endif //PINDA_THERMISTOR
  677. if (print_sd_status)
  678. {
  679. //Print SD status
  680. lcd.setCursor(0, 2);
  681. if (is_usb_printing)
  682. {
  683. lcd_printPGM(PSTR("--"));
  684. }
  685. else
  686. {
  687. lcd_printPGM(PSTR("SD"));
  688. }
  689. if (IS_SD_PRINTING)
  690. {
  691. lcd.print(itostr3(card.percentDone()));
  692. lcd.print('%');
  693. }
  694. else
  695. {
  696. if (is_usb_printing)
  697. {
  698. lcd_printPGM(PSTR(">USB"));
  699. }
  700. else
  701. {
  702. lcd_printPGM(PSTR("---"));
  703. lcd.print('%');
  704. }
  705. }
  706. }
  707. // Farm number display
  708. if (farm_mode)
  709. {
  710. lcd_printPGM(PSTR(" F"));
  711. lcd.print(farm_no);
  712. lcd_printPGM(PSTR(" "));
  713. // Beat display
  714. lcd.setCursor(LCD_WIDTH - 1, 0);
  715. if ( (millis() - kicktime) < 60000 ) {
  716. lcd_printPGM(PSTR("L"));
  717. }else{
  718. lcd_printPGM(PSTR(" "));
  719. }
  720. }
  721. else {
  722. #ifdef SNMM
  723. lcd_printPGM(PSTR(" E"));
  724. lcd.print(get_ext_nr() + 1);
  725. #else
  726. lcd.setCursor(LCD_WIDTH - 8 - 2, 2);
  727. lcd_printPGM(PSTR(" "));
  728. #endif
  729. }
  730. //Print time elapsed
  731. lcd.setCursor(LCD_WIDTH - 8 -1, 2);
  732. lcd_printPGM(PSTR(" "));
  733. lcd.print(LCD_STR_CLOCK[0]);
  734. if(starttime != 0)
  735. {
  736. uint16_t time = millis() / 60000 - starttime / 60000;
  737. lcd.print(itostr2(time/60));
  738. lcd.print(':');
  739. lcd.print(itostr2(time%60));
  740. }else{
  741. lcd_printPGM(PSTR("--:--"));
  742. }
  743. lcd_printPGM(PSTR(" "));
  744. #ifdef DEBUG_DISABLE_LCD_STATUS_LINE
  745. return;
  746. #endif //DEBUG_DISABLE_LCD_STATUS_LINE
  747. //Print status line
  748. lcd.setCursor(0, 3);
  749. // If heating in progress, set flag
  750. if (heating_status != 0) { custom_message = true; }
  751. if (IS_SD_PRINTING) {
  752. if (strcmp(longFilenameOLD, card.longFilename) != 0)
  753. {
  754. memset(longFilenameOLD, '\0', strlen(longFilenameOLD));
  755. sprintf_P(longFilenameOLD, PSTR("%s"), card.longFilename);
  756. scrollstuff = 0;
  757. }
  758. }
  759. // If printing from SD, show what we are printing
  760. if ((IS_SD_PRINTING) && !custom_message
  761. #ifdef DEBUG_BUILD
  762. && lcd_status_message[0] == 0
  763. #endif /* DEBUG_BUILD */
  764. )
  765. {
  766. if(strlen(card.longFilename) > LCD_WIDTH)
  767. {
  768. int inters = 0;
  769. int gh = scrollstuff;
  770. while (((gh - scrollstuff) < LCD_WIDTH) && (inters == 0))
  771. {
  772. if (card.longFilename[gh] == '\0')
  773. {
  774. lcd.setCursor(gh - scrollstuff, 3);
  775. lcd.print(card.longFilename[gh - 1]);
  776. scrollstuff = 0;
  777. gh = scrollstuff;
  778. inters = 1;
  779. }
  780. else
  781. {
  782. lcd.setCursor(gh - scrollstuff, 3);
  783. lcd.print(card.longFilename[gh - 1]);
  784. gh++;
  785. }
  786. }
  787. scrollstuff++;
  788. }
  789. else
  790. {
  791. lcd.print(longFilenameOLD);
  792. }
  793. }
  794. // If not, check for other special events
  795. else
  796. {
  797. if (custom_message)
  798. {
  799. // If heating flag, show progress of heating.
  800. if (heating_status != 0)
  801. {
  802. heating_status_counter++;
  803. if (heating_status_counter > 13)
  804. {
  805. heating_status_counter = 0;
  806. }
  807. lcd.setCursor(7, 3);
  808. lcd_printPGM(PSTR(" "));
  809. for (int dots = 0; dots < heating_status_counter; dots++)
  810. {
  811. lcd.setCursor(7 + dots, 3);
  812. lcd.print('.');
  813. }
  814. switch (heating_status)
  815. {
  816. case 1:
  817. lcd.setCursor(0, 3);
  818. lcd_printPGM(MSG_HEATING);
  819. break;
  820. case 2:
  821. lcd.setCursor(0, 3);
  822. lcd_printPGM(MSG_HEATING_COMPLETE);
  823. heating_status = 0;
  824. heating_status_counter = 0;
  825. custom_message = false;
  826. break;
  827. case 3:
  828. lcd.setCursor(0, 3);
  829. lcd_printPGM(MSG_BED_HEATING);
  830. break;
  831. case 4:
  832. lcd.setCursor(0, 3);
  833. lcd_printPGM(MSG_BED_DONE);
  834. heating_status = 0;
  835. heating_status_counter = 0;
  836. custom_message = false;
  837. break;
  838. default:
  839. break;
  840. }
  841. }
  842. // If mesh bed leveling in progress, show the status
  843. if (custom_message_type == 1)
  844. {
  845. if (custom_message_state > 10)
  846. {
  847. lcd.setCursor(0, 3);
  848. lcd_printPGM(PSTR(" "));
  849. lcd.setCursor(0, 3);
  850. lcd_printPGM(MSG_HOMEYZ_PROGRESS);
  851. lcd_printPGM(PSTR(" : "));
  852. lcd.print(custom_message_state-10);
  853. }
  854. else
  855. {
  856. if (custom_message_state == 3)
  857. {
  858. lcd_printPGM(WELCOME_MSG);
  859. lcd_setstatuspgm(WELCOME_MSG);
  860. custom_message = false;
  861. custom_message_type = 0;
  862. }
  863. if (custom_message_state > 3 && custom_message_state <= 10 )
  864. {
  865. lcd.setCursor(0, 3);
  866. lcd_printPGM(PSTR(" "));
  867. lcd.setCursor(0, 3);
  868. lcd_printPGM(MSG_HOMEYZ_DONE);
  869. custom_message_state--;
  870. }
  871. }
  872. }
  873. // If loading filament, print status
  874. if (custom_message_type == 2)
  875. {
  876. lcd.print(lcd_status_message);
  877. }
  878. // PID tuning in progress
  879. if (custom_message_type == 3) {
  880. lcd.print(lcd_status_message);
  881. if (pid_cycle <= pid_number_of_cycles && custom_message_state > 0) {
  882. lcd.setCursor(10, 3);
  883. lcd.print(itostr3(pid_cycle));
  884. lcd.print('/');
  885. lcd.print(itostr3left(pid_number_of_cycles));
  886. }
  887. }
  888. // PINDA temp calibration in progress
  889. if (custom_message_type == 4) {
  890. char progress[4];
  891. lcd.setCursor(0, 3);
  892. lcd_printPGM(MSG_TEMP_CALIBRATION);
  893. lcd.setCursor(12, 3);
  894. sprintf(progress, "%d/6", custom_message_state);
  895. lcd.print(progress);
  896. }
  897. // temp compensation preheat
  898. if (custom_message_type == 5) {
  899. lcd.setCursor(0, 3);
  900. lcd_printPGM(MSG_PINDA_PREHEAT);
  901. if (custom_message_state <= PINDA_HEAT_T) {
  902. lcd_printPGM(PSTR(": "));
  903. lcd.print(custom_message_state); //seconds
  904. lcd.print(' ');
  905. }
  906. }
  907. }
  908. else
  909. {
  910. // Nothing special, print status message normally
  911. lcd.print(lcd_status_message);
  912. }
  913. }
  914. // Fill the rest of line to have nice and clean output
  915. for(int fillspace = 0; fillspace<20;fillspace++)
  916. {
  917. if((lcd_status_message[fillspace] > 31 ))
  918. {
  919. }
  920. else
  921. {
  922. lcd.print(' ');
  923. }
  924. }
  925. }
  926. static void lcd_implementation_drawmenu_generic(uint8_t row, const char* pstr, char pre_char, char post_char)
  927. {
  928. char c;
  929. //Use all characters in narrow LCDs
  930. #if LCD_WIDTH < 20
  931. uint8_t n = LCD_WIDTH - 1 - 1;
  932. #else
  933. uint8_t n = LCD_WIDTH - 1 - 2;
  934. #endif
  935. lcd.setCursor(0, row);
  936. lcd.print(pre_char);
  937. while( ((c = pgm_read_byte(pstr)) != '\0') && (n>0) )
  938. {
  939. lcd.print(c);
  940. pstr++;
  941. n--;
  942. }
  943. while(n--)
  944. lcd.print(' ');
  945. lcd.print(post_char);
  946. lcd.print(' ');
  947. }
  948. static void lcd_implementation_drawmenu_generic_RAM(uint8_t row, const char* str, char pre_char, char post_char)
  949. {
  950. char c;
  951. //Use all characters in narrow LCDs
  952. #if LCD_WIDTH < 20
  953. uint8_t n = LCD_WIDTH - 1 - 1;
  954. #else
  955. uint8_t n = LCD_WIDTH - 1 - 2;
  956. #endif
  957. lcd.setCursor(0, row);
  958. lcd.print(pre_char);
  959. while( ((c = *str) != '\0') && (n>0) )
  960. {
  961. lcd.print(c);
  962. str++;
  963. n--;
  964. }
  965. while(n--)
  966. lcd.print(' ');
  967. lcd.print(post_char);
  968. lcd.print(' ');
  969. }
  970. static void lcd_implementation_drawmenu_setting_edit_generic(uint8_t row, const char* pstr, char pre_char, char* data)
  971. {
  972. char c;
  973. //Use all characters in narrow LCDs
  974. #if LCD_WIDTH < 20
  975. uint8_t n = LCD_WIDTH - 1 - 1 - strlen(data);
  976. #else
  977. uint8_t n = LCD_WIDTH - 1 - 2 - strlen(data);
  978. #endif
  979. lcd.setCursor(0, row);
  980. lcd.print(pre_char);
  981. while( ((c = pgm_read_byte(pstr)) != '\0') && (n>0) )
  982. {
  983. lcd.print(c);
  984. pstr++;
  985. n--;
  986. }
  987. lcd.print(':');
  988. while(n--)
  989. lcd.print(' ');
  990. lcd.print(data);
  991. }
  992. static void lcd_implementation_drawmenu_setting_edit_generic_P(uint8_t row, const char* pstr, char pre_char, const char* data)
  993. {
  994. char c;
  995. //Use all characters in narrow LCDs
  996. #if LCD_WIDTH < 20
  997. uint8_t n = LCD_WIDTH - 1 - 1 - strlen_P(data);
  998. #else
  999. uint8_t n = LCD_WIDTH - 1 - 2 - strlen_P(data);
  1000. #endif
  1001. lcd.setCursor(0, row);
  1002. lcd.print(pre_char);
  1003. while( ((c = pgm_read_byte(pstr)) != '\0') && (n>0) )
  1004. {
  1005. lcd.print(c);
  1006. pstr++;
  1007. n--;
  1008. }
  1009. lcd.print(':');
  1010. while(n--)
  1011. lcd.print(' ');
  1012. lcd_printPGM(data);
  1013. }
  1014. extern char *wfac_to_str5(const uint8_t &x);
  1015. extern char *mres_to_str3(const uint8_t &x);
  1016. #define lcd_implementation_drawmenu_setting_edit_wfac_selected(row, pstr, pstr2, data, minValue, maxValue) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, '>', wfac_to_str5(*(data)))
  1017. #define lcd_implementation_drawmenu_setting_edit_wfac(row, pstr, pstr2, data, minValue, maxValue) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, ' ', wfac_to_str5(*(data)))
  1018. #define lcd_implementation_drawmenu_setting_edit_mres_selected(row, pstr, pstr2, data, minValue, maxValue) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, '>', mres_to_str3(*(data)))
  1019. #define lcd_implementation_drawmenu_setting_edit_mres(row, pstr, pstr2, data, minValue, maxValue) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, ' ', mres_to_str3(*(data)))
  1020. #define lcd_implementation_drawmenu_setting_edit_byte3_selected(row, pstr, pstr2, data, minValue, maxValue) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, '>', itostr3((uint8_t)*(data)))
  1021. #define lcd_implementation_drawmenu_setting_edit_byte3(row, pstr, pstr2, data, minValue, maxValue) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, ' ', itostr3((uint8_t)*(data)))
  1022. #define lcd_implementation_drawmenu_setting_edit_int3_selected(row, pstr, pstr2, data, minValue, maxValue) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, '>', itostr3(*(data)))
  1023. #define lcd_implementation_drawmenu_setting_edit_int3(row, pstr, pstr2, data, minValue, maxValue) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, ' ', itostr3(*(data)))
  1024. #define lcd_implementation_drawmenu_setting_edit_float3_selected(row, pstr, pstr2, data, minValue, maxValue) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, '>', ftostr3(*(data)))
  1025. #define lcd_implementation_drawmenu_setting_edit_float3(row, pstr, pstr2, data, minValue, maxValue) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, ' ', ftostr3(*(data)))
  1026. #define lcd_implementation_drawmenu_setting_edit_float32_selected(row, pstr, pstr2, data, minValue, maxValue) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, '>', ftostr32(*(data)))
  1027. #define lcd_implementation_drawmenu_setting_edit_float32(row, pstr, pstr2, data, minValue, maxValue) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, ' ', ftostr32(*(data)))
  1028. #define lcd_implementation_drawmenu_setting_edit_float43_selected(row, pstr, pstr2, data, minValue, maxValue) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, '>', ftostr43(*(data)))
  1029. #define lcd_implementation_drawmenu_setting_edit_float43(row, pstr, pstr2, data, minValue, maxValue) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, ' ', ftostr43(*(data)))
  1030. #define lcd_implementation_drawmenu_setting_edit_float5_selected(row, pstr, pstr2, data, minValue, maxValue) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, '>', ftostr5(*(data)))
  1031. #define lcd_implementation_drawmenu_setting_edit_float5(row, pstr, pstr2, data, minValue, maxValue) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, ' ', ftostr5(*(data)))
  1032. #define lcd_implementation_drawmenu_setting_edit_float52_selected(row, pstr, pstr2, data, minValue, maxValue) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, '>', ftostr52(*(data)))
  1033. #define lcd_implementation_drawmenu_setting_edit_float52(row, pstr, pstr2, data, minValue, maxValue) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, ' ', ftostr52(*(data)))
  1034. #define lcd_implementation_drawmenu_setting_edit_float51_selected(row, pstr, pstr2, data, minValue, maxValue) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, '>', ftostr51(*(data)))
  1035. #define lcd_implementation_drawmenu_setting_edit_float51(row, pstr, pstr2, data, minValue, maxValue) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, ' ', ftostr51(*(data)))
  1036. #define lcd_implementation_drawmenu_setting_edit_long5_selected(row, pstr, pstr2, data, minValue, maxValue) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, '>', ftostr5(*(data)))
  1037. #define lcd_implementation_drawmenu_setting_edit_long5(row, pstr, pstr2, data, minValue, maxValue) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, ' ', ftostr5(*(data)))
  1038. #define lcd_implementation_drawmenu_setting_edit_bool_selected(row, pstr, pstr2, data) lcd_implementation_drawmenu_setting_edit_generic_P(row, pstr, '>', (*(data))?PSTR(MSG_ON):PSTR(MSG_OFF))
  1039. #define lcd_implementation_drawmenu_setting_edit_bool(row, pstr, pstr2, data) lcd_implementation_drawmenu_setting_edit_generic_P(row, pstr, ' ', (*(data))?PSTR(MSG_ON):PSTR(MSG_OFF))
  1040. //Add version for callback functions
  1041. #define lcd_implementation_drawmenu_setting_edit_callback_int3_selected(row, pstr, pstr2, data, minValue, maxValue, callback) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, '>', itostr3(*(data)))
  1042. #define lcd_implementation_drawmenu_setting_edit_callback_int3(row, pstr, pstr2, data, minValue, maxValue, callback) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, ' ', itostr3(*(data)))
  1043. #define lcd_implementation_drawmenu_setting_edit_callback_float3_selected(row, pstr, pstr2, data, minValue, maxValue, callback) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, '>', ftostr3(*(data)))
  1044. #define lcd_implementation_drawmenu_setting_edit_callback_float3(row, pstr, pstr2, data, minValue, maxValue, callback) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, ' ', ftostr3(*(data)))
  1045. #define lcd_implementation_drawmenu_setting_edit_callback_float32_selected(row, pstr, pstr2, data, minValue, maxValue, callback) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, '>', ftostr32(*(data)))
  1046. #define lcd_implementation_drawmenu_setting_edit_callback_float32(row, pstr, pstr2, data, minValue, maxValue, callback) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, ' ', ftostr32(*(data)))
  1047. #define lcd_implementation_drawmenu_setting_edit_callback_float43_selected(row, pstr, pstr2, data, minValue, maxValue, callback) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, '>', ftostr43(*(data)))
  1048. #define lcd_implementation_drawmenu_setting_edit_callback_float43(row, pstr, pstr2, data, minValue, maxValue, callback) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, ' ', ftostr43(*(data)))
  1049. #define lcd_implementation_drawmenu_setting_edit_callback_float5_selected(row, pstr, pstr2, data, minValue, maxValue, callback) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, '>', ftostr5(*(data)))
  1050. #define lcd_implementation_drawmenu_setting_edit_callback_float5(row, pstr, pstr2, data, minValue, maxValue, callback) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, ' ', ftostr5(*(data)))
  1051. #define lcd_implementation_drawmenu_setting_edit_callback_float52_selected(row, pstr, pstr2, data, minValue, maxValue, callback) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, '>', ftostr52(*(data)))
  1052. #define lcd_implementation_drawmenu_setting_edit_callback_float52(row, pstr, pstr2, data, minValue, maxValue, callback) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, ' ', ftostr52(*(data)))
  1053. #define lcd_implementation_drawmenu_setting_edit_callback_float51_selected(row, pstr, pstr2, data, minValue, maxValue, callback) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, '>', ftostr51(*(data)))
  1054. #define lcd_implementation_drawmenu_setting_edit_callback_float51(row, pstr, pstr2, data, minValue, maxValue, callback) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, ' ', ftostr51(*(data)))
  1055. #define lcd_implementation_drawmenu_setting_edit_callback_long5_selected(row, pstr, pstr2, data, minValue, maxValue, callback) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, '>', ftostr5(*(data)))
  1056. #define lcd_implementation_drawmenu_setting_edit_callback_long5(row, pstr, pstr2, data, minValue, maxValue, callback) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, ' ', ftostr5(*(data)))
  1057. #define lcd_implementation_drawmenu_setting_edit_callback_bool_selected(row, pstr, pstr2, data, callback) lcd_implementation_drawmenu_setting_edit_generic_P(row, pstr, '>', (*(data))?PSTR(MSG_ON):PSTR(MSG_OFF))
  1058. #define lcd_implementation_drawmenu_setting_edit_callback_bool(row, pstr, pstr2, data, callback) lcd_implementation_drawmenu_setting_edit_generic_P(row, pstr, ' ', (*(data))?PSTR(MSG_ON):PSTR(MSG_OFF))
  1059. void lcd_implementation_drawedit(const char* pstr, char* value)
  1060. {
  1061. lcd.setCursor(1, 1);
  1062. lcd_printPGM(pstr);
  1063. lcd.print(':');
  1064. #if LCD_WIDTH < 20
  1065. lcd.setCursor(LCD_WIDTH - strlen(value), 1);
  1066. #else
  1067. lcd.setCursor(LCD_WIDTH -1 - strlen(value), 1);
  1068. #endif
  1069. lcd.print(value);
  1070. }
  1071. void lcd_implementation_drawedit_2(const char* pstr, char* value)
  1072. {
  1073. lcd.setCursor(0, 1);
  1074. lcd_printPGM(pstr);
  1075. lcd.print(':');
  1076. lcd.setCursor((LCD_WIDTH - strlen(value))/2, 3);
  1077. lcd.print(value);
  1078. lcd.print(" mm");
  1079. }
  1080. static void lcd_implementation_drawmenu_sdfile_selected(uint8_t row, const char* pstr, const char* filename, char* longFilename)
  1081. {
  1082. char c;
  1083. int enc_dif = encoderDiff;
  1084. uint8_t n = LCD_WIDTH - 1;
  1085. for(int g = 0; g<4;g++){
  1086. lcd.setCursor(0, g);
  1087. lcd.print(' ');
  1088. }
  1089. lcd.setCursor(0, row);
  1090. lcd.print('>');
  1091. int i = 1;
  1092. int j = 0;
  1093. char* longFilenameTMP = longFilename;
  1094. while((c = *longFilenameTMP) != '\0')
  1095. {
  1096. lcd.setCursor(i, row);
  1097. lcd.print(c);
  1098. i++;
  1099. longFilenameTMP++;
  1100. if(i==LCD_WIDTH){
  1101. i=1;
  1102. j++;
  1103. longFilenameTMP = longFilename + j;
  1104. n = LCD_WIDTH - 1;
  1105. for(int g = 0; g<300 ;g++){
  1106. manage_heater();
  1107. if(LCD_CLICKED || ( enc_dif != encoderDiff )){
  1108. longFilenameTMP = longFilename;
  1109. *(longFilenameTMP + LCD_WIDTH - 2) = '\0';
  1110. i = 1;
  1111. j = 0;
  1112. break;
  1113. }else{
  1114. if (j == 1) delay(3); //wait around 1.2 s to start scrolling text
  1115. delay(1); //then scroll with redrawing every 300 ms
  1116. }
  1117. }
  1118. }
  1119. }
  1120. if(c!='\0'){
  1121. lcd.setCursor(i, row);
  1122. lcd.print(c);
  1123. i++;
  1124. }
  1125. n=n-i+1;
  1126. while(n--)
  1127. lcd.print(' ');
  1128. }
  1129. static void lcd_implementation_drawmenu_sdfile(uint8_t row, const char* pstr, const char* filename, char* longFilename)
  1130. {
  1131. char c;
  1132. uint8_t n = LCD_WIDTH - 1;
  1133. lcd.setCursor(0, row);
  1134. lcd.print(' ');
  1135. if (longFilename[0] != '\0')
  1136. {
  1137. filename = longFilename;
  1138. longFilename[LCD_WIDTH-1] = '\0';
  1139. }
  1140. while( ((c = *filename) != '\0') && (n>0) )
  1141. {
  1142. lcd.print(c);
  1143. filename++;
  1144. n--;
  1145. }
  1146. while(n--)
  1147. lcd.print(' ');
  1148. }
  1149. static void lcd_implementation_drawmenu_sddirectory_selected(uint8_t row, const char* pstr, const char* filename, char* longFilename)
  1150. {
  1151. char c;
  1152. uint8_t n = LCD_WIDTH - 2;
  1153. lcd.setCursor(0, row);
  1154. lcd.print('>');
  1155. lcd.print(LCD_STR_FOLDER[0]);
  1156. if (longFilename[0] != '\0')
  1157. {
  1158. filename = longFilename;
  1159. longFilename[LCD_WIDTH-2] = '\0';
  1160. }
  1161. while( ((c = *filename) != '\0') && (n>0) )
  1162. {
  1163. lcd.print(c);
  1164. filename++;
  1165. n--;
  1166. }
  1167. while(n--)
  1168. lcd.print(' ');
  1169. }
  1170. static void lcd_implementation_drawmenu_sddirectory(uint8_t row, const char* pstr, const char* filename, char* longFilename)
  1171. {
  1172. char c;
  1173. uint8_t n = LCD_WIDTH - 2;
  1174. lcd.setCursor(0, row);
  1175. lcd.print(' ');
  1176. lcd.print(LCD_STR_FOLDER[0]);
  1177. if (longFilename[0] != '\0')
  1178. {
  1179. filename = longFilename;
  1180. longFilename[LCD_WIDTH-2] = '\0';
  1181. }
  1182. while( ((c = *filename) != '\0') && (n>0) )
  1183. {
  1184. lcd.print(c);
  1185. filename++;
  1186. n--;
  1187. }
  1188. while(n--)
  1189. lcd.print(' ');
  1190. }
  1191. #define lcd_implementation_drawmenu_back_selected(row, pstr, data) lcd_implementation_drawmenu_generic(row, pstr, LCD_STR_UPLEVEL[0], LCD_STR_UPLEVEL[0])
  1192. #define lcd_implementation_drawmenu_back(row, pstr, data) lcd_implementation_drawmenu_generic(row, pstr, ' ', LCD_STR_UPLEVEL[0])
  1193. #define lcd_implementation_drawmenu_back_RAM_selected(row, str, data) lcd_implementation_drawmenu_generic_RAM(row, str, LCD_STR_UPLEVEL[0], LCD_STR_UPLEVEL[0])
  1194. #define lcd_implementation_drawmenu_back_RAM(row, str, data) lcd_implementation_drawmenu_generic_RAM(row, str, ' ', LCD_STR_UPLEVEL[0])
  1195. #define lcd_implementation_drawmenu_submenu_selected(row, pstr, data) lcd_implementation_drawmenu_generic(row, pstr, '>', LCD_STR_ARROW_RIGHT[0])
  1196. #define lcd_implementation_drawmenu_submenu(row, pstr, data) lcd_implementation_drawmenu_generic(row, pstr, ' ', LCD_STR_ARROW_RIGHT[0])
  1197. #define lcd_implementation_drawmenu_gcode_selected(row, pstr, gcode) lcd_implementation_drawmenu_generic(row, pstr, '>', ' ')
  1198. #define lcd_implementation_drawmenu_gcode(row, pstr, gcode) lcd_implementation_drawmenu_generic(row, pstr, ' ', ' ')
  1199. #define lcd_implementation_drawmenu_function_selected(row, pstr, data) lcd_implementation_drawmenu_generic(row, pstr, '>', ' ')
  1200. #define lcd_implementation_drawmenu_function(row, pstr, data) lcd_implementation_drawmenu_generic(row, pstr, ' ', ' ')
  1201. #define lcd_implementation_drawmenu_setlang_selected(row, pstr, data) lcd_implementation_drawmenu_generic(row, pstr, '>', ' ')
  1202. #define lcd_implementation_drawmenu_setlang(row, pstr, data) lcd_implementation_drawmenu_generic(row, pstr, ' ', ' ')
  1203. static void lcd_implementation_quick_feedback()
  1204. {
  1205. #ifdef LCD_USE_I2C_BUZZER
  1206. #if !defined(LCD_FEEDBACK_FREQUENCY_HZ) || !defined(LCD_FEEDBACK_FREQUENCY_DURATION_MS)
  1207. lcd_buzz(1000/6,100);
  1208. #else
  1209. lcd_buzz(LCD_FEEDBACK_FREQUENCY_DURATION_MS,LCD_FEEDBACK_FREQUENCY_HZ);
  1210. #endif
  1211. #elif defined(BEEPER) && BEEPER > -1
  1212. SET_OUTPUT(BEEPER);
  1213. #if !defined(LCD_FEEDBACK_FREQUENCY_HZ) || !defined(LCD_FEEDBACK_FREQUENCY_DURATION_MS)
  1214. for(int8_t i=0;i<10;i++)
  1215. {
  1216. WRITE(BEEPER,HIGH);
  1217. delayMicroseconds(100);
  1218. WRITE(BEEPER,LOW);
  1219. delayMicroseconds(100);
  1220. }
  1221. #else
  1222. for(int8_t i=0;i<(LCD_FEEDBACK_FREQUENCY_DURATION_MS / (1000 / LCD_FEEDBACK_FREQUENCY_HZ));i++)
  1223. {
  1224. WRITE(BEEPER,HIGH);
  1225. delayMicroseconds(1000000 / LCD_FEEDBACK_FREQUENCY_HZ / 2);
  1226. WRITE(BEEPER,LOW);
  1227. delayMicroseconds(1000000 / LCD_FEEDBACK_FREQUENCY_HZ / 2);
  1228. }
  1229. #endif
  1230. #endif
  1231. }
  1232. #ifdef LCD_HAS_STATUS_INDICATORS
  1233. static void lcd_implementation_update_indicators()
  1234. {
  1235. #if defined(LCD_I2C_PANELOLU2) || defined(LCD_I2C_VIKI)
  1236. //set the LEDS - referred to as backlights by the LiquidTWI2 library
  1237. static uint8_t ledsprev = 0;
  1238. uint8_t leds = 0;
  1239. if (target_temperature_bed > 0) leds |= LED_A;
  1240. if (target_temperature[0] > 0) leds |= LED_B;
  1241. if (fanSpeed) leds |= LED_C;
  1242. #if EXTRUDERS > 1
  1243. if (target_temperature[1] > 0) leds |= LED_C;
  1244. #endif
  1245. if (leds != ledsprev) {
  1246. lcd.setBacklight(leds);
  1247. ledsprev = leds;
  1248. }
  1249. #endif
  1250. }
  1251. #endif
  1252. #ifdef LCD_HAS_SLOW_BUTTONS
  1253. extern uint32_t blocking_enc;
  1254. static uint8_t lcd_implementation_read_slow_buttons()
  1255. {
  1256. #ifdef LCD_I2C_TYPE_MCP23017
  1257. uint8_t slow_buttons;
  1258. // Reading these buttons this is likely to be too slow to call inside interrupt context
  1259. // so they are called during normal lcd_update
  1260. slow_buttons = lcd.readButtons() << B_I2C_BTN_OFFSET;
  1261. #if defined(LCD_I2C_VIKI)
  1262. if(slow_buttons & (B_MI|B_RI)) { //LCD clicked
  1263. if(blocking_enc > millis()) {
  1264. slow_buttons &= ~(B_MI|B_RI); // Disable LCD clicked buttons if screen is updated
  1265. }
  1266. }
  1267. #endif
  1268. return slow_buttons;
  1269. #endif
  1270. }
  1271. #endif
  1272. #endif//ULTRA_LCD_IMPLEMENTATION_HITACHI_HD44780_H