lcd.cpp 23 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048
  1. //menu.cpp
  2. #include "lcd.h"
  3. #include <stdio.h>
  4. #include <stdarg.h>
  5. #include <avr/pgmspace.h>
  6. #include <util/delay.h>
  7. #include "Timer.h"
  8. #include "Configuration.h"
  9. #include "pins.h"
  10. #include <binary.h>
  11. //#include <Arduino.h>
  12. #include "Marlin.h"
  13. #include "fastio.h"
  14. //-//
  15. #include "sound.h"
  16. // commands
  17. #define LCD_CLEARDISPLAY 0x01
  18. #define LCD_RETURNHOME 0x02
  19. #define LCD_ENTRYMODESET 0x04
  20. #define LCD_DISPLAYCONTROL 0x08
  21. #define LCD_CURSORSHIFT 0x10
  22. #define LCD_FUNCTIONSET 0x20
  23. #define LCD_SETCGRAMADDR 0x40
  24. #define LCD_SETDDRAMADDR 0x80
  25. // flags for display entry mode
  26. #define LCD_ENTRYRIGHT 0x00
  27. #define LCD_ENTRYLEFT 0x02
  28. #define LCD_ENTRYSHIFTINCREMENT 0x01
  29. #define LCD_ENTRYSHIFTDECREMENT 0x00
  30. // flags for display on/off control
  31. #define LCD_DISPLAYON 0x04
  32. #define LCD_DISPLAYOFF 0x00
  33. #define LCD_CURSORON 0x02
  34. #define LCD_CURSOROFF 0x00
  35. #define LCD_BLINKON 0x01
  36. #define LCD_BLINKOFF 0x00
  37. // flags for display/cursor shift
  38. #define LCD_DISPLAYMOVE 0x08
  39. #define LCD_CURSORMOVE 0x00
  40. #define LCD_MOVERIGHT 0x04
  41. #define LCD_MOVELEFT 0x00
  42. // flags for function set
  43. #define LCD_8BITMODE 0x10
  44. #define LCD_4BITMODE 0x00
  45. #define LCD_2LINE 0x08
  46. #define LCD_1LINE 0x00
  47. #define LCD_5x10DOTS 0x04
  48. #define LCD_5x8DOTS 0x00
  49. FILE _lcdout; // = {0}; Global variable is always zero initialized, no need to explicitly state that.
  50. uint8_t lcd_rs_pin; // LOW: command. HIGH: character.
  51. uint8_t lcd_rw_pin; // LOW: write to LCD. HIGH: read from LCD.
  52. uint8_t lcd_enable_pin; // activated by a HIGH pulse.
  53. uint8_t lcd_data_pins[8];
  54. uint8_t lcd_displayfunction;
  55. uint8_t lcd_displaycontrol;
  56. uint8_t lcd_displaymode;
  57. uint8_t lcd_numlines;
  58. uint8_t lcd_currline;
  59. uint8_t lcd_escape[8];
  60. void lcd_pulseEnable(void)
  61. {
  62. digitalWrite(lcd_enable_pin, LOW);
  63. delayMicroseconds(1);
  64. digitalWrite(lcd_enable_pin, HIGH);
  65. delayMicroseconds(1); // enable pulse must be >450ns
  66. digitalWrite(lcd_enable_pin, LOW);
  67. delayMicroseconds(100); // commands need > 37us to settle
  68. }
  69. void lcd_write4bits(uint8_t value)
  70. {
  71. for (int i = 0; i < 4; i++)
  72. {
  73. pinMode(lcd_data_pins[i], OUTPUT);
  74. digitalWrite(lcd_data_pins[i], (value >> i) & 0x01);
  75. }
  76. lcd_pulseEnable();
  77. }
  78. void lcd_write8bits(uint8_t value)
  79. {
  80. for (int i = 0; i < 8; i++)
  81. {
  82. pinMode(lcd_data_pins[i], OUTPUT);
  83. digitalWrite(lcd_data_pins[i], (value >> i) & 0x01);
  84. }
  85. lcd_pulseEnable();
  86. }
  87. // write either command or data, with automatic 4/8-bit selection
  88. void lcd_send(uint8_t value, uint8_t mode)
  89. {
  90. digitalWrite(lcd_rs_pin, mode);
  91. // if there is a RW pin indicated, set it low to Write
  92. if (lcd_rw_pin != 255) digitalWrite(lcd_rw_pin, LOW);
  93. if (lcd_displayfunction & LCD_8BITMODE)
  94. lcd_write8bits(value);
  95. else
  96. {
  97. lcd_write4bits(value>>4);
  98. lcd_write4bits(value);
  99. }
  100. }
  101. void lcd_command(uint8_t value)
  102. {
  103. lcd_send(value, LOW);
  104. }
  105. void lcd_clear(void);
  106. void lcd_home(void);
  107. void lcd_no_display(void);
  108. void lcd_display(void);
  109. void lcd_no_cursor(void);
  110. void lcd_cursor(void);
  111. void lcd_no_blink(void);
  112. void lcd_blink(void);
  113. void lcd_scrollDisplayLeft(void);
  114. void lcd_scrollDisplayRight(void);
  115. void lcd_leftToRight(void);
  116. void lcd_rightToLeft(void);
  117. void lcd_autoscroll(void);
  118. void lcd_no_autoscroll(void);
  119. void lcd_set_cursor(uint8_t col, uint8_t row);
  120. void lcd_createChar_P(uint8_t location, const uint8_t* charmap);
  121. uint8_t lcd_escape_write(uint8_t chr);
  122. uint8_t lcd_write(uint8_t value)
  123. {
  124. if (value == '\n')
  125. {
  126. if (lcd_currline > 3) lcd_currline = -1;
  127. lcd_set_cursor(0, lcd_currline + 1); // LF
  128. return 1;
  129. }
  130. if (lcd_escape[0] || (value == 0x1b))
  131. return lcd_escape_write(value);
  132. lcd_send(value, HIGH);
  133. return 1; // assume sucess
  134. }
  135. static void lcd_begin(uint8_t lines, uint8_t dotsize, uint8_t clear)
  136. {
  137. if (lines > 1) lcd_displayfunction |= LCD_2LINE;
  138. lcd_numlines = lines;
  139. lcd_currline = 0;
  140. // for some 1 line displays you can select a 10 pixel high font
  141. if ((dotsize != 0) && (lines == 1)) lcd_displayfunction |= LCD_5x10DOTS;
  142. // SEE PAGE 45/46 FOR INITIALIZATION SPECIFICATION!
  143. // according to datasheet, we need at least 40ms after power rises above 2.7V
  144. // before sending commands. Arduino can turn on way befer 4.5V so we'll wait 50
  145. _delay_us(50000);
  146. // Now we pull both RS and R/W low to begin commands
  147. digitalWrite(lcd_rs_pin, LOW);
  148. digitalWrite(lcd_enable_pin, LOW);
  149. if (lcd_rw_pin != 255)
  150. digitalWrite(lcd_rw_pin, LOW);
  151. //put the LCD into 4 bit or 8 bit mode
  152. if (!(lcd_displayfunction & LCD_8BITMODE))
  153. {
  154. // this is according to the hitachi HD44780 datasheet
  155. // figure 24, pg 46
  156. // we start in 8bit mode, try to set 4 bit mode
  157. lcd_write4bits(0x03);
  158. _delay_us(4500); // wait min 4.1ms
  159. // second try
  160. lcd_write4bits(0x03);
  161. _delay_us(4500); // wait min 4.1ms
  162. // third go!
  163. lcd_write4bits(0x03);
  164. _delay_us(150);
  165. // finally, set to 4-bit interface
  166. lcd_write4bits(0x02);
  167. }
  168. else
  169. {
  170. // this is according to the hitachi HD44780 datasheet
  171. // page 45 figure 23
  172. // Send function set command sequence
  173. lcd_command(LCD_FUNCTIONSET | lcd_displayfunction);
  174. _delay_us(4500); // wait more than 4.1ms
  175. // second try
  176. lcd_command(LCD_FUNCTIONSET | lcd_displayfunction);
  177. _delay_us(150);
  178. // third go
  179. lcd_command(LCD_FUNCTIONSET | lcd_displayfunction);
  180. }
  181. // finally, set # lines, font size, etc.
  182. lcd_command(LCD_FUNCTIONSET | lcd_displayfunction);
  183. _delay_us(60);
  184. // turn the display on with no cursor or blinking default
  185. lcd_displaycontrol = LCD_DISPLAYON | LCD_CURSOROFF | LCD_BLINKOFF;
  186. lcd_display();
  187. _delay_us(60);
  188. // clear it off
  189. if (clear) lcd_clear();
  190. _delay_us(3000);
  191. // Initialize to default text direction (for romance languages)
  192. lcd_displaymode = LCD_ENTRYLEFT | LCD_ENTRYSHIFTDECREMENT;
  193. // set the entry mode
  194. lcd_command(LCD_ENTRYMODESET | lcd_displaymode);
  195. _delay_us(60);
  196. lcd_escape[0] = 0;
  197. }
  198. int lcd_putchar(char c, FILE *stream)
  199. {
  200. lcd_write(c);
  201. return 0;
  202. }
  203. void lcd_init(void)
  204. {
  205. uint8_t fourbitmode = 1;
  206. lcd_rs_pin = LCD_PINS_RS;
  207. lcd_rw_pin = 255;
  208. lcd_enable_pin = LCD_PINS_ENABLE;
  209. lcd_data_pins[0] = LCD_PINS_D4;
  210. lcd_data_pins[1] = LCD_PINS_D5;
  211. lcd_data_pins[2] = LCD_PINS_D6;
  212. lcd_data_pins[3] = LCD_PINS_D7;
  213. lcd_data_pins[4] = 0;
  214. lcd_data_pins[5] = 0;
  215. lcd_data_pins[6] = 0;
  216. lcd_data_pins[7] = 0;
  217. pinMode(lcd_rs_pin, OUTPUT);
  218. // we can save 1 pin by not using RW. Indicate by passing 255 instead of pin#
  219. if (lcd_rw_pin != 255) pinMode(lcd_rw_pin, OUTPUT);
  220. pinMode(lcd_enable_pin, OUTPUT);
  221. if (fourbitmode) lcd_displayfunction = LCD_4BITMODE | LCD_1LINE | LCD_5x8DOTS;
  222. else lcd_displayfunction = LCD_8BITMODE | LCD_1LINE | LCD_5x8DOTS;
  223. lcd_begin(LCD_HEIGHT, LCD_5x8DOTS, 1);
  224. //lcd_clear();
  225. fdev_setup_stream(lcdout, lcd_putchar, NULL, _FDEV_SETUP_WRITE); //setup lcdout stream
  226. }
  227. void lcd_refresh(void)
  228. {
  229. lcd_begin(LCD_HEIGHT, LCD_5x8DOTS, 1);
  230. lcd_set_custom_characters();
  231. }
  232. void lcd_refresh_noclear(void)
  233. {
  234. lcd_begin(LCD_HEIGHT, LCD_5x8DOTS, 0);
  235. lcd_set_custom_characters();
  236. }
  237. void lcd_clear(void)
  238. {
  239. lcd_command(LCD_CLEARDISPLAY); // clear display, set cursor position to zero
  240. _delay_us(1600); // this command takes a long time
  241. }
  242. void lcd_home(void)
  243. {
  244. lcd_command(LCD_RETURNHOME); // set cursor position to zero
  245. _delay_us(1600); // this command takes a long time!
  246. }
  247. // Turn the display on/off (quickly)
  248. void lcd_no_display(void)
  249. {
  250. lcd_displaycontrol &= ~LCD_DISPLAYON;
  251. lcd_command(LCD_DISPLAYCONTROL | lcd_displaycontrol);
  252. }
  253. void lcd_display(void)
  254. {
  255. lcd_displaycontrol |= LCD_DISPLAYON;
  256. lcd_command(LCD_DISPLAYCONTROL | lcd_displaycontrol);
  257. }
  258. // Turns the underline cursor on/off
  259. void lcd_no_cursor(void)
  260. {
  261. lcd_displaycontrol &= ~LCD_CURSORON;
  262. lcd_command(LCD_DISPLAYCONTROL | lcd_displaycontrol);
  263. }
  264. void lcd_cursor(void)
  265. {
  266. lcd_displaycontrol |= LCD_CURSORON;
  267. lcd_command(LCD_DISPLAYCONTROL | lcd_displaycontrol);
  268. }
  269. // Turn on and off the blinking cursor
  270. void lcd_no_blink(void)
  271. {
  272. lcd_displaycontrol &= ~LCD_BLINKON;
  273. lcd_command(LCD_DISPLAYCONTROL | lcd_displaycontrol);
  274. }
  275. void lcd_blink(void)
  276. {
  277. lcd_displaycontrol |= LCD_BLINKON;
  278. lcd_command(LCD_DISPLAYCONTROL | lcd_displaycontrol);
  279. }
  280. // These commands scroll the display without changing the RAM
  281. void lcd_scrollDisplayLeft(void)
  282. {
  283. lcd_command(LCD_CURSORSHIFT | LCD_DISPLAYMOVE | LCD_MOVELEFT);
  284. }
  285. void lcd_scrollDisplayRight(void)
  286. {
  287. lcd_command(LCD_CURSORSHIFT | LCD_DISPLAYMOVE | LCD_MOVERIGHT);
  288. }
  289. // This is for text that flows Left to Right
  290. void lcd_leftToRight(void)
  291. {
  292. lcd_displaymode |= LCD_ENTRYLEFT;
  293. lcd_command(LCD_ENTRYMODESET | lcd_displaymode);
  294. }
  295. // This is for text that flows Right to Left
  296. void lcd_rightToLeft(void)
  297. {
  298. lcd_displaymode &= ~LCD_ENTRYLEFT;
  299. lcd_command(LCD_ENTRYMODESET | lcd_displaymode);
  300. }
  301. // This will 'right justify' text from the cursor
  302. void lcd_autoscroll(void)
  303. {
  304. lcd_displaymode |= LCD_ENTRYSHIFTINCREMENT;
  305. lcd_command(LCD_ENTRYMODESET | lcd_displaymode);
  306. }
  307. // This will 'left justify' text from the cursor
  308. void lcd_no_autoscroll(void)
  309. {
  310. lcd_displaymode &= ~LCD_ENTRYSHIFTINCREMENT;
  311. lcd_command(LCD_ENTRYMODESET | lcd_displaymode);
  312. }
  313. void lcd_set_cursor(uint8_t col, uint8_t row)
  314. {
  315. int row_offsets[] = { 0x00, 0x40, 0x14, 0x54 };
  316. if ( row >= lcd_numlines )
  317. row = lcd_numlines-1; // we count rows starting w/0
  318. lcd_currline = row;
  319. lcd_command(LCD_SETDDRAMADDR | (col + row_offsets[row]));
  320. }
  321. // Allows us to fill the first 8 CGRAM locations
  322. // with custom characters
  323. void lcd_createChar_P(uint8_t location, const uint8_t* charmap)
  324. {
  325. location &= 0x7; // we only have 8 locations 0-7
  326. lcd_command(LCD_SETCGRAMADDR | (location << 3));
  327. for (int i=0; i<8; i++)
  328. lcd_send(pgm_read_byte(&charmap[i]), HIGH);
  329. }
  330. //Supported VT100 escape codes:
  331. //EraseScreen "\x1b[2J"
  332. //CursorHome "\x1b[%d;%dH"
  333. //CursorShow "\x1b[?25h"
  334. //CursorHide "\x1b[?25l"
  335. uint8_t lcd_escape_write(uint8_t chr)
  336. {
  337. #define escape_cnt (lcd_escape[0]) //escape character counter
  338. #define is_num_msk (lcd_escape[1]) //numeric character bit mask
  339. #define chr_is_num (is_num_msk & 0x01) //current character is numeric
  340. #define e_2_is_num (is_num_msk & 0x04) //escape char 2 is numeric
  341. #define e_3_is_num (is_num_msk & 0x08) //...
  342. #define e_4_is_num (is_num_msk & 0x10)
  343. #define e_5_is_num (is_num_msk & 0x20)
  344. #define e_6_is_num (is_num_msk & 0x40)
  345. #define e_7_is_num (is_num_msk & 0x80)
  346. #define e2_num (lcd_escape[2] - '0') //number from character 2
  347. #define e3_num (lcd_escape[3] - '0') //number from character 3
  348. #define e23_num (10*e2_num+e3_num) //number from characters 2 and 3
  349. #define e4_num (lcd_escape[4] - '0') //number from character 4
  350. #define e5_num (lcd_escape[5] - '0') //number from character 5
  351. #define e45_num (10*e4_num+e5_num) //number from characters 4 and 5
  352. #define e6_num (lcd_escape[6] - '0') //number from character 6
  353. #define e56_num (10*e5_num+e6_num) //number from characters 5 and 6
  354. if (escape_cnt > 1) // escape length > 1 = "\x1b["
  355. {
  356. lcd_escape[escape_cnt] = chr; // store current char
  357. if ((chr >= '0') && (chr <= '9')) // char is numeric
  358. is_num_msk |= (1 | (1 << escape_cnt)); //set mask
  359. else
  360. is_num_msk &= ~1; //clear mask
  361. }
  362. switch (escape_cnt++)
  363. {
  364. case 0:
  365. if (chr == 0x1b) return 1; // escape = "\x1b"
  366. break;
  367. case 1:
  368. is_num_msk = 0x00; // reset 'is number' bit mask
  369. if (chr == '[') return 1; // escape = "\x1b["
  370. break;
  371. case 2:
  372. switch (chr)
  373. {
  374. case '2': return 1; // escape = "\x1b[2"
  375. case '?': return 1; // escape = "\x1b[?"
  376. default:
  377. if (chr_is_num) return 1; // escape = "\x1b[%1d"
  378. }
  379. break;
  380. case 3:
  381. switch (lcd_escape[2])
  382. {
  383. case '?': // escape = "\x1b[?"
  384. if (chr == '2') return 1; // escape = "\x1b[?2"
  385. break;
  386. case '2':
  387. if (chr == 'J') // escape = "\x1b[2J"
  388. { lcd_clear(); lcd_currline = 0; break; } // EraseScreen
  389. default:
  390. if (e_2_is_num && // escape = "\x1b[%1d"
  391. ((chr == ';') || // escape = "\x1b[%1d;"
  392. chr_is_num)) // escape = "\x1b[%2d"
  393. return 1;
  394. }
  395. break;
  396. case 4:
  397. switch (lcd_escape[2])
  398. {
  399. case '?': // "\x1b[?"
  400. if ((lcd_escape[3] == '2') && (chr == '5')) return 1; // escape = "\x1b[?25"
  401. break;
  402. default:
  403. if (e_2_is_num) // escape = "\x1b[%1d"
  404. {
  405. if ((lcd_escape[3] == ';') && chr_is_num) return 1; // escape = "\x1b[%1d;%1d"
  406. else if (e_3_is_num && (chr == ';')) return 1; // escape = "\x1b[%2d;"
  407. }
  408. }
  409. break;
  410. case 5:
  411. switch (lcd_escape[2])
  412. {
  413. case '?':
  414. if ((lcd_escape[3] == '2') && (lcd_escape[4] == '5')) // escape = "\x1b[?25"
  415. switch (chr)
  416. {
  417. case 'h': // escape = "\x1b[?25h"
  418. lcd_cursor(); // CursorShow
  419. break;
  420. case 'l': // escape = "\x1b[?25l"
  421. lcd_no_cursor(); // CursorHide
  422. break;
  423. }
  424. break;
  425. default:
  426. if (e_2_is_num) // escape = "\x1b[%1d"
  427. {
  428. if ((lcd_escape[3] == ';') && e_4_is_num) // escape = "\x1b%1d;%1dH"
  429. {
  430. if (chr == 'H') // escape = "\x1b%1d;%1dH"
  431. lcd_set_cursor(e4_num, e2_num); // CursorHome
  432. else if (chr_is_num)
  433. return 1; // escape = "\x1b%1d;%2d"
  434. }
  435. else if (e_3_is_num && (lcd_escape[4] == ';') && chr_is_num)
  436. return 1; // escape = "\x1b%2d;%1d"
  437. }
  438. }
  439. break;
  440. case 6:
  441. if (e_2_is_num) // escape = "\x1b[%1d"
  442. {
  443. if ((lcd_escape[3] == ';') && e_4_is_num && e_5_is_num && (chr == 'H')) // escape = "\x1b%1d;%2dH"
  444. lcd_set_cursor(e45_num, e2_num); // CursorHome
  445. else if (e_3_is_num && (lcd_escape[4] == ';') && e_5_is_num) // escape = "\x1b%2d;%1d"
  446. {
  447. if (chr == 'H') // escape = "\x1b%2d;%1dH"
  448. lcd_set_cursor(e5_num, e23_num); // CursorHome
  449. else if (chr_is_num) // "\x1b%2d;%2d"
  450. return 1;
  451. }
  452. }
  453. break;
  454. case 7:
  455. if (e_2_is_num && e_3_is_num && (lcd_escape[4] == ';')) // "\x1b[%2d;"
  456. if (e_5_is_num && e_6_is_num && (chr == 'H')) // "\x1b[%2d;%2dH"
  457. lcd_set_cursor(e56_num, e23_num); // CursorHome
  458. break;
  459. }
  460. escape_cnt = 0; // reset escape
  461. return 1; // assume sucess
  462. }
  463. int lcd_putc(int c)
  464. {
  465. return fputc(c, lcdout);
  466. }
  467. int lcd_puts_P(const char* str)
  468. {
  469. return fputs_P(str, lcdout);
  470. }
  471. int lcd_puts_at_P(uint8_t c, uint8_t r, const char* str)
  472. {
  473. lcd_set_cursor(c, r);
  474. return fputs_P(str, lcdout);
  475. }
  476. int lcd_printf_P(const char* format, ...)
  477. {
  478. va_list args;
  479. va_start(args, format);
  480. int ret = vfprintf_P(lcdout, format, args);
  481. va_end(args);
  482. return ret;
  483. }
  484. void lcd_print(const char* s)
  485. {
  486. while (*s) lcd_write(*(s++));
  487. }
  488. void lcd_print(char c, int base)
  489. {
  490. lcd_print((long) c, base);
  491. }
  492. void lcd_print(unsigned char b, int base)
  493. {
  494. lcd_print((unsigned long) b, base);
  495. }
  496. void lcd_print(int n, int base)
  497. {
  498. lcd_print((long) n, base);
  499. }
  500. void lcd_print(unsigned int n, int base)
  501. {
  502. lcd_print((unsigned long) n, base);
  503. }
  504. void lcd_print(long n, int base)
  505. {
  506. if (base == 0)
  507. lcd_write(n);
  508. else if (base == 10)
  509. {
  510. if (n < 0)
  511. {
  512. lcd_print('-');
  513. n = -n;
  514. }
  515. lcd_printNumber(n, 10);
  516. }
  517. else
  518. lcd_printNumber(n, base);
  519. }
  520. void lcd_print(unsigned long n, int base)
  521. {
  522. if (base == 0)
  523. lcd_write(n);
  524. else
  525. lcd_printNumber(n, base);
  526. }
  527. void lcd_print(double n, int digits)
  528. {
  529. lcd_printFloat(n, digits);
  530. }
  531. void lcd_printNumber(unsigned long n, uint8_t base)
  532. {
  533. unsigned char buf[8 * sizeof(long)]; // Assumes 8-bit chars.
  534. unsigned long i = 0;
  535. if (n == 0)
  536. {
  537. lcd_print('0');
  538. return;
  539. }
  540. while (n > 0)
  541. {
  542. buf[i++] = n % base;
  543. n /= base;
  544. }
  545. for (; i > 0; i--)
  546. lcd_print((char) (buf[i - 1] < 10 ? '0' + buf[i - 1] : 'A' + buf[i - 1] - 10));
  547. }
  548. void lcd_printFloat(double number, uint8_t digits)
  549. {
  550. // Handle negative numbers
  551. if (number < 0.0)
  552. {
  553. lcd_print('-');
  554. number = -number;
  555. }
  556. // Round correctly so that print(1.999, 2) prints as "2.00"
  557. double rounding = 0.5;
  558. for (uint8_t i=0; i<digits; ++i)
  559. rounding /= 10.0;
  560. number += rounding;
  561. // Extract the integer part of the number and print it
  562. unsigned long int_part = (unsigned long)number;
  563. double remainder = number - (double)int_part;
  564. lcd_print(int_part);
  565. // Print the decimal point, but only if there are digits beyond
  566. if (digits > 0)
  567. lcd_print('.');
  568. // Extract digits from the remainder one at a time
  569. while (digits-- > 0)
  570. {
  571. remainder *= 10.0;
  572. int toPrint = int(remainder);
  573. lcd_print(toPrint);
  574. remainder -= toPrint;
  575. }
  576. }
  577. uint8_t lcd_draw_update = 2;
  578. int32_t lcd_encoder = 0;
  579. uint8_t lcd_encoder_bits = 0;
  580. int8_t lcd_encoder_diff = 0;
  581. uint8_t lcd_buttons = 0;
  582. uint8_t lcd_button_pressed = 0;
  583. uint8_t lcd_update_enabled = 1;
  584. uint32_t lcd_next_update_millis = 0;
  585. uint8_t lcd_status_update_delay = 0;
  586. uint8_t lcd_long_press_active = 0;
  587. lcd_longpress_func_t lcd_longpress_func = 0;
  588. lcd_charsetup_func_t lcd_charsetup_func = 0;
  589. lcd_lcdupdate_func_t lcd_lcdupdate_func = 0;
  590. static ShortTimer buttonBlanking;
  591. ShortTimer longPressTimer;
  592. LongTimer lcd_timeoutToStatus;
  593. uint8_t lcd_clicked(void)
  594. {
  595. bool clicked = LCD_CLICKED;
  596. if(clicked) lcd_button_pressed = 1;
  597. return clicked;
  598. }
  599. void lcd_beeper_quick_feedback(void)
  600. {
  601. SET_OUTPUT(BEEPER);
  602. //-//
  603. Sound_MakeSound(e_SOUND_CLASS_Echo,e_SOUND_TYPE_ButtonEcho);
  604. /*
  605. for(int8_t i = 0; i < 10; i++)
  606. {
  607. WRITE(BEEPER,HIGH);
  608. delayMicroseconds(100);
  609. WRITE(BEEPER,LOW);
  610. delayMicroseconds(100);
  611. }
  612. */
  613. }
  614. void lcd_quick_feedback(void)
  615. {
  616. lcd_draw_update = 2;
  617. lcd_button_pressed = false;
  618. lcd_beeper_quick_feedback();
  619. }
  620. void lcd_update(uint8_t lcdDrawUpdateOverride)
  621. {
  622. if (lcd_draw_update < lcdDrawUpdateOverride)
  623. lcd_draw_update = lcdDrawUpdateOverride;
  624. if (!lcd_update_enabled)
  625. return;
  626. lcd_buttons_update();
  627. if (lcd_lcdupdate_func)
  628. lcd_lcdupdate_func();
  629. }
  630. void lcd_update_enable(uint8_t enabled)
  631. {
  632. if (lcd_update_enabled != enabled)
  633. {
  634. lcd_update_enabled = enabled;
  635. if (enabled)
  636. { // Reset encoder position. This is equivalent to re-entering a menu.
  637. lcd_encoder = 0;
  638. lcd_encoder_diff = 0;
  639. // Enabling the normal LCD update procedure.
  640. // Reset the timeout interval.
  641. lcd_timeoutToStatus.start();
  642. // Force the keypad update now.
  643. lcd_next_update_millis = millis() - 1;
  644. // Full update.
  645. lcd_clear();
  646. if (lcd_charsetup_func)
  647. lcd_charsetup_func();
  648. lcd_update(2);
  649. } else
  650. {
  651. // Clear the LCD always, or let it to the caller?
  652. }
  653. }
  654. }
  655. void lcd_buttons_update(void)
  656. {
  657. static bool _lock = false;
  658. if (_lock) return;
  659. _lock = true;
  660. uint8_t newbutton = 0;
  661. if (READ(BTN_EN1) == 0) newbutton |= EN_A;
  662. if (READ(BTN_EN2) == 0) newbutton |= EN_B;
  663. if (lcd_update_enabled)
  664. { //if we are in non-modal mode, long press can be used and short press triggers with button release
  665. if (READ(BTN_ENC) == 0)
  666. { //button is pressed
  667. lcd_timeoutToStatus.start();
  668. if (!buttonBlanking.running() || buttonBlanking.expired(BUTTON_BLANKING_TIME)) {
  669. buttonBlanking.start();
  670. if ((lcd_button_pressed == 0) && (lcd_long_press_active == 0))
  671. {
  672. longPressTimer.start();
  673. lcd_button_pressed = 1;
  674. }
  675. else
  676. {
  677. if (longPressTimer.expired(LONG_PRESS_TIME))
  678. {
  679. lcd_long_press_active = 1;
  680. if (lcd_longpress_func)
  681. lcd_longpress_func();
  682. }
  683. }
  684. }
  685. }
  686. else
  687. { //button not pressed
  688. if (lcd_button_pressed)
  689. { //button was released
  690. buttonBlanking.start();
  691. if (lcd_long_press_active == 0)
  692. { //button released before long press gets activated
  693. newbutton |= EN_C;
  694. }
  695. //else if (menu_menu == lcd_move_z) lcd_quick_feedback();
  696. //lcd_button_pressed is set back to false via lcd_quick_feedback function
  697. }
  698. else
  699. lcd_long_press_active = 0;
  700. }
  701. }
  702. else
  703. { //we are in modal mode
  704. if (READ(BTN_ENC) == 0)
  705. newbutton |= EN_C;
  706. }
  707. lcd_buttons = newbutton;
  708. //manage encoder rotation
  709. uint8_t enc = 0;
  710. if (lcd_buttons & EN_A) enc |= B01;
  711. if (lcd_buttons & EN_B) enc |= B10;
  712. if (enc != lcd_encoder_bits)
  713. {
  714. switch (enc)
  715. {
  716. case encrot0:
  717. if (lcd_encoder_bits == encrot3)
  718. lcd_encoder_diff++;
  719. else if (lcd_encoder_bits == encrot1)
  720. lcd_encoder_diff--;
  721. break;
  722. case encrot1:
  723. if (lcd_encoder_bits == encrot0)
  724. lcd_encoder_diff++;
  725. else if (lcd_encoder_bits == encrot2)
  726. lcd_encoder_diff--;
  727. break;
  728. case encrot2:
  729. if (lcd_encoder_bits == encrot1)
  730. lcd_encoder_diff++;
  731. else if (lcd_encoder_bits == encrot3)
  732. lcd_encoder_diff--;
  733. break;
  734. case encrot3:
  735. if (lcd_encoder_bits == encrot2)
  736. lcd_encoder_diff++;
  737. else if (lcd_encoder_bits == encrot0)
  738. lcd_encoder_diff--;
  739. break;
  740. }
  741. }
  742. lcd_encoder_bits = enc;
  743. _lock = false;
  744. }
  745. ////////////////////////////////////////////////////////////////////////////////
  746. // Custom character data
  747. const uint8_t lcd_chardata_bedTemp[8] PROGMEM = {
  748. B00000,
  749. B11111,
  750. B10101,
  751. B10001,
  752. B10101,
  753. B11111,
  754. B00000,
  755. B00000}; //thanks Sonny Mounicou
  756. const uint8_t lcd_chardata_degree[8] PROGMEM = {
  757. B01100,
  758. B10010,
  759. B10010,
  760. B01100,
  761. B00000,
  762. B00000,
  763. B00000,
  764. B00000};
  765. const uint8_t lcd_chardata_thermometer[8] PROGMEM = {
  766. B00100,
  767. B01010,
  768. B01010,
  769. B01010,
  770. B01010,
  771. B10001,
  772. B10001,
  773. B01110};
  774. const uint8_t lcd_chardata_uplevel[8] PROGMEM = {
  775. B00100,
  776. B01110,
  777. B11111,
  778. B00100,
  779. B11100,
  780. B00000,
  781. B00000,
  782. B00000}; //thanks joris
  783. const uint8_t lcd_chardata_refresh[8] PROGMEM = {
  784. B00000,
  785. B00110,
  786. B11001,
  787. B11000,
  788. B00011,
  789. B10011,
  790. B01100,
  791. B00000}; //thanks joris
  792. const uint8_t lcd_chardata_folder[8] PROGMEM = {
  793. B00000,
  794. B11100,
  795. B11111,
  796. B10001,
  797. B10001,
  798. B11111,
  799. B00000,
  800. B00000}; //thanks joris
  801. /*const uint8_t lcd_chardata_feedrate[8] PROGMEM = {
  802. B11100,
  803. B10000,
  804. B11000,
  805. B10111,
  806. B00101,
  807. B00110,
  808. B00101,
  809. B00000};*/ //thanks Sonny Mounicou
  810. /*const uint8_t lcd_chardata_feedrate[8] PROGMEM = {
  811. B11100,
  812. B10100,
  813. B11000,
  814. B10100,
  815. B00000,
  816. B00111,
  817. B00010,
  818. B00010};*/
  819. /*const uint8_t lcd_chardata_feedrate[8] PROGMEM = {
  820. B01100,
  821. B10011,
  822. B00000,
  823. B01100,
  824. B10011,
  825. B00000,
  826. B01100,
  827. B10011};*/
  828. const uint8_t lcd_chardata_feedrate[8] PROGMEM = {
  829. B00000,
  830. B00100,
  831. B10010,
  832. B01001,
  833. B10010,
  834. B00100,
  835. B00000,
  836. B00000};
  837. const uint8_t lcd_chardata_clock[8] PROGMEM = {
  838. B00000,
  839. B01110,
  840. B10011,
  841. B10101,
  842. B10001,
  843. B01110,
  844. B00000,
  845. B00000}; //thanks Sonny Mounicou
  846. const uint8_t lcd_chardata_arrup[8] PROGMEM = {
  847. B00100,
  848. B01110,
  849. B11111,
  850. B00000,
  851. B00000,
  852. B00000,
  853. B00000,
  854. B00000};
  855. const uint8_t lcd_chardata_arrdown[8] PROGMEM = {
  856. B00000,
  857. B00000,
  858. B00000,
  859. B00000,
  860. B00000,
  861. B10001,
  862. B01010,
  863. B00100};
  864. void lcd_set_custom_characters(void)
  865. {
  866. lcd_createChar_P(LCD_STR_BEDTEMP[0], lcd_chardata_bedTemp);
  867. lcd_createChar_P(LCD_STR_DEGREE[0], lcd_chardata_degree);
  868. lcd_createChar_P(LCD_STR_THERMOMETER[0], lcd_chardata_thermometer);
  869. lcd_createChar_P(LCD_STR_UPLEVEL[0], lcd_chardata_uplevel);
  870. lcd_createChar_P(LCD_STR_REFRESH[0], lcd_chardata_refresh);
  871. lcd_createChar_P(LCD_STR_FOLDER[0], lcd_chardata_folder);
  872. lcd_createChar_P(LCD_STR_FEEDRATE[0], lcd_chardata_feedrate);
  873. lcd_createChar_P(LCD_STR_CLOCK[0], lcd_chardata_clock);
  874. //lcd_createChar_P(LCD_STR_ARROW_UP[0], lcd_chardata_arrup);
  875. //lcd_createChar_P(LCD_STR_ARROW_DOWN[0], lcd_chardata_arrdown);
  876. }
  877. void lcd_set_custom_characters_arrows(void)
  878. {
  879. lcd_createChar_P(1, lcd_chardata_arrdown);
  880. }
  881. const uint8_t lcd_chardata_progress[8] PROGMEM = {
  882. B11111,
  883. B11111,
  884. B11111,
  885. B11111,
  886. B11111,
  887. B11111,
  888. B11111,
  889. B11111};
  890. void lcd_set_custom_characters_progress(void)
  891. {
  892. lcd_createChar_P(1, lcd_chardata_progress);
  893. }
  894. const uint8_t lcd_chardata_arr2down[8] PROGMEM = {
  895. B00000,
  896. B00000,
  897. B10001,
  898. B01010,
  899. B00100,
  900. B10001,
  901. B01010,
  902. B00100};
  903. const uint8_t lcd_chardata_confirm[8] PROGMEM = {
  904. B00000,
  905. B00001,
  906. B00011,
  907. B10110,
  908. B11100,
  909. B01000,
  910. B00000};
  911. void lcd_set_custom_characters_nextpage(void)
  912. {
  913. lcd_createChar_P(1, lcd_chardata_arr2down);
  914. lcd_createChar_P(2, lcd_chardata_confirm);
  915. }
  916. void lcd_set_custom_characters_degree(void)
  917. {
  918. lcd_createChar_P(1, lcd_chardata_degree);
  919. }