API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Sep 5th, 2016
173
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 30.83 KB | None | 0 0
raw download clone embed print report
  1. #include <Button.h> //https://github.com/JChristensen/Button
  2. #include <DS3232RTC.h> //http://github.com/JChristensen/DS3232RTC
  3. #include <Streaming.h> //http://arduiniana.org/libraries/streaming/
  4. #include <Time.h> //http://www.arduino.cc/playground/Code/Time
  5. #include <Wire.h> //http://arduino.cc/en/Reference/Wire (included with Arduino IDE)
  6. #include <EEPROM.h>
  7. #include <dht11.h>
  8. #include <LiquidCrystal_I2C_AvrI2C.h>
  9. #include <Timer.h>
  10. #include "Funkuhr.h"
  11.  
  12.  
  13. LiquidCrystal_I2C_AvrI2C lcd(0x27,16,2);
  14. Funkuhr dcf(0, 7, 13, false);
  15. struct Dcf77Time dt = { 0 };
  16.  
  17. uint8_t curSec;
  18.  
  19. #define BUTTON_PIN_UP 6
  20. #define BUTTON_PIN_DOWN 5
  21. #define BUTTON_PIN_MENU_SELECT 8
  22. #define BUTTON_PIN_btnBACK 4
  23.  
  24.  
  25. #define DEBOUNCE_MS 20 //A debounce time of 20 milliseconds usually works well for tactile button switches.
  26.  
  27. #define REPEAT_FIRST 1000 //ms required before repeating on long press
  28. #define REPEAT_INCR 200 //repeat interval for long press
  29. #define PULLUP true //To keep things simple, we use the Arduino's internal pullup resistor.
  30. #define INVERT true
  31.  
  32. int count; //The number that is adjusted
  33. int lastCount = -1; //Previous value of count (initialized to ensure it's different when the sketch starts)
  34. unsigned long rpt = REPEAT_FIRST; //A variable time that is used to drive the repeats for long presses
  35. int lamba_pin=13;
  36. int lamba_kont;
  37.  
  38.  
  39.  
  40.  
  41. Button buttonUp(BUTTON_PIN_UP, PULLUP, INVERT, DEBOUNCE_MS); //Declare the buttons
  42. Button buttonDown(BUTTON_PIN_DOWN, PULLUP, INVERT, DEBOUNCE_MS);
  43. Button buttonSelect(BUTTON_PIN_MENU_SELECT, PULLUP, INVERT, DEBOUNCE_MS);
  44. Button buttonbtnBACK(BUTTON_PIN_btnBACK, PULLUP, INVERT, DEBOUNCE_MS);
  45.  
  46. // input actions
  47. enum {btnMENU, btnBACK, btnUP, btnDOWN};
  48.  
  49.  
  50. /*
  51. * States of FSM
  52. */
  53. enum STATES
  54. {
  55. MAIN,
  56. MENU_SET_ALARM,
  57. MENU_SET_LAMP,
  58. MENU_SET_TIME,
  59. MENU_SET_DATE,
  60.  
  61. SET_HOUR,
  62. SET_MINUTE,
  63.  
  64. SET_DAY,
  65. SET_MONTH,
  66. SET_YEAR,
  67. SET_AL_HOUR,
  68. SET_AL_MINUTE,
  69. SET_AL_ON_OFF,
  70. ALARM_TIME,
  71. LAMP_TIME,
  72. SET_LAMP_TIME,
  73. SET_LAMP_START,
  74. SET_LAMP_FINISH,
  75. SET_LAMP_ON_OFF,
  76. // Otherwise, it times out after 5 seconds, discards the changes and returns to displaying the time
  77. };
  78. STATES state; // Holds the current state of the system
  79.  
  80.  
  81. int8_t button;
  82. int8_t trigger;
  83.  
  84. int Second;
  85. int Minute;
  86. int Hour;
  87. int Day;
  88. int Month;
  89. int Year;
  90.  
  91. int8_t DoW;
  92. String day_of_week;
  93. unsigned char address, data;
  94.  
  95. int AL_Hour;
  96. int AL_Minute;
  97. int baslangic;
  98. int bitis;
  99. bool alarm_active = false;
  100. bool lamp_active = false;
  101.  
  102.  
  103. uint32_t blink_interval = 500;
  104. uint32_t blink_previousMillis = 0;
  105. boolean blink_state = false;
  106. boolean RTC_error = true;
  107. boolean long_press_button = false;
  108.  
  109. byte picatura[8] = //icon for water droplet
  110. {
  111. B00100,
  112. B00100,
  113. B01010,
  114. B01010,
  115. B10001,
  116. B10001,
  117. B10001,
  118. B01110,
  119. };
  120.  
  121. byte bell_symbol[8] = {
  122. B00100,
  123. B01110,
  124. B01110,
  125. B01110,
  126. B01110,
  127. B11111,
  128. B00000,
  129. B00100};
  130.  
  131. byte thermometer_symbol[8] = {
  132. B00100,
  133. B01010,
  134. B01010,
  135. B01110,
  136. B01110,
  137. B11111,
  138. B11111,
  139. B01110};
  140.  
  141. byte char_S[8] = {
  142. 0b11111,
  143. 0b11111,
  144. 0b11000,
  145. 0b11111,
  146. 0b11111,
  147. 0b00011,
  148. 0b11111,
  149. 0b11111};
  150.  
  151. byte char_D[8] = {
  152. 0b11110,
  153. 0b11111,
  154. 0b11011,
  155. 0b11011,
  156. 0b11011,
  157. 0b11011,
  158. 0b11111,
  159. 0b11110};
  160.  
  161. byte char_J[8] = {
  162. 0b11111,
  163. 0b11111,
  164. 0b00011,
  165. 0b00011,
  166. 0b00011,
  167. 0b10011,
  168. 0b11111,
  169. 0b11111};
  170.  
  171. byte menu_RIGHT[8] = {
  172. B10000,
  173. B11000,
  174. B11100,
  175. B11110,
  176. B11100,
  177. B11000,
  178. B10000,
  179. B00000};
  180.  
  181. byte menu_LEFT[8] = {
  182. B00001,
  183. B00011,
  184. B00111,
  185. B01111,
  186. B00111,
  187. B00011,
  188. B00001,
  189. B00000};
  190.  
  191. /*
  192. * SETUP
  193. */
  194.  
  195.  
  196. dht11 DHT11;
  197.  
  198. /*-----( Declare Constants, Pin Numbers )-----*/
  199. #define DHT11PIN 2
  200. //Timer t;
  201.  
  202. unsigned long previousMillis1 = 0;
  203. unsigned long previousMillis = 0;
  204.  
  205.  
  206.  
  207.  
  208.  
  209. void setup()
  210. {
  211. Serial.begin(9600);
  212. dcf.init();
  213. pinMode(lamba_pin, OUTPUT);
  214. lcd.begin();
  215. lcd.backlight();
  216. Wire.begin();
  217. lcd.createChar(7,picatura);// start I2C
  218. lcd.createChar(0, thermometer_symbol);
  219. lcd.createChar(1, bell_symbol);
  220. lcd.createChar(2, char_S);
  221. lcd.createChar(3, char_D);
  222. lcd.createChar(4, char_J);
  223. lcd.createChar(5, menu_RIGHT);
  224. lcd.createChar(6, menu_LEFT);
  225. Wire.begin();
  226. setSyncProvider(RTC.get); // set RTC as the Syncprovider
  227. setSyncInterval(5); // time in sec of resync with RTC
  228.  
  229. lcd.clear();
  230. lcd.setCursor(5, 0);
  231. lcd.write(2);
  232. lcd.setCursor(6, 0);
  233. lcd.write(2);
  234. lcd.setCursor(7, 0);
  235. lcd.write(3);
  236. lcd.setCursor(8, 0);
  237. lcd.write(4);
  238. lcd.setCursor(0, 1);
  239. lcd.print("Arduino&Saat/GL");
  240. delay(2000);
  241. lcd.clear();
  242. state = MAIN;
  243.  
  244. }//End SETUP
  245.  
  246. void loop()
  247.  
  248. {
  249. unsigned long currentMillis = millis();
  250.  
  251. if (currentMillis - previousMillis >= 5000)
  252. {
  253. previousMillis = currentMillis; // Remember the time
  254. temp();
  255. }
  256.  
  257. change_states(); // change states of FSM
  258. check_inputs(); // check inputs (buttons)
  259. check_RTC();
  260. //if (state == MAIN) {t.update();}
  261. lamba();
  262. dcf.getTime(dt);
  263.  
  264. if(dt.sec != curSec)
  265. {
  266. dumpTime();
  267. }
  268. curSec = dt.sec;
  269. }
  270.  
  271. void lamba()
  272. {
  273. if (EEPROM.read(3)==Hour && EEPROM.read(5)==1)
  274. {
  275. lamba_kont=1;
  276. }
  277. if (lamba_kont==1)
  278. {
  279. digitalWrite(lamba_pin,HIGH);
  280. }
  281. else{digitalWrite(lamba_pin,LOW);}
  282.  
  283. if (EEPROM.read(4)==Hour || EEPROM.read(5)==0)
  284. {
  285. lamba_kont=0;
  286. }
  287.  
  288.  
  289.  
  290. }
  291. void temp()
  292. {
  293.  
  294. lcd.clear();
  295. unsigned long currentMillis= millis();
  296.  
  297. if (currentMillis - previousMillis >= 5000)
  298. {
  299.  
  300.  
  301. previousMillis= currentMillis ; // Remember the time
  302.  
  303. Serial.println(previousMillis);
  304. Serial.println(currentMillis);
  305.  
  306. int chk = DHT11.read(DHT11PIN);
  307. lcd.setCursor(1, 1);
  308. lcd.write(0);
  309. lcd.setCursor(3, 1);
  310. lcd.print((float)DHT11.temperature, 0);
  311. lcd.setCursor(5, 1);
  312. lcd.print((char)223);
  313. lcd.print("C");
  314.  
  315. lcd.setCursor(9, 1);
  316. lcd.write(7);
  317. lcd.setCursor(11, 1);
  318. lcd.print((float)DHT11.humidity*2, 0);
  319. lcd.print("%");
  320. }
  321.  
  322.  
  323.  
  324. }
  325.  
  326. void change_states()
  327. {
  328. //states
  329. switch (state)
  330. {
  331. case MAIN:
  332. display_time();
  333. display_date();
  334. get_alarm(); //read stored alarm time
  335. //display_temperature();
  336. get_lamp();
  337. break;
  338. case MENU_SET_LAMP:
  339. menu_set_lamp();
  340. break;
  341. case MENU_SET_ALARM:
  342. menu_set_alarm();
  343. break;
  344. case MENU_SET_TIME:
  345. menu_set_time();
  346. break;
  347. case MENU_SET_DATE:
  348. menu_set_date();
  349. break;
  350. case SET_HOUR:
  351. display_set_time();
  352. break;
  353. case SET_MINUTE:
  354. display_set_time();
  355. break;
  356. case SET_DAY:
  357. display_set_date();
  358. break;
  359. case SET_MONTH:
  360. display_set_date();
  361. break;
  362. case SET_YEAR:
  363. display_set_date();
  364. break;
  365.  
  366.  
  367. case SET_LAMP_TIME:
  368. display_set_lamp_time();
  369. break;
  370.  
  371. case SET_LAMP_START:
  372. display_set_lamp_time();
  373. break;
  374.  
  375. case SET_LAMP_FINISH:
  376. display_set_lamp_time();
  377. break;
  378.  
  379. case SET_LAMP_ON_OFF:
  380. display_set_lamp_time();
  381. break;
  382.  
  383.  
  384. case SET_AL_HOUR:
  385. display_set_AL_time();
  386. break;
  387. case SET_AL_MINUTE:
  388. display_set_AL_time();
  389. break;
  390. case SET_AL_ON_OFF:
  391. display_set_AL_time();
  392. break;
  393.  
  394. case LAMP_TIME:
  395. displayLAMP();
  396. delay(2000);
  397. lcd.clear();
  398. state=MAIN;
  399. break;
  400.  
  401.  
  402.  
  403.  
  404. case ALARM_TIME:
  405. displayALARM();
  406. delay(2000);
  407. lcd.clear();
  408. state=MAIN;
  409. break;
  410. break;
  411. }
  412.  
  413. }
  414.  
  415.  
  416. /*
  417. * Check INPUT
  418. */
  419. void check_inputs()
  420. {
  421. buttonUp.read(); // check state of buttons
  422. buttonDown.read();
  423. buttonSelect.read();
  424. buttonbtnBACK.read();
  425.  
  426.  
  427. switch (buttonSelect.wasPressed()) // check MENU/SELECT button
  428. {
  429. case 1:
  430. button = btnMENU;
  431. transition(button);
  432. break;
  433.  
  434. }
  435. switch (buttonUp.wasPressed()) // check UP button
  436. {
  437. case 1:
  438. button = btnUP;
  439. transition(button);
  440. break;
  441. }
  442.  
  443. switch (buttonUp.wasReleased()) // check long press UP button
  444. {
  445. case 1:
  446. long_press_button = false;
  447. rpt = REPEAT_FIRST;
  448. break;
  449. }
  450.  
  451. switch (buttonUp.pressedFor(rpt))
  452. {
  453. case 1:
  454. rpt += REPEAT_INCR; //increment the long press interval
  455. long_press_button = true;
  456. button = btnUP;
  457. transition(button);
  458. break;
  459. }
  460.  
  461. switch (buttonDown.wasPressed()) // check DOWN button
  462. {
  463. case 1:
  464. button = btnDOWN;
  465. transition(button);
  466. break;
  467. }
  468.  
  469. switch (buttonDown.wasReleased()) // check long press DOWN button
  470. {
  471. case 1:
  472. long_press_button = false;
  473. rpt = REPEAT_FIRST;
  474. break;
  475. }
  476.  
  477. switch (buttonDown.pressedFor(rpt))
  478. {
  479. case 1:
  480. rpt += REPEAT_INCR; //increment the long press interval
  481. long_press_button = true;
  482. button = btnDOWN;
  483. transition(button);
  484. break;
  485. }
  486.  
  487. switch (buttonbtnBACK.wasPressed()) // check btnBACK button
  488. {
  489. case 1:
  490. button = btnBACK;
  491. transition(button);
  492. break;
  493. }
  494. }
  495.  
  496. void transition(int trigger)
  497. {
  498. switch (state)
  499. {
  500. case MAIN:
  501. if (trigger == btnMENU)
  502. {
  503. lcd.clear();
  504. state = MENU_SET_ALARM;
  505. }
  506. else if (trigger == btnBACK)
  507. {
  508. lcd.clear();
  509. state = ALARM_TIME;
  510.  
  511. }
  512.  
  513. else if (trigger == btnUP)
  514. {
  515. lcd.clear();
  516. state = LAMP_TIME;
  517.  
  518.  
  519. }
  520. break;
  521.  
  522.  
  523.  
  524.  
  525.  
  526. case MENU_SET_ALARM:
  527. if (trigger == btnUP)
  528. {
  529. lcd.clear();
  530. state = MENU_SET_TIME;
  531. }
  532. else if (trigger == btnUP)
  533. {
  534. lcd.clear();
  535. state = MENU_SET_DATE;
  536. }
  537. else if (trigger == btnUP)
  538. {
  539. lcd.clear();
  540. state = MENU_SET_LAMP;
  541. }
  542.  
  543.  
  544.  
  545.  
  546. if (trigger == btnMENU)
  547. {
  548. lcd.clear();
  549. state = SET_AL_HOUR;
  550. }
  551. if (trigger == btnBACK)
  552. {
  553. lcd.clear();
  554. state = MAIN;
  555. }
  556. break;
  557.  
  558.  
  559.  
  560.  
  561.  
  562.  
  563. case MENU_SET_TIME:
  564. if (trigger == btnUP)
  565. {
  566. lcd.clear();
  567. state = MENU_SET_DATE;
  568. }
  569.  
  570. if (trigger == btnDOWN)
  571. {
  572. lcd.clear();
  573. state = MENU_SET_ALARM;
  574. }
  575.  
  576.  
  577. if (trigger == btnMENU)
  578. {
  579. lcd.clear();
  580.  
  581. state = SET_HOUR;
  582. }
  583. if (trigger == btnBACK)
  584. {
  585. lcd.clear();
  586. state = MAIN;
  587. }
  588. break;
  589.  
  590. case MENU_SET_DATE:
  591.  
  592. if (trigger == btnUP)
  593. {
  594. lcd.clear();
  595. state = MENU_SET_LAMP;
  596. }
  597.  
  598.  
  599. else if (trigger == btnDOWN)
  600. {
  601. lcd.clear();
  602. state = MENU_SET_TIME;
  603. }
  604. else if (trigger == btnDOWN)
  605. {
  606. lcd.clear();
  607. state = MENU_SET_ALARM;
  608. }
  609.  
  610. if (trigger == btnMENU)
  611. {
  612. lcd.clear();
  613. state = SET_DAY;
  614.  
  615. }
  616. if (trigger == btnBACK)
  617. {
  618. lcd.clear();
  619. state = MAIN;
  620. }
  621. break;
  622.  
  623.  
  624.  
  625. case MENU_SET_LAMP:
  626.  
  627.  
  628. if (trigger == btnDOWN)
  629. {
  630. lcd.clear();
  631. state = MENU_SET_DATE;
  632. }
  633. else if (trigger == btnDOWN)
  634. {
  635. lcd.clear();
  636. state = MENU_SET_TIME;
  637. }
  638.  
  639. if (trigger == btnMENU)
  640. {
  641. lcd.clear();
  642. state = SET_LAMP_START;
  643.  
  644. }
  645. if (trigger == btnBACK)
  646. {
  647. lcd.clear();
  648. state = MAIN;
  649. }
  650. break;
  651.  
  652.  
  653. case SET_HOUR:
  654. if (trigger == btnUP)
  655. {
  656. Hour++;
  657. if (Hour>23) Hour = 0;
  658. }
  659. else if (trigger == btnDOWN)
  660. {
  661. Hour--;
  662. if (Hour<0) Hour = 23;
  663. }
  664. if (trigger == btnMENU)
  665. {
  666. state = SET_MINUTE;
  667. }
  668. break;
  669.  
  670. case SET_MINUTE:
  671. if (trigger == btnUP)
  672. {
  673. Minute++;
  674. if (Minute>59) Minute = 0;
  675. }
  676. else if (trigger == btnDOWN)
  677. {
  678. Minute--;
  679. if (Minute<0) Minute = 59;
  680. }
  681.  
  682. if (trigger == btnBACK)
  683. {
  684.  
  685. state = SET_HOUR;
  686. }
  687. if (trigger == btnMENU)
  688. {
  689.  
  690. set_time();
  691. lcd.clear();
  692. lcd.setCursor(4,0);
  693. lcd.print("Time Set!");
  694. delay(1000);
  695.  
  696. lcd.clear();
  697. state = MAIN;
  698. }
  699. break;
  700.  
  701.  
  702. case SET_DAY:
  703. if (trigger == btnUP)
  704. {
  705. Day++;
  706. if (Day>31) Day = 1;
  707. }
  708. else if (trigger == btnDOWN)
  709. {
  710. Day--;
  711. if (Day<1) Day = 31;
  712. }
  713. if (trigger == btnMENU)
  714. {
  715. state = SET_MONTH;
  716. }
  717. break;
  718. case SET_MONTH:
  719. if (trigger == btnUP)
  720. {
  721. Month++;
  722. if (Month>12) Month = 1;
  723. }
  724. else if (trigger == btnDOWN)
  725. {
  726. Month--;
  727. if (Month<1) Month = 12;
  728. }
  729. if (trigger == btnMENU)
  730. {
  731. state = SET_YEAR;
  732. }
  733. if (trigger == btnBACK)
  734. {
  735.  
  736. state = SET_DAY;
  737. }
  738. break;
  739. case SET_YEAR:
  740. if (trigger == btnUP)
  741. {
  742. Year++;
  743. if (Year>99) Year = 0;
  744. }
  745. else if (trigger == btnDOWN)
  746. {
  747. Year--;
  748. if (Year<0) Year = 99;
  749. }
  750. if (trigger == btnBACK)
  751. {
  752.  
  753. state = SET_MONTH;
  754. }
  755. if (trigger == btnMENU)
  756. {
  757. set_date();
  758. lcd.clear();
  759. lcd.setCursor(4,0);
  760. lcd.print("Date Set!");
  761. delay(1000);
  762. lcd.clear();
  763. state = MAIN;
  764. }
  765. break;
  766.  
  767.  
  768.  
  769.  
  770. case SET_LAMP_START:
  771. if (trigger == btnUP)
  772. {
  773. baslangic++;
  774. if (baslangic>23) baslangic = 0;
  775. }
  776. else if (trigger == btnDOWN)
  777. {
  778. baslangic--;
  779. if (baslangic<0) baslangic = 23;
  780. }
  781. if (trigger == btnMENU)
  782. {
  783. state = SET_LAMP_FINISH;
  784. }
  785. break;
  786.  
  787. case SET_LAMP_FINISH:
  788. if (trigger == btnUP)
  789. {
  790. bitis++;
  791. if (bitis>23) bitis = 0;
  792. }
  793. else if (trigger == btnDOWN)
  794. {
  795. bitis--;
  796. if (bitis<0) bitis = 23;
  797. }
  798. if (trigger == btnMENU)
  799. {
  800. state=SET_LAMP_ON_OFF;
  801. }
  802. if (trigger == btnBACK)
  803. {
  804.  
  805. state = SET_LAMP_START;
  806. }
  807. break;
  808.  
  809. case SET_LAMP_ON_OFF:
  810. if (trigger == btnUP)
  811. {
  812. lamp_active = true;
  813. }
  814. else if (trigger == btnDOWN)
  815. {
  816. lamp_active =false;
  817. }
  818.  
  819. if (trigger == btnBACK)
  820. {
  821.  
  822. state = SET_LAMP_FINISH;
  823. }
  824. if (trigger == btnMENU)
  825. {
  826. set_lamp();
  827. lcd.clear();
  828. lcd.setCursor(4,0);
  829. lcd.print("Lamba ayarlandi!");
  830. delay(1000);
  831. lcd.clear();
  832. state = MAIN;
  833. }
  834.  
  835. break;
  836.  
  837.  
  838. case SET_AL_HOUR:
  839. if (trigger == btnUP)
  840. {
  841. AL_Hour++;
  842. if (AL_Hour>23) AL_Hour = 0;
  843. }
  844. else if (trigger == btnDOWN)
  845. {
  846. AL_Hour--;
  847. if (AL_Hour<0) AL_Hour = 23;
  848. }
  849. if (trigger == btnMENU)
  850. {
  851. state = SET_AL_MINUTE;
  852. }
  853. break;
  854.  
  855. case SET_AL_MINUTE:
  856. if (trigger == btnUP)
  857. {
  858. AL_Minute++;
  859. if (AL_Minute>59) AL_Minute = 0;
  860. }
  861. else if (trigger == btnDOWN)
  862. {
  863. AL_Minute--;
  864. if (AL_Minute<0) AL_Minute = 59;
  865. }
  866. if (trigger == btnMENU)
  867. {
  868. state=SET_AL_ON_OFF;
  869. }
  870. if (trigger == btnBACK)
  871. {
  872.  
  873. state = SET_AL_HOUR;
  874. }
  875. break;
  876.  
  877.  
  878. case SET_AL_ON_OFF:
  879. if (trigger == btnUP)
  880. {
  881. alarm_active = true;
  882. }
  883. else if (trigger == btnDOWN)
  884. {
  885. alarm_active =false;
  886. }
  887.  
  888. if (trigger == btnBACK)
  889. {
  890.  
  891. state = SET_AL_MINUTE;
  892. }
  893. if (trigger == btnMENU)
  894. {
  895. set_alarm();
  896. lcd.clear();
  897. lcd.setCursor(4,0);
  898. lcd.print("Alarm Set!");
  899. delay(1000);
  900. lcd.clear();
  901. state = MAIN;
  902. }
  903.  
  904. break;}}
  905.  
  906.  
  907. void menu_set_time(){
  908. lcd.setCursor(6,0);
  909. lcd.print("MENU");
  910. lcd.setCursor(4,1);
  911. lcd.print("Set Time");
  912. lcd.setCursor(15,1);
  913. lcd.write(5);
  914. lcd.setCursor(0,1);
  915. lcd.write(6);
  916. }
  917.  
  918. void menu_set_date(){
  919. lcd.setCursor(6,0);
  920. lcd.print("MENU");
  921. lcd.setCursor(4,1);
  922. lcd.print("Set Date");
  923. lcd.setCursor(15,1);
  924. lcd.write(5);
  925. lcd.setCursor(0,1);
  926. lcd.write(6);
  927. }
  928.  
  929.  
  930. void menu_set_alarm(){
  931. lcd.setCursor(6,0);
  932. lcd.print("MENU");
  933. lcd.setCursor(4,1);
  934. lcd.print("Set Alarm");
  935. lcd.setCursor(15,1);
  936. lcd.write(5);
  937. }
  938.  
  939. void menu_set_lamp(){
  940. lcd.setCursor(6,0);
  941. lcd.print("MENU");
  942. lcd.setCursor(4,1);
  943. lcd.print("Set Lamp");
  944. lcd.setCursor(0,1);
  945. lcd.write(6);
  946. }
  947.  
  948. void display_time()
  949. {
  950. get_time();
  951. lcd.setCursor(0,0);
  952. display_position(Hour);
  953. lcd.print(":");
  954. display_position(Minute);
  955. lcd.print(":");
  956. display_position(Second);}
  957.  
  958. void display_date(){
  959. get_date();
  960. lcd.setCursor(8,1);
  961. display_position(Day);
  962. lcd.print("/");
  963. display_position(Month);
  964. lcd.print("/");
  965. display_position(Year);
  966. DoW= weekday();
  967. switch(DoW){
  968. case 1: day_of_week = "Sun"; break;
  969. case 2: day_of_week = "Mon"; break;
  970. case 3: day_of_week = "Tue"; break;
  971. case 4: day_of_week = "Wed"; break;
  972. case 5: day_of_week = "Thu"; break;
  973. case 6: day_of_week = "Fri"; break;
  974. case 7: day_of_week = "Sat"; break;}
  975. lcd.setCursor(0,1);
  976. lcd.print (day_of_week);}
  977.  
  978.  
  979. void display_set_time(){
  980. lcd.setCursor(3,0);
  981. lcd.print("Set Time:");
  982. switch (state)
  983. {
  984. case SET_HOUR:
  985. lcd.setCursor(10,1);
  986. lcd.print("h");
  987. if (long_press_button == false){
  988. if (blink_state == 0){
  989. lcd.setCursor(4,1);
  990. display_position(Hour);}
  991. else{
  992. lcd.setCursor(4,1);
  993. lcd.print(" ");}}
  994. else{
  995. lcd.setCursor(4,1);
  996. display_position(Hour);}
  997. lcd.print(":");
  998. display_position(Minute);
  999. break;
  1000. case SET_MINUTE:
  1001. lcd.setCursor(10,1);
  1002. lcd.print("m");
  1003. lcd.setCursor(4,1);
  1004. display_position(Hour);
  1005. lcd.print(":");
  1006. if (long_press_button == false){
  1007. if (blink_state == 0){
  1008. lcd.setCursor(7,1);
  1009. display_position(Minute);
  1010. }
  1011. else{
  1012. lcd.setCursor(7,1);
  1013. lcd.print(" ");
  1014. }}
  1015. else{
  1016. lcd.setCursor(7,1);
  1017. display_position(Minute);
  1018. }
  1019. break;
  1020. }
  1021.  
  1022. }
  1023.  
  1024. void display_set_date(){
  1025. lcd.setCursor(3,0);
  1026. lcd.print("Set Date:");
  1027. switch (state)
  1028. {
  1029. case SET_DAY:
  1030. if (long_press_button == false){
  1031. if (blink_state == 0){
  1032. lcd.setCursor(4,1);
  1033. display_position(Day);
  1034. }
  1035. else{
  1036. lcd.setCursor(4,1);
  1037. lcd.print(" ");
  1038. }
  1039. }
  1040. else{
  1041. lcd.setCursor(4,1);
  1042. display_position(Day);
  1043. }
  1044. lcd.print("/");
  1045. display_position(Month);
  1046. lcd.print("/");
  1047. display_position(Year);
  1048. break;
  1049. case SET_MONTH:
  1050. lcd.setCursor(4,1);
  1051. display_position(Day);
  1052. lcd.print("/");
  1053. if (long_press_button == false){
  1054. if (blink_state == 0){
  1055. lcd.setCursor(7,1);
  1056. display_position(Month);
  1057. }
  1058. else{
  1059. lcd.setCursor(7,1);
  1060. lcd.print(" ");
  1061. }
  1062. }else{
  1063. lcd.setCursor(7,1);
  1064. display_position(Month);
  1065. }
  1066.  
  1067. lcd.print("/");
  1068. display_position(Year);
  1069. break;
  1070. case SET_YEAR:
  1071.  
  1072. lcd.setCursor(4,1);
  1073. display_position(Day);
  1074. lcd.print("/");
  1075. display_position(Month);
  1076. lcd.print("/");
  1077. if (long_press_button == false){
  1078. if (blink_state == 0){
  1079. lcd.setCursor(10,1);
  1080. display_position(Year);
  1081. }
  1082. else{
  1083. lcd.setCursor(10,1);
  1084. lcd.print(" ");
  1085. }}
  1086. else{
  1087. lcd.setCursor(10,1);
  1088. display_position(Year);
  1089. }
  1090. break;
  1091. }
  1092. unsigned long blink_currentMillis = millis();
  1093. if(blink_currentMillis - blink_previousMillis > blink_interval){
  1094. blink_previousMillis = blink_currentMillis;
  1095. if (blink_state == 0){
  1096. blink_state = 1;
  1097. }else{
  1098. blink_state = 0;}}}
  1099.  
  1100. void display_set_AL_time(){
  1101. lcd.setCursor(1,0);
  1102. lcd.print("Set Alarm Time:");
  1103. if (alarm_active==true){
  1104. lcd.setCursor(12,1);
  1105. lcd.print("ON");
  1106. }else{
  1107. lcd.setCursor(12,1);
  1108. lcd.print("OFF");}
  1109.  
  1110. switch (state)
  1111. {
  1112. case SET_AL_HOUR:
  1113. lcd.setCursor(10,1);
  1114. lcd.print("h");
  1115. if (long_press_button == false){
  1116. if (blink_state == 0){
  1117. lcd.setCursor(4,1);
  1118. display_position(AL_Hour);}
  1119. else{
  1120. lcd.setCursor(4,1);
  1121. lcd.print(" ");}}
  1122. else{
  1123. lcd.setCursor(4,1);
  1124. display_position(AL_Hour);
  1125. }
  1126. lcd.print(":");
  1127. display_position(AL_Minute);
  1128. break;
  1129. case SET_AL_MINUTE:
  1130. lcd.setCursor(10,1);
  1131. lcd.print("m");
  1132. lcd.setCursor(4,1);
  1133. display_position(AL_Hour);
  1134. lcd.print(":");
  1135. if (long_press_button == false){
  1136. if (blink_state == 0){
  1137. lcd.setCursor(7,1);
  1138. display_position(AL_Minute);
  1139. }
  1140. else{
  1141. lcd.setCursor(7,1);
  1142. lcd.print(" ");
  1143. }}
  1144. else{
  1145. lcd.setCursor(7,1);
  1146. display_position(AL_Minute);
  1147. }
  1148. break;
  1149.  
  1150. case SET_AL_ON_OFF:
  1151. lcd.setCursor(7,1);
  1152. display_position(AL_Minute);
  1153.  
  1154. if (alarm_active == true){
  1155. if (blink_state == 0){
  1156. lcd.setCursor(14,1);
  1157. lcd.print(" ");
  1158. lcd.setCursor(12,1);
  1159. lcd.print("ON");}
  1160. else{
  1161. lcd.setCursor(12,1);
  1162. lcd.print(" ");}}
  1163. else{
  1164. if (blink_state == 0){
  1165. lcd.setCursor(12,1);
  1166. lcd.print("OFF");
  1167. }
  1168. else{
  1169. lcd.setCursor(12,1);
  1170. lcd.print(" ");
  1171. }
  1172. }
  1173. break;
  1174. }
  1175. }
  1176.  
  1177. void displayALARM(){
  1178. lcd.setCursor(2,0);
  1179. lcd.print("<< ALARM >>");
  1180. lcd.setCursor(3,1);
  1181. display_position(AL_Hour);
  1182. lcd.print(":");
  1183. lcd.setCursor(6,1);
  1184. display_position(AL_Minute);
  1185. lcd.setCursor(9,1);
  1186. lcd.print("h");
  1187.  
  1188. if (alarm_active == true){
  1189. lcd.setCursor(13,1);
  1190. lcd.print(" ");
  1191. lcd.setCursor(11,1);
  1192. lcd.print("ON");}
  1193. else{
  1194. lcd.setCursor(12,1);
  1195. lcd.print("OFF");
  1196. }}
  1197.  
  1198.  
  1199. void displayLAMP(){
  1200. lcd.setCursor(2,0);
  1201. lcd.print("<< LAMBA >>");
  1202. lcd.setCursor(3,1);
  1203. display_position(baslangic);
  1204. lcd.print(":");
  1205. lcd.setCursor(6,1);
  1206. display_position(bitis);
  1207.  
  1208. if (lamp_active == true){
  1209. lcd.setCursor(13,1);
  1210. lcd.print(" ");
  1211. lcd.setCursor(11,1);
  1212. lcd.print("ON");}
  1213. else{
  1214. lcd.setCursor(12,1);
  1215. lcd.print("OFF");
  1216. }}
  1217.  
  1218. void get_time(){
  1219. Wire.beginTransmission(0x68);
  1220. Wire.write(0); //set register to zero
  1221. Wire.endTransmission();
  1222. Wire.requestFrom(0x68, 3);// 3 bytes (sec, min, hour)
  1223. Second = bcdToDec(Wire.read() & 0x7f);
  1224. Minute = bcdToDec(Wire.read());
  1225. Hour = bcdToDec(Wire.read() & 0x3f);}
  1226.  
  1227. void get_date(){
  1228. Wire.beginTransmission(0x68);
  1229. Wire.write(4);//set register to 3 (day)
  1230. Wire.endTransmission();
  1231. Wire.requestFrom(0x68, 3); // 3 bytes (day, month, year) - DOW get from Time.h library
  1232. Day = bcdToDec(Wire.read());
  1233. Month = bcdToDec(Wire.read());
  1234. Year = bcdToDec(Wire.read());}
  1235.  
  1236. void set_time(){
  1237. Wire.beginTransmission(0x68);
  1238. Wire.write(0x00);
  1239. Second=0;
  1240. Wire.write(decToBcd(Second));
  1241. Wire.write(decToBcd(Minute));
  1242. Wire.write(decToBcd(Hour));
  1243. Wire.write(0x00);
  1244. Wire.endTransmission();}
  1245.  
  1246. void set_date(){
  1247. Wire.beginTransmission(0x68);
  1248. Wire.write(4);
  1249. //Wire.write(decToBcd(DoW));
  1250. Wire.write(decToBcd(Day));
  1251. Wire.write(decToBcd(Month));
  1252. Wire.write(decToBcd(Year));
  1253. Wire.endTransmission();}
  1254.  
  1255.  
  1256. void set_alarm(){ //save alarm time to EEPROM
  1257. EEPROM.write(0, AL_Hour);
  1258. EEPROM.write(1, AL_Minute);
  1259. EEPROM.write(2, alarm_active);
  1260. }
  1261.  
  1262.  
  1263. void set_lamp(){ //save alarm time to EEPROM
  1264. EEPROM.write(3, baslangic);
  1265. EEPROM.write(4, bitis);
  1266. EEPROM.write(5, lamp_active);
  1267. }
  1268.  
  1269. void get_alarm(){ //read alarm time from EEPROM
  1270. AL_Hour = EEPROM.read(0);
  1271. if (AL_Hour > 23) AL_Hour=0;
  1272. AL_Minute = EEPROM.read(1);
  1273. if (AL_Minute > 59) AL_Minute=0;
  1274. alarm_active = EEPROM.read(2);
  1275. if(alarm_active==true){
  1276. lcd.setCursor(5,1);
  1277. lcd.write(1);
  1278. }
  1279. else{
  1280. lcd.setCursor(5,1);
  1281. lcd.print(" ");
  1282. }}
  1283.  
  1284.  
  1285.  
  1286. void get_lamp(){ //read alarm time from EEPROM
  1287. baslangic = EEPROM.read(3);
  1288. if (baslangic > 23) baslangic=0;
  1289. bitis = EEPROM.read(4);
  1290. if (bitis > 23) bitis=0;
  1291. lamp_active = EEPROM.read(5);
  1292. if(lamp_active==true){
  1293. lcd.setCursor(6,1);
  1294. lcd.write(1);
  1295. }
  1296. else{
  1297. lcd.setCursor(6,1);
  1298. lcd.print(" ");
  1299. }}
  1300.  
  1301.  
  1302. // check communication with RTC
  1303. void check_RTC()
  1304. {
  1305. if (timeStatus() != timeSet)
  1306. RTC_error = true; // RTC could not be read
  1307. else
  1308. RTC_error = false; // RTC could be read
  1309. }
  1310.  
  1311. byte decToBcd(byte val){
  1312. return ( (val/10*16) + (val%10) );}
  1313.  
  1314. byte bcdToDec(byte val){
  1315. return ( (val/16*10) + (val%16) );}
  1316.  
  1317.  
  1318. void display_position(int digits){
  1319. if(digits < 10)
  1320. lcd.print("0");
  1321. lcd.print(digits);}
  1322.  
  1323. void display_set_lamp_time(){
  1324. lcd.setCursor(1,0);
  1325. lcd.print("Set Lamp Time:");
  1326. if (lamp_active==true){
  1327. lcd.setCursor(12,1);
  1328. lcd.print("ON");
  1329. }else{
  1330. lcd.setCursor(12,1);
  1331. lcd.print("OFF");}
  1332.  
  1333. switch (state)
  1334. {
  1335. case SET_LAMP_START:
  1336. lcd.setCursor(10,1);
  1337. lcd.print("S");
  1338. if (long_press_button == false){
  1339. if (blink_state == 0){
  1340. lcd.setCursor(4,1);
  1341. display_position(baslangic);}
  1342. else{
  1343. lcd.setCursor(4,1);
  1344. lcd.print(" ");}}
  1345. else{
  1346. lcd.setCursor(4,1);
  1347. display_position(baslangic);
  1348. }
  1349. lcd.print(":");
  1350. display_position(bitis);
  1351. break;
  1352. case SET_LAMP_FINISH:
  1353. lcd.setCursor(10,1);
  1354. lcd.print("F");
  1355. lcd.setCursor(4,1);
  1356. display_position(baslangic);
  1357. lcd.print(":");
  1358. if (long_press_button == false){
  1359. if (blink_state == 0){
  1360. lcd.setCursor(7,1);
  1361. display_position(bitis);
  1362. }
  1363. else{
  1364. lcd.setCursor(7,1);
  1365. lcd.print(" ");
  1366. }}
  1367. else{
  1368. lcd.setCursor(7,1);
  1369. display_position(bitis);
  1370. }
  1371. break;
  1372.  
  1373. case SET_LAMP_ON_OFF:
  1374. lcd.setCursor(7,1);
  1375. display_position(bitis);
  1376.  
  1377. if (lamp_active == true){
  1378. if (blink_state == 0){
  1379. lcd.setCursor(14,1);
  1380. lcd.print(" ");
  1381. lcd.setCursor(12,1);
  1382. lcd.print("ON");}
  1383. else{
  1384. lcd.setCursor(12,1);
  1385. lcd.print(" ");}}
  1386. else{
  1387. if (blink_state == 0){
  1388. lcd.setCursor(12,1);
  1389. lcd.print("OFF");
  1390. }
  1391. else{
  1392. lcd.setCursor(12,1);
  1393. lcd.print(" ");
  1394. }
  1395. }
  1396. break;
  1397. }
  1398. }
  1399.  
  1400. void dumpTime(void)
  1401. {
  1402. Serial.println("DCF77 Time");
  1403.  
  1404. // Print date
  1405. Serial.print(" ");
  1406.  
  1407. if(dt.day < 10)
  1408. Serial.print("0");
  1409. Serial.print(dt.day, DEC);
  1410. Serial.print(".");
  1411.  
  1412. if(dt.month < 10)
  1413. Serial.print("0");
  1414. Serial.print(dt.month, DEC);
  1415. Serial.print(".");
  1416.  
  1417. if(dt.year == 0)
  1418. {
  1419. Serial.print("000");
  1420. }
  1421. else
  1422. {
  1423. Serial.print("20");
  1424. }
  1425.  
  1426. Serial.print(dt.year, DEC);
  1427.  
  1428. if(dcf.synced())
  1429. {
  1430. Serial.println(" ");
  1431. Serial.print(" ");
  1432. }
  1433. else
  1434. {
  1435. Serial.println(" ");
  1436. Serial.print("~");
  1437. }
  1438.  
  1439. // Print Time
  1440. if (dt.hour < 10)
  1441. Serial.print("0");
  1442.  
  1443.  
  1444. Serial.print(dt.hour, DEC);
  1445.  
  1446. Serial.print(":");
  1447.  
  1448. if (dt.min < 10)
  1449. Serial.print("0");
  1450.  
  1451.  
  1452. Serial.print(dt.min, DEC);
  1453.  
  1454. Serial.print(":");
  1455.  
  1456. if (dt.sec < 10)
  1457. Serial.print("0");
  1458.  
  1459. Serial.print(dt.sec, DEC);
  1460.  
  1461. Serial.print(" ");
  1462.  
  1463. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!