ultralcd_implementation_hitachi_HD44780.h 40 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396
  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/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 "LiquidCrystalRus.h"
  174. #define LCD_CLASS LiquidCrystalRus
  175. #else
  176. #include "LiquidCrystal.h"
  177. #define LCD_CLASS LiquidCrystal
  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. #if 0 // Unused
  323. byte arrup[8] = {
  324. B00100,
  325. B01110,
  326. B11111,
  327. B00000,
  328. B00000,
  329. B00000,
  330. B00000,
  331. B00000
  332. };
  333. byte arrdown[8] = {
  334. B00000,
  335. B00000,
  336. B00000,
  337. B00000,
  338. B00000,
  339. B10001,
  340. B01010,
  341. B00100
  342. };
  343. #endif
  344. #if defined(LCD_PROGRESS_BAR) && defined(SDSUPPORT)
  345. static bool char_mode = false;
  346. byte progress[3][8] = { {
  347. B00000,
  348. B10000,
  349. B10000,
  350. B10000,
  351. B10000,
  352. B10000,
  353. B10000,
  354. B00000
  355. }, {
  356. B00000,
  357. B10100,
  358. B10100,
  359. B10100,
  360. B10100,
  361. B10100,
  362. B10100,
  363. B00000
  364. }, {
  365. B00000,
  366. B10101,
  367. B10101,
  368. B10101,
  369. B10101,
  370. B10101,
  371. B10101,
  372. B00000
  373. } };
  374. if (progress_bar_set != char_mode) {
  375. char_mode = progress_bar_set;
  376. lcd.createChar(LCD_STR_BEDTEMP[0], bedTemp);
  377. lcd.createChar(LCD_STR_DEGREE[0], degree);
  378. lcd.createChar(LCD_STR_THERMOMETER[0], thermometer);
  379. lcd.createChar(LCD_STR_FEEDRATE[0], feedrate);
  380. lcd.createChar(LCD_STR_CLOCK[0], clock);
  381. if (progress_bar_set) {
  382. // Progress bar characters for info screen
  383. for (int i=3; i--;) lcd.createChar(LCD_STR_PROGRESS[i], progress[i]);
  384. }
  385. else {
  386. // Custom characters for submenus
  387. lcd.createChar(LCD_STR_UPLEVEL[0], uplevel);
  388. lcd.createChar(LCD_STR_REFRESH[0], refresh);
  389. lcd.createChar(LCD_STR_FOLDER[0], folder);
  390. }
  391. }
  392. #else
  393. lcd.createChar(LCD_STR_BEDTEMP[0], bedTemp);
  394. lcd.createChar(LCD_STR_DEGREE[0], degree);
  395. lcd.createChar(LCD_STR_THERMOMETER[0], thermometer);
  396. lcd.createChar(LCD_STR_UPLEVEL[0], uplevel);
  397. lcd.createChar(LCD_STR_REFRESH[0], refresh);
  398. lcd.createChar(LCD_STR_FOLDER[0], folder);
  399. lcd.createChar(LCD_STR_FEEDRATE[0], feedrate);
  400. lcd.createChar(LCD_STR_CLOCK[0], clock);
  401. //lcd.createChar(LCD_STR_ARROW_UP[0], arrup);
  402. //lcd.createChar(LCD_STR_ARROW_DOWN[0], arrdown);
  403. #endif
  404. }
  405. void lcd_set_custom_characters_arrows()
  406. {
  407. byte arrdown[8] = {
  408. B00000,
  409. B00000,
  410. B00000,
  411. B00000,
  412. B00000,
  413. B10001,
  414. B01010,
  415. B00100
  416. };
  417. lcd.createChar(1, arrdown);
  418. }
  419. void lcd_set_custom_characters_progress()
  420. {
  421. byte progress[8] = {
  422. B11111,
  423. B11111,
  424. B11111,
  425. B11111,
  426. B11111,
  427. B11111,
  428. B11111,
  429. B11111,
  430. };
  431. lcd.createChar(1, progress);
  432. }
  433. void lcd_set_custom_characters_nextpage()
  434. {
  435. byte arrdown[8] = {
  436. B00000,
  437. B00000,
  438. B10001,
  439. B01010,
  440. B00100,
  441. B10001,
  442. B01010,
  443. B00100
  444. };
  445. byte confirm[8] = {
  446. B00000,
  447. B00001,
  448. B00011,
  449. B10110,
  450. B11100,
  451. B01000,
  452. B00000,
  453. B00000
  454. };
  455. lcd.createChar(1, arrdown);
  456. lcd.createChar(2, confirm);
  457. }
  458. void lcd_set_custom_characters_degree()
  459. {
  460. byte degree[8] = {
  461. B01100,
  462. B10010,
  463. B10010,
  464. B01100,
  465. B00000,
  466. B00000,
  467. B00000,
  468. B00000
  469. };
  470. lcd.createChar(1, degree);
  471. }
  472. static void lcd_implementation_init(
  473. #if defined(LCD_PROGRESS_BAR) && defined(SDSUPPORT)
  474. bool progress_bar_set=true
  475. #endif
  476. ) {
  477. #if defined(LCD_I2C_TYPE_PCF8575)
  478. lcd.begin(LCD_WIDTH, LCD_HEIGHT);
  479. #ifdef LCD_I2C_PIN_BL
  480. lcd.setBacklightPin(LCD_I2C_PIN_BL,POSITIVE);
  481. lcd.setBacklight(HIGH);
  482. #endif
  483. #elif defined(LCD_I2C_TYPE_MCP23017)
  484. lcd.setMCPType(LTI_TYPE_MCP23017);
  485. lcd.begin(LCD_WIDTH, LCD_HEIGHT);
  486. lcd.setBacklight(0); //set all the LEDs off to begin with
  487. #elif defined(LCD_I2C_TYPE_MCP23008)
  488. lcd.setMCPType(LTI_TYPE_MCP23008);
  489. lcd.begin(LCD_WIDTH, LCD_HEIGHT);
  490. #elif defined(LCD_I2C_TYPE_PCA8574)
  491. lcd.init();
  492. lcd.backlight();
  493. #else
  494. lcd.begin(LCD_WIDTH, LCD_HEIGHT);
  495. #endif
  496. lcd_set_custom_characters(
  497. #if defined(LCD_PROGRESS_BAR) && defined(SDSUPPORT)
  498. progress_bar_set
  499. #endif
  500. );
  501. lcd.clear();
  502. }
  503. static void lcd_implementation_init_noclear(
  504. #if defined(LCD_PROGRESS_BAR) && defined(SDSUPPORT)
  505. bool progress_bar_set=true
  506. #endif
  507. ) {
  508. #if defined(LCD_I2C_TYPE_PCF8575)
  509. lcd.begin_noclear(LCD_WIDTH, LCD_HEIGHT);
  510. #ifdef LCD_I2C_PIN_BL
  511. lcd.setBacklightPin(LCD_I2C_PIN_BL,POSITIVE);
  512. lcd.setBacklight(HIGH);
  513. #endif
  514. #elif defined(LCD_I2C_TYPE_MCP23017)
  515. lcd.setMCPType(LTI_TYPE_MCP23017);
  516. lcd.begin_noclear(LCD_WIDTH, LCD_HEIGHT);
  517. lcd.setBacklight(0); //set all the LEDs off to begin with
  518. #elif defined(LCD_I2C_TYPE_MCP23008)
  519. lcd.setMCPType(LTI_TYPE_MCP23008);
  520. lcd.begin_noclear(LCD_WIDTH, LCD_HEIGHT);
  521. #elif defined(LCD_I2C_TYPE_PCA8574)
  522. lcd.init();
  523. lcd.backlight();
  524. #else
  525. lcd.begin_noclear(LCD_WIDTH, LCD_HEIGHT);
  526. #endif
  527. lcd_set_custom_characters(
  528. #if defined(LCD_PROGRESS_BAR) && defined(SDSUPPORT)
  529. progress_bar_set
  530. #endif
  531. );
  532. }
  533. inline void lcd_implementation_nodisplay()
  534. {
  535. lcd.noDisplay();
  536. }
  537. inline void lcd_implementation_display()
  538. {
  539. lcd.display();
  540. }
  541. inline void lcd_implementation_clear()
  542. {
  543. lcd.clear();
  544. }
  545. /* Arduino < 1.0.0 is missing a function to print PROGMEM strings, so we need to implement our own */
  546. void lcd_printPGM(const char* str)
  547. {
  548. char c;
  549. while((c = pgm_read_byte(str++)) != '\0')
  550. {
  551. lcd.write(c);
  552. }
  553. }
  554. void lcd_print_at_PGM(uint8_t x, uint8_t y, const char* str)
  555. {
  556. lcd.setCursor(x, y);
  557. char c;
  558. while((c = pgm_read_byte(str++)) != '\0')
  559. {
  560. lcd.write(c);
  561. }
  562. }
  563. void lcd_implementation_write(char c)
  564. {
  565. lcd.write(c);
  566. }
  567. void lcd_implementation_print(int8_t i)
  568. {
  569. lcd.print(i);
  570. }
  571. void lcd_implementation_print_at(uint8_t x, uint8_t y, int8_t i)
  572. {
  573. lcd.setCursor(x, y);
  574. lcd.print(i);
  575. }
  576. void lcd_implementation_print(int i)
  577. {
  578. lcd.print(i);
  579. }
  580. void lcd_implementation_print_at(uint8_t x, uint8_t y, int i)
  581. {
  582. lcd.setCursor(x, y);
  583. lcd.print(i);
  584. }
  585. void lcd_implementation_print(float f)
  586. {
  587. lcd.print(f);
  588. }
  589. void lcd_implementation_print(const char *str)
  590. {
  591. lcd.print(str);
  592. }
  593. void lcd_implementation_print_at(uint8_t x, uint8_t y, const char *str)
  594. {
  595. lcd.setCursor(x, y);
  596. lcd.print(str);
  597. }
  598. /*
  599. 20x4 |01234567890123456789|
  600. |T 000/000D Z000.0 |
  601. |B 000/000D F100% |
  602. |SD100% T--:-- |
  603. |Status line.........|
  604. */
  605. static void lcd_implementation_status_screen()
  606. {
  607. int tHotend=int(degHotend(0) + 0.5);
  608. int tTarget=int(degTargetHotend(0) + 0.5);
  609. //Print the hotend temperature
  610. lcd.setCursor(0, 0);
  611. lcd.print(LCD_STR_THERMOMETER[0]);
  612. lcd.print(itostr3(tHotend));
  613. lcd.print('/');
  614. lcd.print(itostr3left(tTarget));
  615. lcd_printPGM(PSTR(LCD_STR_DEGREE " "));
  616. lcd_printPGM(PSTR(" "));
  617. //Print the Z coordinates
  618. lcd.setCursor(LCD_WIDTH - 8-2, 0);
  619. #if 1
  620. lcd_printPGM(PSTR(" Z"));
  621. if (custom_message_type == 1) {
  622. // In a bed calibration mode.
  623. lcd_printPGM(PSTR(" --- "));
  624. } else {
  625. lcd.print(ftostr32sp(current_position[Z_AXIS] + 0.00001));
  626. lcd.print(' ');
  627. }
  628. #else
  629. lcd_printPGM(PSTR(" Queue:"));
  630. lcd.print(int(moves_planned()));
  631. lcd.print(' ');
  632. #endif
  633. //Print the Bedtemperature
  634. lcd.setCursor(0, 1);
  635. tHotend=int(degBed() + 0.5);
  636. tTarget=int(degTargetBed() + 0.5);
  637. lcd.print(LCD_STR_BEDTEMP[0]);
  638. lcd.print(itostr3(tHotend));
  639. lcd.print('/');
  640. lcd.print(itostr3left(tTarget));
  641. lcd_printPGM(PSTR(LCD_STR_DEGREE " "));
  642. lcd_printPGM(PSTR(" "));
  643. #if 1
  644. //Print Feedrate
  645. lcd.setCursor(LCD_WIDTH - 8-2, 1);
  646. lcd_printPGM(PSTR(" "));
  647. lcd.print(LCD_STR_FEEDRATE[0]);
  648. lcd.print(itostr3(feedmultiply));
  649. lcd_printPGM(PSTR("% "));
  650. #else
  651. //Print Feedrate
  652. lcd.setCursor(LCD_WIDTH - 8-2, 1);
  653. lcd.print(LCD_STR_FEEDRATE[0]);
  654. lcd.print(itostr3(feedmultiply));
  655. lcd_printPGM(PSTR("% Q"));
  656. {
  657. uint8_t queue = planner_queue_min();
  658. if (queue < (BLOCK_BUFFER_SIZE >> 1)) {
  659. lcd.print('!');
  660. } else {
  661. lcd.print((char)(queue / 10) + '0');
  662. queue %= 10;
  663. }
  664. lcd.print((char)queue + '0');
  665. planner_queue_min_reset();
  666. }
  667. #endif
  668. //Print SD status
  669. lcd.setCursor(0, 2);
  670. if (is_usb_printing)
  671. {
  672. lcd_printPGM(PSTR("--"));
  673. }
  674. else
  675. {
  676. lcd_printPGM(PSTR("SD"));
  677. }
  678. if (IS_SD_PRINTING)
  679. {
  680. lcd.print(itostr3(card.percentDone()));
  681. lcd.print('%');
  682. }
  683. else
  684. {
  685. if (is_usb_printing)
  686. {
  687. lcd_printPGM(PSTR(">USB"));
  688. }
  689. else
  690. {
  691. lcd_printPGM(PSTR("---"));
  692. lcd.print('%');
  693. }
  694. }
  695. // Farm number display
  696. if (farm_mode)
  697. {
  698. lcd_printPGM(PSTR(" F"));
  699. lcd.print(farm_no);
  700. lcd_printPGM(PSTR(" "));
  701. // Beat display
  702. lcd.setCursor(LCD_WIDTH - 1, 0);
  703. if ( (millis() - kicktime) < 60000 ) {
  704. lcd_printPGM(PSTR("L"));
  705. }else{
  706. lcd_printPGM(PSTR(" "));
  707. }
  708. }
  709. else {
  710. #ifdef SNMM
  711. lcd_printPGM(PSTR(" E"));
  712. lcd.print(get_ext_nr() + 1);
  713. #else
  714. lcd.setCursor(LCD_WIDTH - 8 - 2, 2);
  715. lcd_printPGM(PSTR(" "));
  716. #endif
  717. }
  718. //Print time elapsed
  719. lcd.setCursor(LCD_WIDTH - 8 -1, 2);
  720. lcd_printPGM(PSTR(" "));
  721. lcd.print(LCD_STR_CLOCK[0]);
  722. if(starttime != 0)
  723. {
  724. uint16_t time = millis() / 60000 - starttime / 60000;
  725. lcd.print(itostr2(time/60));
  726. lcd.print(':');
  727. lcd.print(itostr2(time%60));
  728. }else{
  729. lcd_printPGM(PSTR("--:--"));
  730. }
  731. lcd_printPGM(PSTR(" "));
  732. #ifdef DEBUG_DISABLE_LCD_STATUS_LINE
  733. return;
  734. #endif //DEBUG_DISABLE_LCD_STATUS_LINE
  735. //Print status line
  736. lcd.setCursor(0, 3);
  737. // If heating in progress, set flag
  738. if (heating_status != 0) { custom_message = true; }
  739. if (IS_SD_PRINTING) {
  740. if (strcmp(longFilenameOLD, card.longFilename) != 0)
  741. {
  742. memset(longFilenameOLD, '\0', strlen(longFilenameOLD));
  743. sprintf_P(longFilenameOLD, PSTR("%s"), card.longFilename);
  744. scrollstuff = 0;
  745. }
  746. }
  747. // If printing from SD, show what we are printing
  748. if (IS_SD_PRINTING && !custom_message)
  749. {
  750. if (strlen(card.longFilename) > LCD_WIDTH)
  751. {
  752. int inters = 0;
  753. int gh = scrollstuff;
  754. while (((gh - scrollstuff) < LCD_WIDTH) && (inters == 0))
  755. {
  756. if (card.longFilename[gh] == '\0')
  757. {
  758. lcd.setCursor(gh - scrollstuff, 3);
  759. lcd.print(card.longFilename[gh - 1]);
  760. scrollstuff = 0;
  761. gh = scrollstuff;
  762. inters = 1;
  763. }
  764. else
  765. {
  766. lcd.setCursor(gh - scrollstuff, 3);
  767. lcd.print(card.longFilename[gh - 1]);
  768. gh++;
  769. }
  770. }
  771. scrollstuff++;
  772. }
  773. else
  774. {
  775. lcd.print(longFilenameOLD);
  776. }
  777. }
  778. // If not, check for other special events
  779. else
  780. {
  781. if (custom_message)
  782. {
  783. // If heating flag, show progress of heating.
  784. if (heating_status != 0)
  785. {
  786. heating_status_counter++;
  787. if (heating_status_counter > 13)
  788. {
  789. heating_status_counter = 0;
  790. }
  791. lcd.setCursor(7, 3);
  792. lcd_printPGM(PSTR(" "));
  793. for (uint16_t dots = 0; dots < heating_status_counter; dots++)
  794. {
  795. lcd.setCursor(7 + dots, 3);
  796. lcd.print('.');
  797. }
  798. switch (heating_status)
  799. {
  800. case 1:
  801. lcd.setCursor(0, 3);
  802. lcd_printPGM(MSG_HEATING);
  803. break;
  804. case 2:
  805. lcd.setCursor(0, 3);
  806. lcd_printPGM(MSG_HEATING_COMPLETE);
  807. heating_status = 0;
  808. heating_status_counter = 0;
  809. custom_message = false;
  810. break;
  811. case 3:
  812. lcd.setCursor(0, 3);
  813. lcd_printPGM(MSG_BED_HEATING);
  814. break;
  815. case 4:
  816. lcd.setCursor(0, 3);
  817. lcd_printPGM(MSG_BED_DONE);
  818. heating_status = 0;
  819. heating_status_counter = 0;
  820. custom_message = false;
  821. break;
  822. default:
  823. break;
  824. }
  825. }
  826. // If mesh bed leveling in progress, show the status
  827. if (custom_message_type == 1)
  828. {
  829. if (custom_message_state > 10)
  830. {
  831. lcd.setCursor(0, 3);
  832. lcd_printPGM(PSTR(" "));
  833. lcd.setCursor(0, 3);
  834. lcd_printPGM(MSG_HOMEYZ_PROGRESS);
  835. lcd_printPGM(PSTR(" : "));
  836. lcd.print(custom_message_state-10);
  837. }
  838. else
  839. {
  840. if (custom_message_state == 3)
  841. {
  842. lcd_printPGM(WELCOME_MSG);
  843. lcd_setstatuspgm(WELCOME_MSG);
  844. custom_message = false;
  845. custom_message_type = 0;
  846. }
  847. if (custom_message_state > 3 && custom_message_state < 10 )
  848. {
  849. lcd.setCursor(0, 3);
  850. lcd_printPGM(PSTR(" "));
  851. lcd.setCursor(0, 3);
  852. lcd_printPGM(MSG_HOMEYZ_DONE);
  853. custom_message_state--;
  854. }
  855. if (custom_message_state == 10)
  856. {
  857. lcd_printPGM(MSG_HOMEYZ_DONE);
  858. custom_message_state = 9;
  859. }
  860. }
  861. }
  862. // If loading filament, print status
  863. if (custom_message_type == 2)
  864. {
  865. lcd.print(lcd_status_message);
  866. }
  867. // PID tuning in progress
  868. if (custom_message_type == 3) {
  869. lcd.print(lcd_status_message);
  870. if (pid_cycle <= pid_number_of_cycles && custom_message_state > 0) {
  871. lcd.setCursor(10, 3);
  872. lcd.print(itostr3(pid_cycle));
  873. lcd.print('/');
  874. lcd.print(itostr3left(pid_number_of_cycles));
  875. }
  876. }
  877. // PINDA temp calibration in progress
  878. if (custom_message_type == 4) {
  879. char progress[4];
  880. lcd.setCursor(0, 3);
  881. lcd_printPGM(MSG_TEMP_CALIBRATION);
  882. lcd.setCursor(12, 3);
  883. sprintf(progress, "%d/6", custom_message_state);
  884. lcd.print(progress);
  885. }
  886. // temp compensation preheat
  887. if (custom_message_type == 5) {
  888. lcd.setCursor(0, 3);
  889. lcd_printPGM(MSG_PINDA_PREHEAT);
  890. if (custom_message_state <= PINDA_HEAT_T) {
  891. lcd_printPGM(PSTR(": "));
  892. lcd.print(custom_message_state); //seconds
  893. lcd.print(' ');
  894. }
  895. }
  896. }
  897. else
  898. {
  899. // Nothing special, print status message normally
  900. lcd.print(lcd_status_message);
  901. }
  902. }
  903. // Fill the rest of line to have nice and clean output
  904. for(int fillspace = 0; fillspace<20;fillspace++)
  905. {
  906. if((lcd_status_message[fillspace] > 31 ))
  907. {
  908. }
  909. else
  910. {
  911. lcd.print(' ');
  912. }
  913. }
  914. }
  915. static void lcd_implementation_drawmenu_generic(uint8_t row, const char* pstr, char pre_char, char post_char)
  916. {
  917. char c;
  918. //Use all characters in narrow LCDs
  919. #if LCD_WIDTH < 20
  920. uint8_t n = LCD_WIDTH - 1 - 1;
  921. #else
  922. uint8_t n = LCD_WIDTH - 1 - 2;
  923. #endif
  924. lcd.setCursor(0, row);
  925. lcd.print(pre_char);
  926. while( ((c = pgm_read_byte(pstr)) != '\0') && (n>0) )
  927. {
  928. lcd.print(c);
  929. pstr++;
  930. n--;
  931. }
  932. while(n--)
  933. lcd.print(' ');
  934. lcd.print(post_char);
  935. lcd.print(' ');
  936. }
  937. static void lcd_implementation_drawmenu_generic_RAM(uint8_t row, const char* str, char pre_char, char post_char)
  938. {
  939. char c;
  940. //Use all characters in narrow LCDs
  941. #if LCD_WIDTH < 20
  942. uint8_t n = LCD_WIDTH - 1 - 1;
  943. #else
  944. uint8_t n = LCD_WIDTH - 1 - 2;
  945. #endif
  946. lcd.setCursor(0, row);
  947. lcd.print(pre_char);
  948. while( ((c = *str) != '\0') && (n>0) )
  949. {
  950. lcd.print(c);
  951. str++;
  952. n--;
  953. }
  954. while(n--)
  955. lcd.print(' ');
  956. lcd.print(post_char);
  957. lcd.print(' ');
  958. }
  959. static void lcd_implementation_drawmenu_setting_edit_generic(uint8_t row, const char* pstr, char pre_char, char* data)
  960. {
  961. char c;
  962. //Use all characters in narrow LCDs
  963. #if LCD_WIDTH < 20
  964. uint8_t n = LCD_WIDTH - 1 - 1 - strlen(data);
  965. #else
  966. uint8_t n = LCD_WIDTH - 1 - 2 - strlen(data);
  967. #endif
  968. lcd.setCursor(0, row);
  969. lcd.print(pre_char);
  970. while( ((c = pgm_read_byte(pstr)) != '\0') && (n>0) )
  971. {
  972. lcd.print(c);
  973. pstr++;
  974. n--;
  975. }
  976. lcd.print(':');
  977. while(n--)
  978. lcd.print(' ');
  979. lcd.print(data);
  980. }
  981. #if 0
  982. static void lcd_implementation_drawmenu_setting_edit_generic_P(uint8_t row, const char* pstr, char pre_char, const char* data)
  983. {
  984. char c;
  985. //Use all characters in narrow LCDs
  986. #if LCD_WIDTH < 20
  987. uint8_t n = LCD_WIDTH - 1 - 1 - strlen_P(data);
  988. #else
  989. uint8_t n = LCD_WIDTH - 1 - 2 - strlen_P(data);
  990. #endif
  991. lcd.setCursor(0, row);
  992. lcd.print(pre_char);
  993. while( ((c = pgm_read_byte(pstr)) != '\0') && (n>0) )
  994. {
  995. lcd.print(c);
  996. pstr++;
  997. n--;
  998. }
  999. lcd.print(':');
  1000. while(n--)
  1001. lcd.print(' ');
  1002. lcd_printPGM(data);
  1003. }
  1004. #endif
  1005. #define lcd_implementation_drawmenu_setting_edit_int3_selected(row, pstr, pstr2, data, minValue, maxValue) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, '>', itostr3(*(data)))
  1006. #define lcd_implementation_drawmenu_setting_edit_int3(row, pstr, pstr2, data, minValue, maxValue) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, ' ', itostr3(*(data)))
  1007. #define lcd_implementation_drawmenu_setting_edit_float3_selected(row, pstr, pstr2, data, minValue, maxValue) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, '>', ftostr3(*(data)))
  1008. #define lcd_implementation_drawmenu_setting_edit_float3(row, pstr, pstr2, data, minValue, maxValue) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, ' ', ftostr3(*(data)))
  1009. #define lcd_implementation_drawmenu_setting_edit_float32_selected(row, pstr, pstr2, data, minValue, maxValue) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, '>', ftostr32(*(data)))
  1010. #define lcd_implementation_drawmenu_setting_edit_float32(row, pstr, pstr2, data, minValue, maxValue) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, ' ', ftostr32(*(data)))
  1011. #define lcd_implementation_drawmenu_setting_edit_float43_selected(row, pstr, pstr2, data, minValue, maxValue) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, '>', ftostr43(*(data)))
  1012. #define lcd_implementation_drawmenu_setting_edit_float43(row, pstr, pstr2, data, minValue, maxValue) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, ' ', ftostr43(*(data)))
  1013. #define lcd_implementation_drawmenu_setting_edit_float5_selected(row, pstr, pstr2, data, minValue, maxValue) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, '>', ftostr5(*(data)))
  1014. #define lcd_implementation_drawmenu_setting_edit_float5(row, pstr, pstr2, data, minValue, maxValue) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, ' ', ftostr5(*(data)))
  1015. #define lcd_implementation_drawmenu_setting_edit_float52_selected(row, pstr, pstr2, data, minValue, maxValue) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, '>', ftostr52(*(data)))
  1016. #define lcd_implementation_drawmenu_setting_edit_float52(row, pstr, pstr2, data, minValue, maxValue) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, ' ', ftostr52(*(data)))
  1017. #define lcd_implementation_drawmenu_setting_edit_float51_selected(row, pstr, pstr2, data, minValue, maxValue) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, '>', ftostr51(*(data)))
  1018. #define lcd_implementation_drawmenu_setting_edit_float51(row, pstr, pstr2, data, minValue, maxValue) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, ' ', ftostr51(*(data)))
  1019. #define lcd_implementation_drawmenu_setting_edit_long5_selected(row, pstr, pstr2, data, minValue, maxValue) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, '>', ftostr5(*(data)))
  1020. #define lcd_implementation_drawmenu_setting_edit_long5(row, pstr, pstr2, data, minValue, maxValue) lcd_implementation_drawmenu_setting_edit_generic(row, pstr, ' ', ftostr5(*(data)))
  1021. #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))
  1022. #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))
  1023. //Add version for callback functions
  1024. #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)))
  1025. #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)))
  1026. #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)))
  1027. #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)))
  1028. #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)))
  1029. #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)))
  1030. #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)))
  1031. #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)))
  1032. #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)))
  1033. #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)))
  1034. #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)))
  1035. #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)))
  1036. #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)))
  1037. #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)))
  1038. #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)))
  1039. #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)))
  1040. #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))
  1041. #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))
  1042. void lcd_implementation_drawedit(const char* pstr, char* value)
  1043. {
  1044. lcd.setCursor(1, 1);
  1045. lcd_printPGM(pstr);
  1046. lcd.print(':');
  1047. #if LCD_WIDTH < 20
  1048. lcd.setCursor(LCD_WIDTH - strlen(value), 1);
  1049. #else
  1050. lcd.setCursor(LCD_WIDTH -1 - strlen(value), 1);
  1051. #endif
  1052. lcd.print(value);
  1053. }
  1054. void lcd_implementation_drawedit_2(const char* pstr, char* value)
  1055. {
  1056. lcd.setCursor(0, 1);
  1057. lcd_printPGM(pstr);
  1058. lcd.print(':');
  1059. lcd.setCursor((LCD_WIDTH - strlen(value))/2, 3);
  1060. lcd.print(value);
  1061. lcd.print(" mm");
  1062. }
  1063. static void lcd_implementation_drawmenu_sdfile_selected(uint8_t row, const char* pstr, const char* filename, char* longFilename)
  1064. {
  1065. char c;
  1066. int enc_dif = encoderDiff;
  1067. uint8_t n = LCD_WIDTH - 1;
  1068. for(int g = 0; g<4;g++){
  1069. lcd.setCursor(0, g);
  1070. lcd.print(' ');
  1071. }
  1072. lcd.setCursor(0, row);
  1073. lcd.print('>');
  1074. int i = 1;
  1075. int j = 0;
  1076. char* longFilenameTMP = longFilename;
  1077. while((c = *longFilenameTMP) != '\0')
  1078. {
  1079. lcd.setCursor(i, row);
  1080. lcd.print(c);
  1081. i++;
  1082. longFilenameTMP++;
  1083. if(i==LCD_WIDTH) {
  1084. i=1;
  1085. j++;
  1086. longFilenameTMP = longFilename + j;
  1087. n = LCD_WIDTH - 1;
  1088. for(int g = 0; g<300 ;g++){
  1089. if(LCD_CLICKED || ( enc_dif != encoderDiff )){
  1090. longFilenameTMP = longFilename;
  1091. *(longFilenameTMP + LCD_WIDTH - 2) = '\0';
  1092. i = 1;
  1093. j = 0;
  1094. break;
  1095. }else{
  1096. if (j == 1) delay(3); //wait around 1.2 s to start scrolling text
  1097. delay(1); //then scroll with redrawing every 300 ms
  1098. }
  1099. }
  1100. }
  1101. }
  1102. if(c!='\0'){
  1103. lcd.setCursor(i, row);
  1104. lcd.print(c);
  1105. i++;
  1106. }
  1107. n=n-i+1;
  1108. while(n--)
  1109. lcd.print(' ');
  1110. }
  1111. static void lcd_implementation_drawmenu_sdfile(uint8_t row, const char* pstr, const char* filename, char* longFilename)
  1112. {
  1113. char c;
  1114. uint8_t n = LCD_WIDTH - 1;
  1115. lcd.setCursor(0, row);
  1116. lcd.print(' ');
  1117. if (longFilename[0] != '\0')
  1118. {
  1119. filename = longFilename;
  1120. longFilename[LCD_WIDTH-1] = '\0';
  1121. }
  1122. while( ((c = *filename) != '\0') && (n>0) )
  1123. {
  1124. lcd.print(c);
  1125. filename++;
  1126. n--;
  1127. }
  1128. while(n--)
  1129. lcd.print(' ');
  1130. }
  1131. static void lcd_implementation_drawmenu_sddirectory_selected(uint8_t row, const char* pstr, const char* filename, char* longFilename)
  1132. {
  1133. char c;
  1134. uint8_t n = LCD_WIDTH - 2;
  1135. lcd.setCursor(0, row);
  1136. lcd.print('>');
  1137. lcd.print(LCD_STR_FOLDER[0]);
  1138. if (longFilename[0] != '\0')
  1139. {
  1140. filename = longFilename;
  1141. longFilename[LCD_WIDTH-2] = '\0';
  1142. }
  1143. while( ((c = *filename) != '\0') && (n>0) )
  1144. {
  1145. lcd.print(c);
  1146. filename++;
  1147. n--;
  1148. }
  1149. while(n--)
  1150. lcd.print(' ');
  1151. }
  1152. static void lcd_implementation_drawmenu_sddirectory(uint8_t row, const char* pstr, const char* filename, char* longFilename)
  1153. {
  1154. char c;
  1155. uint8_t n = LCD_WIDTH - 2;
  1156. lcd.setCursor(0, row);
  1157. lcd.print(' ');
  1158. lcd.print(LCD_STR_FOLDER[0]);
  1159. if (longFilename[0] != '\0')
  1160. {
  1161. filename = longFilename;
  1162. longFilename[LCD_WIDTH-2] = '\0';
  1163. }
  1164. while( ((c = *filename) != '\0') && (n>0) )
  1165. {
  1166. lcd.print(c);
  1167. filename++;
  1168. n--;
  1169. }
  1170. while(n--)
  1171. lcd.print(' ');
  1172. }
  1173. #define lcd_implementation_drawmenu_back_selected(row, pstr, data) lcd_implementation_drawmenu_generic(row, pstr, LCD_STR_UPLEVEL[0], LCD_STR_UPLEVEL[0])
  1174. #define lcd_implementation_drawmenu_back(row, pstr, data) lcd_implementation_drawmenu_generic(row, pstr, ' ', LCD_STR_UPLEVEL[0])
  1175. #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])
  1176. #define lcd_implementation_drawmenu_back_RAM(row, str, data) lcd_implementation_drawmenu_generic_RAM(row, str, ' ', LCD_STR_UPLEVEL[0])
  1177. #define lcd_implementation_drawmenu_submenu_selected(row, pstr, data) lcd_implementation_drawmenu_generic(row, pstr, '>', LCD_STR_ARROW_RIGHT[0])
  1178. #define lcd_implementation_drawmenu_submenu(row, pstr, data) lcd_implementation_drawmenu_generic(row, pstr, ' ', LCD_STR_ARROW_RIGHT[0])
  1179. #define lcd_implementation_drawmenu_gcode_selected(row, pstr, gcode) lcd_implementation_drawmenu_generic(row, pstr, '>', ' ')
  1180. #define lcd_implementation_drawmenu_gcode(row, pstr, gcode) lcd_implementation_drawmenu_generic(row, pstr, ' ', ' ')
  1181. #define lcd_implementation_drawmenu_function_selected(row, pstr, data) lcd_implementation_drawmenu_generic(row, pstr, '>', ' ')
  1182. #define lcd_implementation_drawmenu_function(row, pstr, data) lcd_implementation_drawmenu_generic(row, pstr, ' ', ' ')
  1183. #define lcd_implementation_drawmenu_setlang_selected(row, pstr, data) lcd_implementation_drawmenu_generic(row, pstr, '>', ' ')
  1184. #define lcd_implementation_drawmenu_setlang(row, pstr, data) lcd_implementation_drawmenu_generic(row, pstr, ' ', ' ')
  1185. static void lcd_implementation_quick_feedback()
  1186. {
  1187. #ifdef LCD_USE_I2C_BUZZER
  1188. #if !defined(LCD_FEEDBACK_FREQUENCY_HZ) || !defined(LCD_FEEDBACK_FREQUENCY_DURATION_MS)
  1189. lcd_buzz(1000/6,100);
  1190. #else
  1191. lcd_buzz(LCD_FEEDBACK_FREQUENCY_DURATION_MS,LCD_FEEDBACK_FREQUENCY_HZ);
  1192. #endif
  1193. #elif defined(BEEPER) && BEEPER > -1
  1194. SET_OUTPUT(BEEPER);
  1195. #if !defined(LCD_FEEDBACK_FREQUENCY_HZ) || !defined(LCD_FEEDBACK_FREQUENCY_DURATION_MS)
  1196. for(int8_t i=0;i<10;i++)
  1197. {
  1198. WRITE(BEEPER,HIGH);
  1199. delayMicroseconds(100);
  1200. WRITE(BEEPER,LOW);
  1201. delayMicroseconds(100);
  1202. }
  1203. #else
  1204. for(int8_t i=0;i<(LCD_FEEDBACK_FREQUENCY_DURATION_MS / (1000 / LCD_FEEDBACK_FREQUENCY_HZ));i++)
  1205. {
  1206. WRITE(BEEPER,HIGH);
  1207. delayMicroseconds(1000000 / LCD_FEEDBACK_FREQUENCY_HZ / 2);
  1208. WRITE(BEEPER,LOW);
  1209. delayMicroseconds(1000000 / LCD_FEEDBACK_FREQUENCY_HZ / 2);
  1210. }
  1211. #endif
  1212. #endif
  1213. }
  1214. #ifdef LCD_HAS_STATUS_INDICATORS
  1215. static void lcd_implementation_update_indicators()
  1216. {
  1217. #if defined(LCD_I2C_PANELOLU2) || defined(LCD_I2C_VIKI)
  1218. //set the LEDS - referred to as backlights by the LiquidTWI2 library
  1219. static uint8_t ledsprev = 0;
  1220. uint8_t leds = 0;
  1221. if (target_temperature_bed > 0) leds |= LED_A;
  1222. if (target_temperature[0] > 0) leds |= LED_B;
  1223. if (fanSpeed) leds |= LED_C;
  1224. #if EXTRUDERS > 1
  1225. if (target_temperature[1] > 0) leds |= LED_C;
  1226. #endif
  1227. if (leds != ledsprev) {
  1228. lcd.setBacklight(leds);
  1229. ledsprev = leds;
  1230. }
  1231. #endif
  1232. }
  1233. #endif
  1234. #ifdef LCD_HAS_SLOW_BUTTONS
  1235. extern uint32_t blocking_enc;
  1236. static uint8_t lcd_implementation_read_slow_buttons()
  1237. {
  1238. #ifdef LCD_I2C_TYPE_MCP23017
  1239. uint8_t slow_buttons;
  1240. // Reading these buttons this is likely to be too slow to call inside interrupt context
  1241. // so they are called during normal lcd_update
  1242. slow_buttons = lcd.readButtons() << B_I2C_BTN_OFFSET;
  1243. #if defined(LCD_I2C_VIKI)
  1244. if(slow_buttons & (B_MI|B_RI)) { //LCD clicked
  1245. if(blocking_enc > millis()) {
  1246. slow_buttons &= ~(B_MI|B_RI); // Disable LCD clicked buttons if screen is updated
  1247. }
  1248. }
  1249. #endif
  1250. return slow_buttons;
  1251. #endif
  1252. }
  1253. #endif
  1254. #endif//ULTRA_LCD_IMPLEMENTATION_HITACHI_HD44780_H