API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Dec 14th, 2018
68
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 36.91 KB | None | 0 0
raw download clone embed print report
  1. /* Librarii folosite */
  2. #include <IRremote.h>
  3. #include "DHT.h"
  4. #include <LiquidCrystal_I2C.h>
  5. #include <Wire.h>
  6. #include "RTClib.h"
  7.  
  8.  
  9.  
  10. #define PIN_RELEU_PRIZA_0 2
  11. #define PIN_RELEU_PRIZA_1 3
  12. #define PIN_RELEU_PRIZA_2 4
  13.  
  14. #define PIN_SENZOR_DHT11 5
  15. #define PIN_IR_RECEIVER 6
  16.  
  17. #define PIN_BUTON_1 9
  18. #define PIN_BUTON_2 10
  19. #define PIN_BUTON_3 8
  20.  
  21. #define PIN_LED_ROSU 11
  22. #define PIN_LED_VERDE 12
  23. #define PIN_LED_ALBASTRU 13
  24.  
  25. #define PIN_SENZOR_CRT_PRIZA_0 A0
  26. #define PIN_SENZOR_CRT_PRIZA_1 A1
  27. #define PIN_SENZOR_CRT_PRIZA_2 A2
  28.  
  29. #define PIN_SENZOR_LUMINA A3
  30.  
  31. #define NR_PRIZE 2 /* Numerotate: 0,1,2 */
  32.  
  33. const int val_min_lumina = 10; /* Pragul de 0% pentru luminozitate */
  34. const int val_max_lumina = 500; /* Pragul de 100% pentru luminozitate */
  35.  
  36.  
  37. int mVperAmp = 100; // use 100 for 20A Module and 66 for 30A Module
  38.  
  39.  
  40. double Voltage = 0;
  41. double VRMS = 0;
  42. double AmpsRMS = 0;
  43.  
  44. char* tipuri_de_comanda[] = {"Nefolosita", "Temperatura", "Umiditate", "Lumina", "Telecomanda", "Ceas" };
  45. int nr_comenzi_posibile = 5;
  46. /* Initializari senzori */
  47.  
  48. /** Infrared receiver **/
  49. IRrecv irrecv(PIN_IR_RECEIVER);
  50. decode_results results;
  51. /** Humidity/Temperature **/
  52. DHT dht(PIN_SENZOR_DHT11, DHT11);
  53. /** LCD Display **/
  54. LiquidCrystal_I2C lcd(0x3F, 20, 4); // set the LCD address to 0x27 for a 16 chars and 2 line display
  55. /** Modul RTC**/
  56. RTC_DS1307 RTC;
  57.  
  58. enum culori_led
  59. {
  60. rosu,
  61. verde,
  62. albastru,
  63. mov,
  64. portocaliu,
  65. stins
  66. };
  67.  
  68. enum ceas
  69. {
  70. ora,
  71. minut,
  72. secunda
  73. };
  74.  
  75. enum meniuri_posibile
  76. {
  77. meniu_initializare,
  78. meniu_monitorizare,
  79. meniu_selectMenu,
  80. meniu_senzori,
  81. meniu_manual
  82. };
  83.  
  84. //int meniuCurent = meniu_initializare;
  85. int meniuCurent = meniu_senzori;
  86. // int meniuCurent = meniu_manual;
  87. /* Structuri */
  88. typedef struct
  89. {
  90. char nume[10]; /* Nume asociat prizei (orientativ) */
  91. bool stare; /* FALSE - Nerogramata / TRUE = Programata */
  92. bool pornita;
  93. int pin_releu; /* Pinul digital la care este legat releul asociat prizei */
  94. int pin_senzorCurent; /* Pinul analogic la care este legat senzorul de curent asociat prizei */
  95. float consum_I; /* Consumul de curent instantaneu al prizei */
  96. int tip_comanda; /* 0 - Nefolosita, 1 - Temperatura, 2 - Umiditate, 3 - Lumina, 4 - Telecomanda, 5 - Ceas */
  97. float prag_temperatura; /* Pragul de temperatura exprimat in grade celsius la care priza porneste */
  98. float prag_umiditate; /* Pragul de umiditate exprimat in procente [0:100%]*/
  99. int prag_lumina; /* Pragul de luminozitate exprimat in procente [0:100%]*/
  100. unsigned long cod_telecomanda;
  101. int ceasON_ora;
  102. int ceasON_minut;
  103. int ceasOFF_ora;
  104. int ceasOFF_minut;
  105. } structura_priza;
  106.  
  107.  
  108. structura_priza prizaNr[] =
  109. {
  110. {
  111. "Priza 0",
  112. false,
  113. false,
  114. PIN_RELEU_PRIZA_0,
  115. PIN_SENZOR_CRT_PRIZA_0,
  116. 0, //consum
  117. 0, //comanda
  118. 15, //grade
  119. 15, //umiditate
  120. 0, //prag lumina
  121. 0, //cod telecomanda
  122. 0, //ceasON ora
  123. 0, //ceasON minut
  124. 0, //ceasOFF ora
  125. 0 //ceasOFF minut
  126. },
  127.  
  128. {
  129. "Priza 1",
  130. false,
  131. false,
  132. PIN_RELEU_PRIZA_1,
  133. PIN_SENZOR_CRT_PRIZA_1,
  134. 0, //consum
  135. 0, //comanda
  136. 15, //grade
  137. 15, //umiditate
  138. 0, //prag lumina
  139. 0, //cod telecomanda
  140. 0, //ceasON ora
  141. 0, //ceasON minut
  142. 0, //ceasOFF ora
  143. 0 //ceasOFF minut
  144. },
  145.  
  146. {
  147. "Priza 2",
  148. false,
  149. false,
  150. PIN_RELEU_PRIZA_2,
  151. PIN_SENZOR_CRT_PRIZA_2,
  152. 0, //consum
  153. 0, //comanda
  154. 15, //grade
  155. 15, //umiditate
  156. 0, //prag lumina
  157. 0, //cod telecomanda
  158. 0, //ceasON ora
  159. 0, //ceasON minut
  160. 0, //ceasOFF ora
  161. 0 //ceasOFF minut
  162. }
  163.  
  164. };
  165.  
  166. //PICTOGRAME
  167. byte termometru[8] = //icon for termometer
  168. {
  169. B00100,
  170. B01010,
  171. B01010,
  172. B01010,
  173. B01110,
  174. B11111,
  175. B11111,
  176. B01110
  177. };
  178.  
  179. byte picatura[8] = //icon for water droplet
  180. {
  181. B00100,
  182. B00100,
  183. B01010,
  184. B01010,
  185. B10001,
  186. B10001,
  187. B10001,
  188. B01110,
  189. };
  190.  
  191. byte soare[8] = //icon for water droplet
  192. {
  193. B00000,
  194. B00100,
  195. B10101,
  196. B01110,
  197. B01110,
  198. B10101,
  199. B00100,
  200. B00000,
  201. };
  202.  
  203. byte ceas[8] = //icon for water droplet
  204. {
  205. B00000,
  206. B01110,
  207. B10001,
  208. B10011,
  209. B10101,
  210. B10101,
  211. B01110,
  212. B00000,
  213. };
  214.  
  215. byte curent[8] = //icon for water droplet
  216. {
  217. B11111,
  218. B11011,
  219. B10001,
  220. B11011,
  221. B11111,
  222. B11111,
  223. B10001,
  224. B11111,
  225. };
  226.  
  227.  
  228. byte bullet[8] = //icon for water droplet
  229. {
  230. B00000,
  231. B00000,
  232. B00100,
  233. B01110,
  234. B11011,
  235. B01110,
  236. B00100,
  237. B00000,
  238. };
  239.  
  240. void setup() {
  241.  
  242. digitalWrite(PIN_RELEU_PRIZA_0, HIGH);
  243. digitalWrite(PIN_RELEU_PRIZA_1, HIGH);
  244. digitalWrite(PIN_RELEU_PRIZA_2, HIGH);
  245. // put your setup code here, to run once:
  246.  
  247. pinMode(PIN_RELEU_PRIZA_0, OUTPUT);
  248. pinMode(PIN_RELEU_PRIZA_1, OUTPUT);
  249. pinMode(PIN_RELEU_PRIZA_2, OUTPUT);
  250.  
  251. pinMode(PIN_SENZOR_DHT11, OUTPUT);
  252. pinMode(PIN_IR_RECEIVER , OUTPUT);
  253.  
  254. pinMode(PIN_BUTON_1 , INPUT_PULLUP);
  255. pinMode(PIN_BUTON_2 , INPUT_PULLUP);
  256. pinMode(PIN_BUTON_3 , INPUT_PULLUP);
  257.  
  258. pinMode(PIN_LED_ROSU, OUTPUT);
  259. pinMode(PIN_LED_VERDE , OUTPUT);
  260. pinMode(PIN_LED_ALBASTRU , OUTPUT);
  261.  
  262. pinMode(PIN_SENZOR_CRT_PRIZA_0 , INPUT);
  263. pinMode(PIN_SENZOR_CRT_PRIZA_1 , INPUT);
  264. pinMode(PIN_SENZOR_CRT_PRIZA_2 , INPUT);
  265.  
  266. pinMode(PIN_SENZOR_LUMINA , INPUT);
  267. Serial.begin(9600);
  268.  
  269. irrecv.enableIRIn(); // Start the receiver
  270. dht.begin();
  271. Wire.begin();
  272. RTC.begin();
  273. lcd.init();
  274. lcd.backlight();
  275. if (! RTC.isrunning()) {
  276. RTC.adjust(DateTime(__DATE__, __TIME__));
  277. }
  278.  
  279. lcd.createChar(0, termometru);
  280. lcd.createChar(1, picatura);
  281. lcd.createChar(2, soare);
  282. lcd.createChar(3, ceas);
  283. lcd.createChar(4, curent);
  284. lcd.createChar(5, bullet);
  285. }
  286.  
  287. void loop() {
  288.  
  289.  
  290. //digitalWrite(PIN_RELEU_PRIZA_0, LOW);
  291. //digitalWrite(PIN_RELEU_PRIZA_1, HIGH);
  292. //digitalWrite(PIN_RELEU_PRIZA_2, HIGH);
  293.  
  294. for (int i = 0; i <= NR_PRIZE; i++) //parcurg fiecare priza
  295. {
  296. prizaNr[i].consum_I = citire_senzor_curent(prizaNr[i].pin_senzorCurent);
  297. }
  298.  
  299. switch (meniuCurent)
  300. {
  301. case meniu_initializare:
  302. {
  303. func_meniu_initializare();
  304. break;
  305. }
  306.  
  307. case meniu_monitorizare:
  308. {
  309. func_meniu_monitorizare();
  310. actualizare_stare_prize();
  311. break;
  312. }
  313. case meniu_senzori:
  314. {
  315. func_meniu_senzori();
  316. break;
  317. }
  318.  
  319. case meniu_selectMenu:
  320. {
  321. func_meniu_selectMenu();
  322. break;
  323. }
  324.  
  325. case meniu_manual:
  326. {
  327. func_meniu_manual();
  328. actualizare_releu();
  329. break;
  330. }
  331. }
  332.  
  333. // DateTime now = RTC.now();
  334. // lcd.clear();
  335. // lcd.setCursor(0, 0);
  336. //
  337. // lcd.print(now.year(), DEC);
  338. // lcd.print('/');
  339. // lcd.print(now.month(), DEC);
  340. // lcd.print('/');
  341. // lcd.print(now.day(), DEC);
  342. // lcd.print(' ');
  343. // lcd.print(now.hour(), DEC);
  344. // lcd.print(':');
  345. // lcd.print(now.minute(), DEC);
  346. // lcd.print(':');
  347. // lcd.print(now.second(), DEC);
  348. // // put your main code here, to run repeatedly:
  349. //
  350. // if (digitalRead(PIN_BUTON_1) == LOW)
  351. // {
  352. // // digitalWrite(PIN_LED_ROSU, HIGH);
  353. // aprinde_led(portocaliu);
  354. // digitalWrite(PIN_RELEU_PRIZA_0, LOW);
  355. // }
  356. // else
  357. // {
  358. // //digitalWrite(PIN_LED_ROSU, LOW);
  359. // aprinde_led(stins);
  360. // digitalWrite(PIN_RELEU_PRIZA_0, HIGH);
  361. // }
  362. //
  363. // /***********************************************************/
  364. // if (digitalRead(PIN_BUTON_2) == LOW)
  365. // {
  366. // digitalWrite(PIN_LED_VERDE, HIGH);
  367. // digitalWrite(PIN_RELEU_PRIZA_1, LOW);
  368. // }
  369. //
  370. // else
  371. // {
  372. // digitalWrite(PIN_LED_VERDE, LOW);
  373. // digitalWrite(PIN_RELEU_PRIZA_1, HIGH);
  374. // }
  375. //
  376. // /************************************************************/
  377. // if (digitalRead(PIN_BUTON_3) == LOW)
  378. // {
  379. // digitalWrite(PIN_LED_ALBASTRU, HIGH);
  380. // digitalWrite(PIN_RELEU_PRIZA_2, LOW);
  381. // }
  382. //
  383. // else
  384. // {
  385. // digitalWrite(PIN_LED_ALBASTRU, LOW);
  386. // digitalWrite(PIN_RELEU_PRIZA_2, HIGH);
  387. // }
  388. // if (irrecv.decode(&results))
  389. // {
  390. //
  391. // Serial.println(results.value, HEX);
  392. // irrecv.resume();
  393. // }
  394. // //Serial.println("######################");
  395. // //Serial.print("Nivel lumina: ");
  396. // //Serial.print(citire_senzor_lumina());
  397. // //Serial.println("%");
  398. // //
  399. // //Serial.println("######################");
  400. // //Serial.print("Nivel temperatura: ");
  401. // //Serial.print(citire_senzor_temperatura());
  402. // //Serial.println(" *C");
  403. // //
  404. // //
  405. // //Serial.println("######################");
  406. // //Serial.print("Nivel umiditate: ");
  407. // //Serial.print(citire_senzor_umiditate());
  408. // //Serial.println(" %");
  409. // //
  410. // //Serial.println("######################");
  411. // Serial.print("Curent consumat: ");
  412. // Serial.print(citire_senzor_curent(PIN_SENZOR_CRT_PRIZA_2));
  413. // Serial.println(" A");
  414. // //delay(500);
  415.  
  416. }
  417.  
  418. void aprinde_led(int culoare)
  419. {
  420.  
  421. if (culoare == rosu)
  422. {
  423. digitalWrite(PIN_LED_VERDE, LOW); // sting LEDul verde
  424. digitalWrite(PIN_LED_ALBASTRU, LOW); // sting LEDul albastru
  425. digitalWrite(PIN_LED_ROSU, HIGH); // aprind LEDul rosu
  426. }
  427. if (culoare == verde)
  428. {
  429. digitalWrite(PIN_LED_ALBASTRU, LOW); // sting LEDul albastru
  430. digitalWrite(PIN_LED_ROSU, LOW); // sting LEDul rosu
  431. digitalWrite(PIN_LED_VERDE, HIGH); // aprind LEDul verde
  432. }
  433. if (culoare == albastru)
  434. {
  435. digitalWrite(PIN_LED_ROSU, LOW); // sting LEDul rosu
  436. digitalWrite(PIN_LED_VERDE, LOW); // sting LEDul verde
  437. digitalWrite(PIN_LED_ALBASTRU, HIGH); // aprind LEDul albastru
  438. }
  439.  
  440. if (culoare == mov)
  441. {
  442. digitalWrite(PIN_LED_ROSU, HIGH); // aprind LEDul rosu
  443. digitalWrite(PIN_LED_VERDE, LOW); // sting LEDul verde
  444. digitalWrite(PIN_LED_ALBASTRU, HIGH); // aprind LEDul albastru
  445. }
  446.  
  447. if (culoare == portocaliu)
  448. {
  449. digitalWrite(PIN_LED_ROSU, HIGH); // aprind LEDul rosu
  450. digitalWrite(PIN_LED_VERDE, HIGH); // aprind LEDul verde
  451. digitalWrite(PIN_LED_ALBASTRU, LOW); // sting LEDul albastru
  452. }
  453. if (culoare == stins)
  454. {
  455. digitalWrite(PIN_LED_ROSU, LOW); // sting LEDul rosu
  456. digitalWrite(PIN_LED_VERDE, LOW); // sting LEDul verde
  457. digitalWrite(PIN_LED_ALBASTRU, LOW); // sting LEDul albastru
  458. }
  459. }
  460.  
  461. int citire_senzor_lumina()
  462. {
  463. int valoareEfectiva; /* Valoarea citita analogic de la fotorezistor */
  464. int valoareProcentuala; /* Valoarea citita anterior si mapata la intervalul [0:100] */
  465.  
  466. valoareEfectiva = analogRead(PIN_SENZOR_LUMINA); /* Citesc senzorul analogic */
  467.  
  468. /* Mapez valoare la noul interval */
  469. valoareProcentuala = map(valoareEfectiva, val_min_lumina, val_max_lumina, 0, 100);
  470.  
  471. return valoareProcentuala; /* Returnez valoarea in procente */
  472. }
  473.  
  474.  
  475. float citire_senzor_temperatura()
  476. {
  477. float temperatura_citita = 0;
  478. temperatura_citita = dht.readTemperature(); /* Valoarea temperaturii returnata de senzorul DHT11 */
  479.  
  480. return temperatura_citita * 0.896; /* Returnez valoarea inmultita cu un factor de calibrare */
  481. }
  482.  
  483. float citire_senzor_umiditate()
  484. {
  485. float umiditate_citita = 0;
  486. umiditate_citita = dht.readHumidity(); /* Valoarea temperaturii citita de senzorul DHT11 */
  487.  
  488. return umiditate_citita; /* Returnez valoarea citita */
  489. }
  490.  
  491. float citire_senzor_curent(int param_pin_senzor)
  492. {
  493. float result;
  494. int readValue; /* Valoarea citita de la senzor */
  495. int maxValue = 0; /* Valoarea maxima */
  496. int minValue = 1024; /* Valoarea minima */
  497.  
  498. uint32_t start_time = millis();
  499.  
  500. while ((millis() - start_time) < 100)
  501. {
  502. /* Masor timp de o secunda */
  503. readValue = analogRead(param_pin_senzor);
  504.  
  505. /* Verific daca am o valoare mai mare decat maxValue */
  506. if (readValue > maxValue)
  507. {
  508. /* Daca e mai mare, aceasta devine valoarea maxima */
  509. maxValue = readValue;
  510. }
  511.  
  512. /* Verific daca am o valoare mai mica decat minValue */
  513. if (readValue < minValue)
  514. {
  515. /*Daca e mai mica, aceasta devine valoarea minima */
  516. minValue = readValue;
  517. }
  518. }
  519.  
  520. /* Calculez curentul consumat */
  521. result = ((maxValue - minValue) * 5.0) / 1024.0;
  522. Voltage = result;
  523. VRMS = (Voltage / 2.0) * 0.707;
  524. AmpsRMS = (VRMS * 1000) / mVperAmp;
  525.  
  526. if (AmpsRMS < 0.06)
  527. {
  528. /* Elimin citirile eronate */
  529. AmpsRMS = 0;
  530. }
  531.  
  532. return AmpsRMS;
  533. }
  534.  
  535. unsigned long citire_senzor_IR()
  536. {
  537. if (irrecv.decode(&results))
  538. {
  539. irrecv.resume();
  540. }
  541.  
  542. return results.value;
  543. }
  544.  
  545. int citire_senzor_ceas(int param) /*param = ORA sau MINUT */
  546. {
  547. int retVal = 0;
  548. DateTime now = RTC.now();
  549.  
  550. /* Daca parametrul cerut este ora */
  551. if (param == ora)
  552. {
  553. retVal = now.hour();
  554. }
  555.  
  556. /* Daca parametrul cerut este minutul */
  557. if (param == minut)
  558. {
  559. retVal = now.minute();
  560. }
  561.  
  562. /* Daca parametrul cerut este secunda */
  563. if (param == secunda)
  564. {
  565. retVal = now.second();
  566. }
  567.  
  568. /* Returnez valoarea citita */
  569. return retVal;
  570. }
  571.  
  572. void func_meniu_initializare()
  573. {
  574. meniuCurent = meniu_initializare;
  575. for (int i = 0; i <= NR_PRIZE; i++) //parcurg fiecare priza
  576. {
  577. while ( prizaNr[i].stare == false)
  578. {
  579. lcd.setCursor(0, 0);
  580. lcd.print("Cum comand ");
  581. lcd.print(prizaNr[i].nume);
  582. lcd.print("?");
  583. lcd.setCursor(0, 1);
  584. lcd.print(prizaNr[i].tip_comanda);
  585. lcd.print(" -> ");
  586. lcd.print(tipuri_de_comanda[prizaNr[i].tip_comanda]);
  587.  
  588. lcd.setCursor(0, 3);
  589. lcd.print(" + OK -");
  590.  
  591.  
  592. if (digitalRead(PIN_BUTON_1) == LOW)
  593. {
  594. lcd.clear();
  595. if (prizaNr[i].tip_comanda < nr_comenzi_posibile)
  596. prizaNr[i].tip_comanda ++;
  597. else
  598. prizaNr[i].tip_comanda = 0;
  599. }
  600.  
  601. if (digitalRead(PIN_BUTON_3) == LOW)
  602. {
  603. lcd.clear();
  604. if (prizaNr[i].tip_comanda > 0 )
  605. prizaNr[i].tip_comanda --;
  606. else
  607. prizaNr[i].tip_comanda = nr_comenzi_posibile;
  608. }
  609.  
  610. if (digitalRead(PIN_BUTON_2) == LOW)
  611. {
  612.  
  613. lcd.clear();
  614. switch (prizaNr[i].tip_comanda)
  615. {
  616. case 0: /* Cazul in care tipul de comanda este: Nefolosita */
  617. { // mergi la urmatoarea priza
  618. prizaNr[i].stare = true;
  619.  
  620. break;
  621. }
  622. case 1: /* Cazul in care tipul de comanda este: Temperatura */
  623. {
  624. while ( digitalRead(PIN_BUTON_3) == HIGH) //cat timp nu apas OK
  625. {
  626.  
  627. lcd.setCursor(0, 0);
  628. lcd.print("Temp. citita: ");
  629. lcd.print(citire_senzor_temperatura(), 1);
  630. lcd.print((char)223);
  631. lcd.print("C");
  632. lcd.setCursor(0, 1);
  633. lcd.print("Prag pornire: ");
  634.  
  635. lcd.print(prizaNr[i].prag_temperatura, 1);
  636. lcd.print((char)223);
  637. lcd.print("C");
  638. lcd.setCursor(0, 3);
  639. lcd.print(" + - SET");
  640.  
  641. if (digitalRead(PIN_BUTON_1) == LOW)
  642. {
  643. lcd.clear();
  644. if ( prizaNr[i].prag_temperatura < 35)
  645. {
  646. prizaNr[i].prag_temperatura = prizaNr[i].prag_temperatura + 0.5;
  647. delay(200);
  648. }
  649. else
  650. prizaNr[i].prag_temperatura = 15;
  651. }
  652.  
  653. if (digitalRead(PIN_BUTON_2) == LOW)
  654. {
  655. lcd.clear();
  656. if ( prizaNr[i].prag_temperatura > 15)
  657. {
  658. prizaNr[i].prag_temperatura = prizaNr[i].prag_temperatura - 0.5;
  659. delay(200);
  660. }
  661. else
  662. prizaNr[i].prag_temperatura = 35;
  663. }
  664. }
  665.  
  666. prizaNr[i].stare = true;
  667.  
  668. lcd.clear();
  669.  
  670. break;
  671. }
  672.  
  673. case 2: /* Cazul in care tipul de comanda este: Umiditate */
  674. {
  675. while ( digitalRead(PIN_BUTON_3) == HIGH) //cat timp nu apas OK
  676. {
  677. lcd.setCursor(0, 3);
  678. lcd.print(" + - SET");
  679. lcd.setCursor(0, 0);
  680. lcd.print("Umid. citita: ");
  681. lcd.print(citire_senzor_umiditate(), 1);
  682. lcd.print("%");
  683.  
  684. lcd.setCursor(0, 1);
  685. lcd.print("Prag umidit.: ");
  686. lcd.print(prizaNr[i].prag_umiditate, 1);
  687. lcd.print("%");
  688.  
  689. if (digitalRead(PIN_BUTON_1) == LOW)
  690. {
  691. lcd.clear();
  692. if ( prizaNr[i].prag_umiditate < 100)
  693. {
  694. prizaNr[i].prag_umiditate = prizaNr[i].prag_umiditate + 5;
  695. delay(200);
  696. }
  697. else
  698. prizaNr[i].prag_umiditate = 15;
  699. }
  700.  
  701. if (digitalRead(PIN_BUTON_2) == LOW)
  702. {
  703. lcd.clear();
  704. if ( prizaNr[i].prag_umiditate > 15)
  705. {
  706. prizaNr[i].prag_umiditate = prizaNr[i].prag_umiditate - 5;
  707. delay(200);
  708. }
  709. else
  710. prizaNr[i].prag_umiditate = 100;
  711. }
  712. }
  713. prizaNr[i].stare = true;
  714.  
  715. lcd.clear();
  716.  
  717. break;
  718.  
  719. }
  720.  
  721.  
  722. case 3: /* Cazul in care tipul de comanda este: Luminozitate */
  723. {
  724. while ( digitalRead(PIN_BUTON_3) == HIGH) //cat timp nu apas OK
  725. {
  726. lcd.setCursor(0, 3);
  727. lcd.print(" + - SET");
  728. lcd.setCursor(0, 0);
  729. lcd.print("Lum. citita: ");
  730. lcd.print(citire_senzor_lumina());
  731. lcd.print("%");
  732.  
  733. lcd.setCursor(0, 1);
  734. lcd.print("Prag lumin.: ");
  735. lcd.print(prizaNr[i].prag_lumina, 1);
  736.  
  737. lcd.print("%");
  738.  
  739. if (digitalRead(PIN_BUTON_1) == LOW)
  740. {
  741. lcd.clear();
  742. if ( prizaNr[i].prag_lumina < 100)
  743. {
  744. prizaNr[i].prag_lumina = prizaNr[i].prag_lumina + 2;
  745. delay(200);
  746. }
  747. else
  748. prizaNr[i].prag_lumina = 0;
  749. }
  750.  
  751. if (digitalRead(PIN_BUTON_2) == LOW)
  752. {
  753. lcd.clear();
  754. if ( prizaNr[i].prag_lumina > 0)
  755. {
  756. prizaNr[i].prag_lumina = prizaNr[i].prag_lumina - 2;
  757. delay(200);
  758. }
  759. else
  760. prizaNr[i].prag_lumina = 100;
  761. }
  762. }
  763. prizaNr[i].stare = true;
  764.  
  765. lcd.clear();
  766.  
  767. break;
  768.  
  769. }
  770.  
  771. case 4: /* Cazul in care tipul de comanda este: Telecomanda */
  772. {
  773. while ( digitalRead(PIN_BUTON_3) == HIGH) //cat timp nu apas OK
  774. {
  775. lcd.setCursor(0, 3);
  776. lcd.print(" SET");
  777. lcd.setCursor(0, 0);
  778. lcd.print("Astept cod IR");
  779. lcd.setCursor(0, 1);
  780. lcd.print("Cod citit: ");
  781. prizaNr[i].cod_telecomanda = citire_senzor_IR();
  782. lcd.print(citire_senzor_IR(), HEX);
  783.  
  784.  
  785.  
  786.  
  787. }
  788. prizaNr[i].stare = true;
  789.  
  790. lcd.clear();
  791.  
  792. break;
  793.  
  794. }
  795.  
  796.  
  797. case 5: /* Cazul in care tipul de comanda este: CEAS */
  798. {
  799. prizaNr[i].ceasON_ora = citire_senzor_ceas(ora);
  800. prizaNr[i].ceasON_minut = citire_senzor_ceas(minut);
  801. prizaNr[i].ceasOFF_ora = citire_senzor_ceas(ora);
  802. prizaNr[i].ceasOFF_minut = citire_senzor_ceas(minut);
  803.  
  804.  
  805. while ( digitalRead(PIN_BUTON_3) == HIGH) //cat timp nu apas OK
  806. {
  807.  
  808. lcd.setCursor(0, 3);
  809. lcd.print(" + - SET");
  810. lcd.setCursor(0, 0);
  811. lcd.print("Ora curenta: ");
  812. lcd.print(citire_senzor_ceas(ora));
  813. lcd.print(":");
  814. lcd.print(citire_senzor_ceas(minut));
  815.  
  816.  
  817. lcd.setCursor(0, 1);
  818. lcd.print("Ora ON: ");
  819. lcd.print(prizaNr[i].ceasON_ora);
  820. lcd.setCursor(12, 1);
  821. lcd.print(" <-");
  822. lcd.setCursor(0, 2);
  823. lcd.print("Minut ON: ");
  824. lcd.print(prizaNr[i].ceasON_minut);
  825.  
  826.  
  827. if (digitalRead(PIN_BUTON_1) == LOW)
  828. {
  829. lcd.clear();
  830. if ( prizaNr[i].ceasON_ora < 23)
  831. {
  832. prizaNr[i].ceasON_ora = prizaNr[i].ceasON_ora + 1;
  833. delay(200);
  834. }
  835. else
  836. prizaNr[i].ceasON_ora = 0;
  837. }
  838.  
  839. if (digitalRead(PIN_BUTON_2) == LOW)
  840. {
  841. lcd.clear();
  842. if ( prizaNr[i].ceasON_ora > 0)
  843. {
  844. prizaNr[i].ceasON_ora = prizaNr[i].ceasON_ora - 1;
  845. delay(200);
  846. }
  847. else
  848. prizaNr[i].ceasON_ora = 23;
  849. }
  850.  
  851. }
  852. delay(300);
  853. lcd.clear();
  854. while ( digitalRead(PIN_BUTON_3) == HIGH) //cat timp nu apas OK
  855. {
  856.  
  857. lcd.setCursor(0, 3);
  858. lcd.print(" + - SET");
  859. lcd.setCursor(0, 0);
  860. lcd.print("Ora curenta: ");
  861. lcd.print(citire_senzor_ceas(ora));
  862. lcd.print(":");
  863. lcd.print(citire_senzor_ceas(minut));
  864.  
  865.  
  866. lcd.setCursor(0, 1);
  867. lcd.print("Ora ON: ");
  868. lcd.print(prizaNr[i].ceasON_ora);
  869. lcd.setCursor(0, 2);
  870. lcd.print("Minut ON: ");
  871. lcd.print(prizaNr[i].ceasON_minut);
  872. lcd.setCursor(12, 2);
  873. lcd.print(" <-");
  874.  
  875.  
  876. if (digitalRead(PIN_BUTON_1) == LOW)
  877. {
  878. lcd.clear();
  879. if ( prizaNr[i].ceasON_minut < 59)
  880. {
  881. prizaNr[i].ceasON_minut = prizaNr[i].ceasON_minut + 1;
  882. delay(200);
  883. }
  884. else
  885. prizaNr[i].ceasON_minut = 0;
  886. }
  887.  
  888. if (digitalRead(PIN_BUTON_2) == LOW)
  889. {
  890. lcd.clear();
  891. if ( prizaNr[i].ceasON_minut > 0)
  892. {
  893. prizaNr[i].ceasON_minut = prizaNr[i].ceasON_minut - 1;
  894. delay(200);
  895. }
  896. else
  897. prizaNr[i].ceasON_minut = 59;
  898. }
  899.  
  900.  
  901. }
  902. //DE AICICIAICAICAIC
  903. delay(300);
  904. lcd.clear();
  905. while ( digitalRead(PIN_BUTON_3) == HIGH) //cat timp nu apas OK
  906. {
  907.  
  908. lcd.setCursor(0, 3);
  909. lcd.print(" + - SET");
  910. lcd.setCursor(0, 0);
  911. lcd.print("Ora curenta: ");
  912. lcd.print(citire_senzor_ceas(ora));
  913. lcd.print(":");
  914. lcd.print(citire_senzor_ceas(minut));
  915.  
  916.  
  917. lcd.setCursor(0, 1);
  918. lcd.print("Ora OFF: ");
  919. lcd.print(prizaNr[i].ceasOFF_ora);
  920. lcd.setCursor(12, 1);
  921. lcd.print(" <-");
  922. lcd.setCursor(0, 2);
  923. lcd.print("Min OFF: ");
  924. lcd.print(prizaNr[i].ceasOFF_minut);
  925.  
  926.  
  927. if (digitalRead(PIN_BUTON_1) == LOW)
  928. {
  929. lcd.clear();
  930. if ( prizaNr[i].ceasOFF_ora < 23)
  931. {
  932. prizaNr[i].ceasOFF_ora = prizaNr[i].ceasOFF_ora + 1;
  933. delay(200);
  934. }
  935. else
  936. prizaNr[i].ceasOFF_ora = 0;
  937. }
  938.  
  939. if (digitalRead(PIN_BUTON_2) == LOW)
  940. {
  941. lcd.clear();
  942. if ( prizaNr[i].ceasOFF_ora > 0)
  943. {
  944. prizaNr[i].ceasOFF_ora = prizaNr[i].ceasOFF_ora - 1;
  945. delay(200);
  946. }
  947. else
  948. prizaNr[i].ceasOFF_ora = 23;
  949. }
  950.  
  951. }
  952. delay(300);
  953. lcd.clear();
  954. while ( digitalRead(PIN_BUTON_3) == HIGH) //cat timp nu apas OK
  955. {
  956.  
  957. lcd.setCursor(0, 3);
  958. lcd.print(" + - SET");
  959. lcd.setCursor(0, 0);
  960. lcd.print("Ora curenta: ");
  961. lcd.print(citire_senzor_ceas(ora));
  962. lcd.print(":");
  963. lcd.print(citire_senzor_ceas(minut));
  964.  
  965.  
  966. lcd.setCursor(0, 1);
  967. lcd.print("Ora OFF: ");
  968. lcd.print(prizaNr[i].ceasOFF_ora);
  969. lcd.setCursor(0, 2);
  970. lcd.print("Min OFF: ");
  971. lcd.print(prizaNr[i].ceasOFF_minut);
  972. lcd.setCursor(12, 2);
  973. lcd.print(" <-");
  974.  
  975.  
  976. if (digitalRead(PIN_BUTON_1) == LOW)
  977. {
  978. lcd.clear();
  979. if ( prizaNr[i].ceasOFF_minut < 59)
  980. {
  981. prizaNr[i].ceasOFF_minut = prizaNr[i].ceasOFF_minut + 1;
  982. delay(200);
  983. }
  984. else
  985. prizaNr[i].ceasOFF_minut = 0;
  986. }
  987.  
  988. if (digitalRead(PIN_BUTON_2) == LOW)
  989. {
  990. lcd.clear();
  991. if ( prizaNr[i].ceasOFF_minut > 0)
  992. {
  993. prizaNr[i].ceasOFF_minut = prizaNr[i].ceasOFF_minut - 1;
  994. delay(200);
  995. }
  996. else
  997. prizaNr[i].ceasOFF_minut = 59;
  998. }
  999.  
  1000.  
  1001. }
  1002. //pana aiciaiciacia
  1003. prizaNr[i].stare = true;
  1004.  
  1005. lcd.clear();
  1006. break;
  1007.  
  1008. }
  1009.  
  1010. }
  1011. }
  1012.  
  1013.  
  1014. delay(200);
  1015.  
  1016. }
  1017. }
  1018. lcd.clear();
  1019. lcd.print("Prizele au fost");
  1020. lcd.setCursor(0, 1);
  1021. lcd.print("configurate");
  1022. delay(1000);
  1023. meniuCurent = meniu_monitorizare;
  1024.  
  1025. }
  1026. void func_meniu_monitorizare()
  1027. {
  1028. meniuCurent = meniu_monitorizare;
  1029. lcd.clear();
  1030. lcd.setCursor(0, 3);
  1031. lcd.print("|menu|");
  1032. for (int i = 0; i <= NR_PRIZE; i++) //parcurg fiecare priza
  1033. {
  1034. lcd.setCursor(0, i);
  1035. lcd.print(prizaNr[i].nume);
  1036. lcd.print(" |");
  1037.  
  1038. if (prizaNr[i].pornita == 1)
  1039. lcd.print("ON | ");
  1040. else
  1041. lcd.print("OFF| ");
  1042.  
  1043. lcd.print(prizaNr[i].consum_I);
  1044. lcd.setCursor(19, i);
  1045. lcd.print("A");
  1046.  
  1047. }
  1048. delay(100);
  1049.  
  1050. if (digitalRead(PIN_BUTON_1) == LOW)
  1051. {
  1052. func_meniu_selectMenu();
  1053. }
  1054. }
  1055.  
  1056.  
  1057.  
  1058. void func_meniu_senzori()
  1059. {
  1060.  
  1061.  
  1062. //lcd.clear();
  1063.  
  1064. //lcd.setCursor(0,3);
  1065. //lcd.print("|menu|");
  1066.  
  1067. lcd.setCursor(11, 0);
  1068. lcd.print(" ");
  1069. lcd.setCursor(0, 0);
  1070. lcd.print("|Temp|");
  1071. lcd.write(0);
  1072. lcd.print("| -> ");
  1073. lcd.print(citire_senzor_temperatura(), 1);
  1074. lcd.print((char)223);
  1075. lcd.print("C");
  1076.  
  1077. lcd.setCursor(11, 1);
  1078. lcd.print(" ");
  1079. lcd.setCursor(0, 1);
  1080. lcd.print("|Umid|");
  1081. lcd.write(1);
  1082. lcd.print("| -> ");
  1083. lcd.print(citire_senzor_umiditate(), 1);
  1084. lcd.print("%");
  1085.  
  1086. lcd.setCursor(11, 2);
  1087. lcd.print(" ");
  1088. lcd.setCursor(0, 2);
  1089. lcd.print("|Lumi|");
  1090. lcd.write(2);
  1091. lcd.print("| -> ");
  1092. lcd.print(citire_senzor_lumina());
  1093. lcd.print("%");
  1094.  
  1095. lcd.setCursor(11, 3);
  1096. lcd.print(" ");
  1097. lcd.setCursor(0, 3);
  1098. lcd.print("|Ceas|");
  1099. lcd.write(3);
  1100. lcd.print("| -> ");
  1101. lcd.print(citire_senzor_ceas(ora));
  1102. lcd.print(":");
  1103. lcd.print(citire_senzor_ceas(minut));
  1104. lcd.print(":");
  1105. lcd.print(citire_senzor_ceas(secunda));
  1106. delay(20);
  1107. if (digitalRead(PIN_BUTON_1) == LOW)
  1108. {
  1109. func_meniu_selectMenu();
  1110. //meniuCurent = meniu_selectMenu;
  1111.  
  1112. }
  1113.  
  1114. }
  1115.  
  1116. void func_meniu_selectMenu()
  1117. {
  1118.  
  1119. static int i = 0;
  1120. if (meniuCurent != meniu_selectMenu)
  1121. {
  1122. lcd.clear();
  1123. delay(500);
  1124. }
  1125.  
  1126. meniuCurent = meniu_selectMenu;
  1127. lcd.setCursor(0, 0);
  1128. lcd.print("MENIU");
  1129.  
  1130. lcd.setCursor(0, 3);
  1131. lcd.print("+ GO -");
  1132.  
  1133.  
  1134. lcd.setCursor(9, 0);
  1135. lcd.print("| | Init");
  1136. lcd.setCursor(9, 1);
  1137. lcd.print("| | Monitor");
  1138. lcd.setCursor(9, 2);
  1139. lcd.print("| | Senzor");
  1140. lcd.setCursor(9, 3);
  1141. lcd.print("| | Manual");
  1142. // lcd.setCursor(0, i - 1);
  1143. // lcd.print(" ");
  1144. lcd.setCursor(10, i);
  1145. lcd.write(5);
  1146.  
  1147. if (digitalRead(PIN_BUTON_1) == LOW)
  1148. {
  1149. delay(350); /*Debounce*/
  1150. if (i < 3)
  1151. {
  1152. i++;
  1153. lcd.clear();
  1154. }
  1155. else
  1156. {
  1157. i = 0;
  1158. lcd.clear();
  1159. }
  1160. }
  1161. if (digitalRead(PIN_BUTON_3) == LOW)
  1162. {
  1163. delay(350); /*Debounce*/
  1164. if (i > 0)
  1165. {
  1166. i--;
  1167. lcd.clear();
  1168. }
  1169. else
  1170. {
  1171. i = 3;
  1172. lcd.clear();
  1173. }
  1174. }
  1175.  
  1176.  
  1177. //daca s-a apasat butonul OK, se acceseaza meniul corespunztor
  1178.  
  1179. if (digitalRead(PIN_BUTON_2) == LOW)
  1180. {
  1181.  
  1182.  
  1183. switch(i)
  1184. {
  1185. case 0:
  1186. {
  1187. func_meniu_initializare();
  1188. break;
  1189. }
  1190.  
  1191. case 1:
  1192. {
  1193. func_meniu_monitorizare();
  1194. break;
  1195. }
  1196.  
  1197. case 2:
  1198. {
  1199.  
  1200. func_meniu_senzori();
  1201. break;
  1202. }
  1203.  
  1204. case 3:
  1205. {
  1206. func_meniu_manual();
  1207. break;
  1208. }
  1209. }
  1210. }
  1211. }
  1212.  
  1213. void func_meniu_manual()
  1214. {
  1215. static int i = 0;
  1216. if (meniuCurent != meniu_manual)
  1217. {
  1218. lcd.clear();
  1219. delay(500);
  1220. }
  1221. meniuCurent = meniu_manual;
  1222.  
  1223. lcd.setCursor(2, 0);
  1224. lcd.print("PRIZA 0 |");
  1225. if (prizaNr[0].pornita == 1)
  1226. {
  1227. lcd.print("ON|");
  1228. }
  1229. else
  1230. {
  1231. lcd.print("OFF|");
  1232. }
  1233.  
  1234.  
  1235.  
  1236. lcd.setCursor(2, 1);
  1237. lcd.print("PRIZA 1 |" );
  1238. if (prizaNr[1].pornita == 1)
  1239. {
  1240. lcd.print("ON|");
  1241. }
  1242. else
  1243. {
  1244. lcd.print("OFF|");
  1245. }
  1246.  
  1247. lcd.setCursor(2, 2);
  1248. lcd.print("PRIZA 2 |");
  1249. if (prizaNr[2].pornita == 1)
  1250. {
  1251. lcd.print("ON|");
  1252. }
  1253. else
  1254. {
  1255. lcd.print("OFF|");
  1256. }
  1257.  
  1258. lcd.setCursor(2, 3);
  1259. if (i < 3)
  1260. {
  1261. lcd.print("[+] [SET] [-]");
  1262. }
  1263. else
  1264. {
  1265. lcd.print("[+] [MENU] [-]");
  1266. }
  1267.  
  1268. if (digitalRead(PIN_BUTON_1) == LOW)
  1269. {
  1270. delay(350); /*Debounce*/
  1271. if (i < 3)
  1272. {
  1273. i++;
  1274. lcd.clear();
  1275. }
  1276. else
  1277. {
  1278. i = 0;
  1279. lcd.clear();
  1280. }
  1281. }
  1282. if (digitalRead(PIN_BUTON_3) == LOW)
  1283. {
  1284. delay(350); /*Debounce*/
  1285. if (i > 0)
  1286. {
  1287. i--;
  1288. lcd.clear();
  1289. }
  1290. else
  1291. {
  1292. i = 3;
  1293. lcd.clear();
  1294. }
  1295. }
  1296. lcd.setCursor(0, i);
  1297. lcd.write(5);
  1298.  
  1299. if (digitalRead(PIN_BUTON_2) == LOW)
  1300. {
  1301. delay(100);
  1302. //Daca sunt cu selectia pe prize
  1303. if (i < 3)
  1304. {
  1305. if (prizaNr[i].pornita == 0)
  1306. {
  1307. prizaNr[i].pornita = 1;
  1308. }
  1309. else
  1310. {
  1311. prizaNr[i].pornita = 0;
  1312. }
  1313. }//Altfel merg la meniu
  1314. else
  1315. {
  1316. func_meniu_selectMenu();
  1317. }
  1318.  
  1319.  
  1320. }
  1321. }
  1322.  
  1323. void actualizare_stare_prize()
  1324. {
  1325. for (int i = 0; i <= NR_PRIZE; i++) //parcurg fiecare priza
  1326. {
  1327. if (prizaNr[i].stare == true);
  1328. {
  1329. switch (prizaNr[i].tip_comanda)
  1330. { /*1 - Temperatura, 2 - Umiditate, 3 - Lumina, 4 - Telecomanda, 5 - Ceas */
  1331. case 0: /* Depinde de temperatura */
  1332. {
  1333. prizaNr[i].pornita = false;
  1334. actualizare_releu();
  1335. break;
  1336. }
  1337.  
  1338. case 1: /* Depinde de temperatura */
  1339. {
  1340. if ( citire_senzor_temperatura() >= prizaNr[i].prag_temperatura )
  1341. {
  1342. prizaNr[i].pornita = true;
  1343. }
  1344. else
  1345. {
  1346. prizaNr[i].pornita = false;
  1347. }
  1348.  
  1349. actualizare_releu();
  1350. break;
  1351. }
  1352.  
  1353.  
  1354. case 2: /* Depinde de temperatura */
  1355. {
  1356. if ( citire_senzor_umiditate() >= prizaNr[i].prag_umiditate )
  1357. {
  1358. prizaNr[i].pornita = true;
  1359. }
  1360. else
  1361. {
  1362. prizaNr[i].pornita = false;
  1363. }
  1364.  
  1365. actualizare_releu();
  1366. break;
  1367. }
  1368.  
  1369. case 3: /* Depinde de temperatura */
  1370. {
  1371. if ( citire_senzor_lumina() >= prizaNr[i].prag_lumina )
  1372. {
  1373. prizaNr[i].pornita = true;
  1374. }
  1375. else
  1376. {
  1377. prizaNr[i].pornita = false;
  1378. }
  1379.  
  1380. actualizare_releu();
  1381. break;
  1382. }
  1383.  
  1384. case 4: /* Depinde de telecomanda */
  1385. {
  1386. results.value = 0;
  1387. if (citire_senzor_IR() == prizaNr[i].cod_telecomanda)
  1388. {
  1389. if (prizaNr[i].pornita == false)
  1390. {
  1391. prizaNr[i].pornita = true;
  1392. }
  1393. else
  1394. {
  1395. prizaNr[i].pornita = false;
  1396. }
  1397. }
  1398.  
  1399. actualizare_releu();
  1400. break;
  1401. }
  1402.  
  1403. case 5: /* Depinde de ceas */
  1404. {
  1405. if ((citire_senzor_ceas(ora) == prizaNr[i].ceasON_ora) &&
  1406. (citire_senzor_ceas(minut) == prizaNr[i].ceasON_minut))
  1407. {
  1408. Serial.print("Ora citita e: ");
  1409. Serial.println(citire_senzor_ceas(ora));
  1410.  
  1411. Serial.print("Ora setata e: ");
  1412. Serial.println(prizaNr[i].ceasON_ora);
  1413.  
  1414. Serial.println("############");
  1415. Serial.print("min citit e: ");
  1416. Serial.println(citire_senzor_ceas(minut));
  1417.  
  1418. Serial.print("min setat e: ");
  1419. Serial.println(prizaNr[i].ceasON_minut);
  1420. prizaNr[i].pornita = true;
  1421. }
  1422.  
  1423.  
  1424. if ((citire_senzor_ceas(ora) == prizaNr[i].ceasOFF_ora) &&
  1425. (citire_senzor_ceas(minut) == prizaNr[i].ceasOFF_minut))
  1426. {
  1427. prizaNr[i].pornita = false;
  1428. }
  1429.  
  1430. actualizare_releu();
  1431. break;
  1432. }
  1433.  
  1434. default : /* Caz implicit */
  1435. {
  1436. prizaNr[i].pornita = false;
  1437. actualizare_releu();
  1438. break;
  1439. }
  1440. }
  1441. }
  1442. }
  1443. }
  1444.  
  1445.  
  1446. void actualizare_releu()
  1447. {
  1448. /* Parcurg fiecare priza in parte */
  1449. for (int i = 0; i <= NR_PRIZE; i++)
  1450. {
  1451. if (prizaNr[i].pornita == true) /* Daca statusul prizei a fost setat pe 'pornit' */
  1452. {
  1453. digitalWrite(prizaNr[i].pin_releu, LOW); /* Aprind priza respectiva */
  1454. }
  1455. else if (prizaNr[i].pornita == false) /* Daca statusul prizei a fost setat pe 'oprit' */
  1456. {
  1457. digitalWrite(prizaNr[i].pin_releu, HIGH); /* Sting priza respectiva */
  1458. }
  1459. }
  1460. }
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!