API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Jul 2nd, 2016
109
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 22.89 KB | None | 0 0
raw download clone embed print report
  1. #include <LiquidCrystal_I2C.h> // Biblioteca LCD I2C
  2. #include <TimerOne.h> // Biblioteca do timer1
  3. #include <Limits.h>
  4.  
  5. const int temperatura = 0;
  6. const int buzzer = A2;
  7. int pinoativaluz = A1; //Pino ligado ao acionamento da lampada
  8. int pinopir = 9; //Pino ligado ao sensor
  9. int acionamento; //Variavel para guardar valor do sensor
  10. int ConRegre = 240; //variavel com o valor definido de 30 segundos
  11. int ConRegreReg = ConRegre; //receble valor de referencia
  12. int MenuCarga = 1;
  13. int percentc1 = 100; // valor máximo que pode atingir
  14. int percentc2 = 100;
  15. int percentc3 = 100;
  16. int percentc4 = 100;
  17. int val1 = 0;// variavel que recebe valores entre 0 e 100
  18. int val2 = 0;
  19. int val3 = 0;
  20. int val4 = 0;
  21. int LAMP = A3; // Pino de disparo do Triac
  22. int ConfigTemp = 29;
  23.  
  24. ///////
  25.  
  26. unsigned int dimming1 = 115; // Variavel para tempo de retardo. Valor Inicial Minimo
  27. unsigned int dimming2 = 115; // Variavel para tempo de retardo. Valor Inicial Minimo
  28. unsigned int dimming3 = 115; // Variavel para tempo de retardo. Valor Inicial Minimo
  29. unsigned int dimming4 = 115; // Variavel para tempo de retardo. Valor Inicial Minimo
  30.  
  31. ///////
  32.  
  33. int str1 = 0; // Variavel string para receber dados da Serial
  34. int str2 = 0; // Variavel string para receber dados da Serial
  35. int str3 = 0; // Variavel string para receber dados da Serial
  36. int str4 = 0; // Variavel string para receber dados da Serial
  37.  
  38. ////////
  39.  
  40. #define bMenu 10 // Os pinos analógicos podem ser
  41. #define bChange 11 // usados como digitais, bastando
  42. #define bUp 13 //
  43. #define bDown 12
  44.  
  45. ////////
  46.  
  47. #define bMenu0 90 // Valor de referência que a
  48. #define bChange0 91 // função CheckButton() passa
  49. #define bUp0 92 // indicando que um botão foi
  50. #define bDown0 93 // solto
  51.  
  52. ////////
  53.  
  54. boolean aMenu, aChange, aUp, aDown; // Grava o ultimo valor lidos nos botões.
  55.  
  56. ////////
  57.  
  58. const int sensorTemp = 0;
  59. int valorSensorTemp = 0;
  60. int menorValorTemp = INT_MAX;
  61.  
  62. // Utilizado pela função Checkbutton p/ identificar quando há uma alteração no estado do pino dos botões
  63.  
  64. char state = 1; // variável que guarda posição atual do menu
  65.  
  66. //LiquidCrystal lcd(7, 8, 9, 10, 11, 12); // Declaração do objeto tipo lcd
  67. LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE); // Set the LCD I2C address
  68.  
  69.  
  70. byte seta_direita[8] = { //cria seta direita
  71. B00000,
  72. B00100,
  73. B00010,
  74. B11111,
  75. B00010,
  76. B00100,
  77. B00000,
  78. B00000
  79. };
  80.  
  81. byte seta_esquerda[8] = { //cria seta esquerda
  82. B00000,
  83. B00100,
  84. B01000,
  85. B11111,
  86. B01000,
  87. B00100,
  88. B00000,
  89. B00000
  90. };
  91. byte seta_abaixo[8] = { // cria seta abaixo
  92. B00000,
  93. B00100,
  94. B00100,
  95. B10101,
  96. B01110,
  97. B00100,
  98. B00000,
  99. B00000
  100. };
  101. byte seta_acima[8] = { // cria seta acima
  102. B00000,
  103. B00100,
  104. B01110,
  105. B10101,
  106. B00100,
  107. B00100,
  108. B00000,
  109. B00000
  110. };
  111.  
  112. //----------------------------------
  113. void callback() // Cada vez que "estoura" o timer 1 chama esta rotina
  114. {
  115. ConRegre--;
  116. if (ConRegre <= 0) ConRegre = 0; // Se chegar em zero, fica em zero
  117. }
  118. //----------------------------------
  119. void setup()
  120. {
  121. pinMode(buzzer, OUTPUT);
  122. Timer1.initialize(1000000); // initialize timer1, and set a 1 second period
  123. Timer1.attachInterrupt(callback); // attaches callback() as a timer overflow interrupt
  124. attachInterrupt(0, zero_cross, RISING); // Enable interrupt no pino D2
  125. lcd.createChar(1, seta_direita); // vai criar novos caracteres
  126. lcd.createChar(2, seta_esquerda);
  127. lcd.createChar(3, seta_abaixo);
  128. lcd.createChar(4, seta_acima);
  129. lcd.begin(16, 2); // Iniciando a biblioteca do LCD
  130. lcd.print("INICIANDO... ");
  131. delay(5000);
  132. pinMode(bMenu, INPUT); // Botões
  133. pinMode(bChange, INPUT);
  134. pinMode(bUp, INPUT);
  135. pinMode(bDown, INPUT);
  136. pinMode(A3, OUTPUT);
  137. pinMode(LAMP, OUTPUT); // Define o pino(A3) LAMP como saída
  138. digitalWrite(bMenu, HIGH); // Aciona o pull-up interno
  139. digitalWrite(bChange, HIGH); // dos botões
  140. digitalWrite(bUp, HIGH);
  141. digitalWrite(bDown, HIGH);
  142. pinMode(pinoativaluz, OUTPUT); //Define pino como saida
  143. pinMode(pinopir, INPUT); //Define pino sensor como entrada
  144. // digitalWrite(A5, HIGH); //Comuta para o controle digital digital
  145. digitalWrite(pinoativaluz, HIGH);
  146. }
  147. //----------------------------------
  148. void loop()
  149. {
  150. if (MenuCarga == 1)
  151. {
  152. Controla_Vent_Temp();
  153. }
  154. acionamento = digitalRead(pinopir); //Le o valor do sensor
  155. if (acionamento != 0)
  156. {
  157. digitalWrite(pinoativaluz, HIGH); //aciona a luz se estiver desligada
  158. ConRegre = ConRegreReg; // reseta o contador para o valor definido pela variável ConRegreReg
  159. }
  160. if (ConRegre <= 0)
  161. {
  162. digitalWrite(pinoativaluz, LOW); // desliga a luz ao final da contagem
  163. }
  164.  
  165. dimmer01();
  166. ////////////////////////////////////////////////////cod. sensor
  167. switch (state) {
  168. case 1: //MENU 1 - CONTROLE (LIGADO/DESLIGADO)
  169. switch (CheckButton()) {
  170. case bMenu:
  171. // lcd.clear();
  172. digitalWrite(A3, LOW);
  173. lcd.setCursor(0, 1);
  174. lcd.print("DESLIGADO ");
  175. tone(buzzer, 1500);
  176. delay(50);
  177. noTone(buzzer);
  178. break;
  179. case bDown:
  180. lcd.clear();
  181. tone(buzzer, 1500);
  182. delay(50);
  183. noTone(buzzer);
  184. Set_state(2);
  185. break;
  186. case bChange:
  187. // lcd.clear();
  188. digitalWrite(A3, HIGH);
  189. lcd.setCursor(0, 1);
  190. lcd.print("LIGADO ");
  191. tone(buzzer, 1500);
  192. delay(50);
  193. noTone(buzzer);
  194. break;
  195. default:
  196. Set_state(1);
  197. if (digitalRead(A3) == 1)
  198. {
  199. lcd.setCursor(0, 1);
  200. lcd.print("LIGADO ");
  201. }
  202. }
  203. break;
  204. case 2: //ILUMINACAO
  205. switch (CheckButton()) {
  206. case bMenu:
  207. lcd.clear();
  208. tone(buzzer, 1500);
  209. delay(50);
  210. noTone(buzzer);
  211. Set_state(3);
  212. break;
  213. case bDown:
  214. lcd.clear();
  215. tone(buzzer, 1500);
  216. delay(50);
  217. noTone(buzzer);
  218. Set_state(5);
  219. break;
  220. case bUp:
  221. lcd.clear();
  222. tone(buzzer, 1500);
  223. delay(50);
  224. noTone(buzzer);
  225. Set_state(1);
  226. break;
  227. default:
  228. Set_state(2);
  229. }
  230. break;
  231. case 3: //ILUMINACAO - CONFIGURA TEMPO
  232. switch (CheckButton())
  233. {
  234. case bMenu:
  235. lcd.clear();
  236. tone(buzzer, 1500);
  237. delay(50);
  238. noTone(buzzer);
  239. Set_state(4);
  240. break;
  241. case bChange:
  242. lcd.clear();
  243. tone(buzzer, 1500);
  244. delay(50);
  245. noTone(buzzer);
  246. Set_state(2);
  247. break;
  248. case bDown:
  249. if (ConRegreReg >= 0) {
  250. ConRegreReg = ConRegreReg - 30;
  251. ConRegre = ConRegreReg;
  252. tone(buzzer, 1500);
  253. delay(50);
  254. noTone(buzzer);
  255. break;
  256. case bUp:
  257. ConRegreReg = ConRegreReg + 30;
  258. ConRegre = ConRegreReg;
  259. tone(buzzer, 1500);
  260. delay(50);
  261. noTone(buzzer);
  262. break;
  263. default:
  264. Set_state(3);
  265. }
  266. }
  267. break;
  268. case 4: //ILUMINACAO - MONITORACAO
  269. switch (CheckButton())
  270. {
  271. case bMenu:
  272. lcd.clear();
  273. tone(buzzer, 1500);
  274. delay(50);
  275. noTone(buzzer);
  276. Set_state(2);
  277. break;
  278. case bChange:
  279. lcd.clear();
  280. tone(buzzer, 1500);
  281. delay(50);
  282. noTone(buzzer);
  283. Set_state(3);
  284. break;
  285. default:
  286. Set_state(4);
  287. }
  288. break;
  289. case 5: //CARGA
  290. switch (CheckButton()) {
  291. case bMenu:
  292. lcd.clear();
  293. tone(buzzer, 1500);
  294. delay(50);
  295. noTone(buzzer);
  296. Set_state(11);
  297. break;
  298. case bDown:
  299. lcd.clear();
  300. tone(buzzer, 1500);
  301. delay(50);
  302. noTone(buzzer);
  303. Set_state(1);
  304. break;
  305. case bUp:
  306. lcd.clear();
  307. tone(buzzer, 1500);
  308. delay(50);
  309. noTone(buzzer);
  310. Set_state(2);
  311. break;
  312. default:
  313. Set_state(5);
  314. }
  315. break;
  316. case 6: //CARGA - 1
  317. switch (CheckButton()) {
  318. case bMenu:
  319. lcd.clear();
  320. tone(buzzer, 1500);
  321. delay(50);
  322. noTone(buzzer);
  323. Set_state(7);
  324. break;
  325. case bChange:
  326. lcd.clear();
  327. tone(buzzer, 1500);
  328. delay(50);
  329. noTone(buzzer);
  330. Set_state(11);
  331. break;
  332. case bUp:
  333. if (val1 >= 0 )
  334. {
  335. lcd.clear();
  336. val1 = val1 + 10;
  337. str1 = val1;
  338. tone(buzzer, 1500);
  339. delay(50);
  340. noTone(buzzer);
  341.  
  342. }
  343. break;
  344. case bDown:
  345. if (val1 >= 0) {
  346. lcd.clear();
  347. val1 = val1 - 10;
  348. str1 = val1;
  349. tone(buzzer, 1500);
  350. delay(50);
  351. noTone(buzzer);
  352. }
  353. break;
  354. default:
  355. Set_state(6);
  356. }
  357. break;
  358. case 7: //CARGA - 2
  359. switch (CheckButton()) {
  360. case bMenu:
  361. lcd.clear();
  362. tone(buzzer, 1500);
  363. delay(50);
  364. noTone(buzzer);
  365. Set_state(8);
  366. break;
  367. case bChange:
  368. lcd.clear();
  369. tone(buzzer, 1500);
  370. delay(50);
  371. noTone(buzzer);
  372. Set_state(6);
  373. break;
  374. case bDown:
  375. if (val2 <= 100) {
  376. lcd.clear(); val2++;
  377. tone(buzzer, 1500);
  378. delay(50);
  379. noTone(buzzer);
  380. }
  381. break;
  382. case bUp:
  383. if (val2 <= 100) {
  384. lcd.clear(); val2++;
  385. tone(buzzer, 1500);
  386. delay(50);
  387. noTone(buzzer);
  388. }
  389. break;
  390. default:
  391. Set_state(7);
  392. }
  393. break;
  394. case 8: //CARGA - 3
  395. switch (CheckButton()) {
  396. case bMenu:
  397. lcd.clear();
  398. tone(buzzer, 1500);
  399. delay(50);
  400. noTone(buzzer);
  401. Set_state(9);
  402. break;
  403. case bChange:
  404. lcd.clear();
  405. tone(buzzer, 1500);
  406. delay(50);
  407. noTone(buzzer);
  408. Set_state(7);
  409. break;
  410. case bDown:
  411. if (val3 <= 24) {
  412. lcd.clear(); val3++;
  413. tone(buzzer, 1500);
  414. delay(50);
  415. noTone(buzzer);
  416. }
  417. break;
  418. case bUp:
  419. if (val3 <= 24) {
  420. lcd.clear(); val3++;
  421. tone(buzzer, 1500);
  422. delay(50);
  423. noTone(buzzer);
  424. }
  425. break;
  426. default:
  427. Set_state(8);
  428. }
  429. break;
  430. case 9: //CARGA - 4
  431. switch (CheckButton()) {
  432. case bMenu:
  433. lcd.clear();
  434. tone(buzzer, 1500);
  435. delay(50);
  436. noTone(buzzer);
  437. Set_state(10);
  438. break;
  439. case bChange:
  440. lcd.clear();
  441. tone(buzzer, 1500);
  442. delay(50);
  443. noTone(buzzer);
  444. Set_state(8);
  445. break;
  446. case bDown:
  447. if (val4 <= 24) {
  448. lcd.clear(); val4++;
  449. tone(buzzer, 1500);
  450. delay(50);
  451. noTone(buzzer);
  452. }
  453. break;
  454. case bUp:
  455. if (val4 <= 24) {
  456. lcd.clear(); val4++;
  457. tone(buzzer, 1500);
  458. delay(50);
  459. noTone(buzzer);
  460. }
  461. break;
  462. default:
  463. Set_state(9);
  464. }
  465. break;
  466. case 10: //CARGA - MONITOR TEMPERATURA
  467. switch (CheckButton()) {
  468. case bMenu:
  469. lcd.clear();
  470. tone(buzzer, 1500);
  471. delay(50);
  472. noTone(buzzer);
  473. Set_state(5);
  474. break;
  475. case bChange:
  476. if (MenuCarga == 1) {
  477. lcd.clear();
  478. tone(buzzer, 1500);
  479. delay(50);
  480. noTone(buzzer);
  481. Set_state(12);
  482. }
  483. else if (MenuCarga == 0) {
  484. lcd.clear();
  485. tone(buzzer, 1500);
  486. delay(50);
  487. noTone(buzzer);
  488. Set_state(9);
  489. }
  490. break;
  491. default:
  492. Set_state(10);
  493. }
  494. case 11: //MENU CARGA - ATIVA AUTOMACAO DE ATIVACAO DO DIMMER AUTOMATICAMENTE
  495. switch (CheckButton()) {
  496. case bMenu:
  497. if (MenuCarga == 1) {
  498. lcd.clear();
  499. tone(buzzer, 1500);
  500. delay(50);
  501. noTone(buzzer);
  502. Set_state(12);
  503. }
  504. else if (MenuCarga == 0) {
  505. lcd.clear();
  506. tone(buzzer, 1500);
  507. delay(50);
  508. noTone(buzzer);
  509. Set_state(6);
  510. }
  511. break;
  512. case bChange:
  513. lcd.clear();
  514. tone(buzzer, 1500);
  515. delay(50);
  516. noTone(buzzer);
  517. Set_state(5);
  518. break;
  519. case bUp:
  520. MenuCarga = 1;
  521. lcd.setCursor(0, 1);
  522. lcd.print("LIGADO ");
  523. tone(buzzer, 1500);
  524. delay(50);
  525. noTone(buzzer);
  526. break;
  527. case bDown:
  528. MenuCarga = 0;
  529. lcd.setCursor(0, 1);
  530. lcd.print("DESLIGADO ");
  531. tone(buzzer, 1500);
  532. delay(50);
  533. noTone(buzzer);
  534. break;
  535. default:
  536. Set_state(11);
  537. if (MenuCarga == 1)
  538. {
  539. lcd.setCursor(0, 1);
  540. lcd.print("LIGADO ");
  541. }
  542. }
  543. break;
  544. case 12: //MENU CARGA - CONFIGURA TEMPO
  545. switch (CheckButton()) {
  546. case bMenu:
  547. lcd.clear();
  548. tone(buzzer, 1500);
  549. delay(50);
  550. noTone(buzzer);
  551. Set_state(10);
  552. break;
  553. case bChange:
  554. Set_state(11);
  555. break;
  556. case bUp:
  557. ConfigTemp++;
  558. lcd.setCursor(0, 1);
  559. lcd.print(ConfigTemp);
  560. tone(buzzer, 1500);
  561. delay(50);
  562. noTone(buzzer);
  563. break;
  564. case bDown:
  565. ConfigTemp--;
  566. lcd.setCursor(0, 1);
  567. lcd.print(ConfigTemp);
  568. tone(buzzer, 1500);
  569. delay(50);
  570. noTone(buzzer);
  571. break;
  572. default:
  573. Set_state(12);
  574. lcd.setCursor(0, 1);
  575. lcd.print(ConfigTemp);
  576. lcd.write(B11011111); //Simbolo de graus celsius
  577. lcd.print("C");
  578. }
  579. default: ;
  580. }
  581. }
  582. //----------------------------------
  583. char CheckButton()
  584. {
  585. if (aMenu != digitalRead(bMenu))
  586. {
  587. aMenu = !aMenu;
  588. if (aMenu) return bMenu0;
  589. else return bMenu;
  590. }
  591. else if (aChange != digitalRead(bChange))
  592. {
  593. aChange = !aChange;
  594. if (aChange) return bChange0;
  595. else return bChange;
  596. }
  597. else if (aUp != digitalRead(bUp))
  598. {
  599. aUp = !aUp;
  600. if (aUp) return bUp0;
  601. else return bUp;
  602. }
  603. else if (aDown != digitalRead(bDown))
  604. {
  605. aDown = !aDown;
  606. if (aDown) return bDown0;
  607. else return bDown;
  608. }
  609. else
  610. return 0;
  611. }
  612. //---------------------------------
  613. void Set_state(char index)
  614. {
  615. state = index; // Atualiza a variável state para a nova tela
  616. switch (state) // verifica qual a tela atual e exibe o conteúdo correspondente
  617. {
  618. case 1: //==================== state 1
  619. lcd.setCursor(0, 0);
  620. lcd.print("CONTROLE ");
  621. lcd.write(3);
  622. lcd.write(2);
  623. lcd.write(1);
  624. break;
  625. case 2: //==================== state 2
  626. lcd.setCursor(0, 0);
  627. lcd.print("ILUMINACAO ");
  628. lcd.setCursor(13, 0);
  629. lcd.write(4);
  630. lcd.write(3);
  631. lcd.write(1);
  632. lcd.setCursor(0, 1);
  633. lcd.print("T. CONF:");
  634. lcd.print(ConRegreReg);
  635. lcd.print("s");
  636. break;
  637. case 3: //==================== state 3
  638. lcd.setCursor(0, 0);
  639. lcd.print("CONF. TEMPO ");
  640. lcd.setCursor(12, 0);
  641. lcd.write(4);
  642. lcd.write(3);
  643. lcd.write(2);
  644. lcd.write(1);
  645. lcd.setCursor(0, 1);
  646. lcd.print("TEMPO: ");
  647. lcd.print(ConRegreReg);
  648. lcd.print("s ");
  649. break;
  650. case 4: //==================== state 4
  651. lcd.setCursor(0, 0);
  652. lcd.print("MONIT. TEMPO ");
  653. lcd.setCursor(14, 0);
  654. lcd.write(2);
  655. lcd.write(1);
  656. lcd.setCursor(0, 1);
  657. lcd.print("TEMPO: ");
  658. lcd.print(ConRegre);
  659. lcd.print("s");
  660. break;
  661. case 5: //==================== state 5
  662. lcd.setCursor(0, 0);
  663. lcd.print("CARGAS");
  664. lcd.setCursor(13, 0);
  665. lcd.write(4);
  666. lcd.write(3);
  667. // lcd.write(2);
  668. lcd.write(1);
  669. lcd.setCursor(0, 1);
  670. lcd.print("CONFIGURACAO");
  671. break;
  672. case 6: //==================== state 6
  673. percentc1 = val1 * 100 / 100;
  674. lcd.setCursor(0, 0);
  675. lcd.print("CARGA 1");
  676. lcd.setCursor(12, 0);
  677. lcd.write(4);
  678. lcd.write(3);
  679. lcd.write(2);
  680. lcd.write(1);
  681. lcd.setCursor(0, 1);
  682. lcd.print(percentc1, DEC); // mostra o valor de "variavel"
  683. lcd.print(" % ");
  684.  
  685. break;
  686. case 7: //==================== state 7
  687. percentc2 = val2 * 100 / 100;
  688. lcd.setCursor(0, 0);
  689. lcd.print("CARGA 2");
  690. lcd.setCursor(12, 0);
  691. lcd.write(4);
  692. lcd.write(3);
  693. lcd.write(2);
  694. lcd.write(1);
  695. lcd.setCursor(0, 1);
  696. lcd.print(percentc2, DEC); // mostra o valor de "variavel"
  697. lcd.print(" % ");
  698. break;
  699. case 8: //==================== state 8
  700. percentc3 = val3 * 100 / 100;
  701. lcd.setCursor(0, 0);
  702. lcd.print("CARGA 3");
  703. lcd.setCursor(12, 0);
  704. lcd.write(4);
  705. lcd.write(3);
  706. lcd.write(2);
  707. lcd.write(1);
  708. lcd.setCursor(0, 1);
  709. lcd.print(percentc3, DEC); // mostra o valor de "variavel"
  710. lcd.print(" % ");
  711. break;
  712. case 9: //==================== state 9
  713. percentc4 = val4 * 100 / 100;
  714. lcd.setCursor(0, 0);
  715. lcd.print("CARGA 4");
  716. lcd.setCursor(12, 0);
  717. lcd.write(4);
  718. lcd.write(3);
  719. lcd.write(2);
  720. lcd.write(1);
  721. lcd.setCursor(0, 1);
  722. lcd.print(percentc4, DEC); // mostra o valor de "variavel"
  723. lcd.print(" % ");
  724. break;
  725. case 10: //==================== state 10
  726. lcd.clear(); //limpa o display do LCD.
  727. lcd.setCursor(0, 0);
  728. lcd.print("TEMPERATURA ");
  729. lcd.setCursor(14, 0);
  730. lcd.write(2);
  731. lcd.write(1);
  732. lcd.setCursor(0, 1);
  733. atualizaTemperatura(); //-------------------- Chama rotina de temperatura
  734. lcd.print(menorValorTemp); // Imprime menor valor
  735. lcd.write(B11011111); //Simbolo de graus celsius
  736. lcd.print("C");
  737. delay(250);
  738. break;
  739. case 11: //==================== state 11
  740. lcd.setCursor(0, 0);
  741. lcd.print("AUTOMACAO ");
  742. lcd.setCursor(12, 0);
  743. lcd.write(4);
  744. lcd.write(3);
  745. lcd.write(2);
  746. lcd.write(1);
  747. break;
  748. case 12: //==================== state 12
  749. lcd.setCursor(0, 0);
  750. lcd.print("AJUSTE TEMP ");
  751. lcd.setCursor(12, 0);
  752. lcd.write(4);
  753. lcd.write(3);
  754. lcd.write(2);
  755. lcd.write(1);
  756. break;
  757. default:;
  758. }
  759. }
  760. void atualizaTemperatura() {
  761. menorValorTemp = INT_MAX; //Inicializando com o maior valor int possível
  762. for (int i = 1; i <= 8; i++) {
  763. valorSensorTemp = analogRead(sensorTemp); //Lendo o valor do sensor de temperatura.
  764. valorSensorTemp *= 0.54 ; //Transformando valor lido no sensor de temperatura em graus celsius aproximados.
  765. if (valorSensorTemp < menorValorTemp) { //Mantendo sempre a menor temperatura lida
  766. menorValorTemp = valorSensorTemp;
  767. }
  768. }
  769. }
  770. void zero_cross() // Rotina chamada à cada interrupt causada pelo zero cross do AC
  771. {
  772. delayMicroseconds(dimming1); // Restardo calculado
  773. digitalWrite(LAMP, HIGH); // Dispara o Triac
  774. delayMicroseconds(8.33); // Duração do pulso de disparo
  775. digitalWrite(LAMP, LOW); // Desliga pulso de disparo
  776. }
  777.  
  778. void Controla_Vent_Temp() { // define qual valor a variavel str1 vai receber de acordo com a temperatura
  779.  
  780. int verificasistema = digitalRead(A5); // le o valor na saida se está ou não ativado
  781. int verificaLuz = digitalRead(A1); // le o valor na saida do luzes
  782.  
  783. if (verificasistema == HIGH) // verifica se o sistema está ou não operante
  784. {
  785. if (verificaLuz == HIGH) { // verifica se a luz esta ou não ligado
  786.  
  787. atualizaTemperatura(); // chama a rotina de temperatura
  788. }
  789. if (menorValorTemp <= ConfigTemp) { // compara a temperatura (LM35) menorValorTemp função do sensor e ConfigTemp variável definida pelo usuario
  790. str1 = 0;
  791. }
  792. if (menorValorTemp >= 35) {
  793. str1 = 90;
  794. }
  795. else if (menorValorTemp < 34 && menorValorTemp > 32 ) {
  796. str1 = 60;
  797. }
  798. else if (menorValorTemp < 31 && menorValorTemp > 30 ) {
  799. str1 = 40;
  800. }
  801. }
  802. if (verificasistema == LOW) {
  803. str1 = 0;
  804. }
  805. }
  806. void dimmer01() {
  807. dimming1 = str1; // a variável dimming recebe valores de STR1
  808. dimming1 = (118 - dimming1) * 68; // Calcula o retardo para o disparo do triac
  809. if (dimming1 < 1224) dimming1 = 1224; // Valor para o brilho máximo 1224
  810. if (dimming1 > 7820) dimming1 = 7820; // Valor para o brilho minimo 7820
  811. }
  812. void dimmer02() {
  813. dimming2 = str2; // a variável dimming recebe valores de STR1
  814. dimming2 = (118 - dimming2) * 68; // Calcula o retardo para o disparo do triac
  815. if (dimming2 < 1224) dimming2 = 1224; // Valor para o brilho máximo 1224
  816. if (dimming2 > 7820) dimming2 = 7820; // Valor para o brilho minimo 7820
  817. }
  818. void dimmer03() {
  819. dimming3 = str3; // a variável dimming recebe valores de STR1
  820. dimming3 = (118 - dimming3) * 68; // Calcula o retardo para o disparo do triac
  821. if (dimming3 < 1224) dimming3 = 1224; // Valor para o brilho máximo 1224
  822. if (dimming3 > 7820) dimming3 = 7820; // Valor para o brilho minimo 7820
  823. }
  824. void dimmer04() {
  825. dimming4 = str4; // a variável dimming recebe valores de STR1
  826. dimming4 = (118 - dimming4) * 68; // Calcula o retardo para o disparo do triac
  827. if (dimming4 < 1224) dimming4 = 1224; // Valor para o brilho máximo 1224
  828. if (dimming4 > 7820) dimming4 = 7820; // Valor para o brilho minimo 7820
  829. }
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!