ultralcd_implementation_hitachi_HD44780.h 38 KB

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