API tools faq
paste
RuiViana

Menu_LCD.ino

RuiViana
Dec 10th, 2018
264
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 23.38 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 SistemaOnOff = 8;
  8. int pinoativaluz = A1;                                  // Pino ligado ao acionamento da lampada
  9. int pinopir = 9;                                        // Pino ligado ao sensor
  10. int acionamento;                                        // Variavel para guardar valor do sensor
  11. int ConRegre = 240;                                     // Variavel com o valor definido de 30 segundos
  12. int ConRegreReg = ConRegre;                             // Recebe valor de referencia
  13. int MenuCarga = 1;
  14.  
  15. int ConfigTemp = 29;
  16.  
  17. int val1 = 1;                                           // variavel que recebe valores entre 0 e 100
  18. int val2 = 1;
  19. int val3 = 1;
  20. int val4 = 1;
  21.  
  22. int str5 = 0;
  23.  
  24. #define bLeft 10                                        // Os pinos analogicos podem ser
  25. #define bRight 11                                       // Usados como digitais, bastando
  26. //#define bUp 13
  27. #define bUp 3                                           //       <-----------  mudei era 13
  28. #define bDown 12
  29.  
  30. #define bLeft0 90                                       // Valor de referencia que a
  31. #define bRight0 91                                      // funcaoo CheckButton() passa
  32. #define bUp0 92                                         // indicando que um botao foi
  33. #define bDown0 93                                       // solto
  34.  
  35. boolean aLeft, aRight, aUp, aDown;                      // Grava o ultimo valor lidos nos botoes.
  36.  
  37. const int sensorTemp = 0;
  38. int valorSensorTemp = 0;
  39. int menorValorTemp  = INT_MAX;
  40.  
  41. int state = 1;                                          // variavel que guarda posicao atual do menu
  42.  
  43. //LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);            // Set the LCD I2C address
  44. LiquidCrystal_I2C lcd(0x39,  2, 1, 0, 7, 6, 5, 4, 3, POSITIVE);             //   <--------- Meu LCD
  45.  
  46. byte seta_direita[8]  = {0x00, 0x04, 0x02, 0x1F, 0x02, 0x04, 0x00, 0x00};   //cria seta direita
  47. byte seta_esquerda[8] = {0x00, 0x04, 0x08, 0x1F, 0x08, 0x04, 0x00, 0x00};   //cria seta esquerda
  48. byte seta_abaixo[8]   = {0x00, 0x04, 0x04, 0x15, 0x0E, 0x04, 0x00, 0x00};   // cria seta abaixo
  49. byte seta_acima[8]    = {0x00, 0x04, 0x0E, 0x15, 0x04, 0x04, 0x00, 0x00};   // cria seta acima
  50.  
  51. byte Dir   = 1;
  52. byte Esq   = 2;
  53. byte Desce = 3;
  54. byte Sobe  = 4;
  55.  
  56. unsigned char Canal1 = 4;                               // Port para Triac 1
  57. unsigned char Canal2 = 5;                               // Port para Triac 2
  58. unsigned char Canal3 = 6;                               // Port para Triac 3
  59. unsigned char Canal4 = 7;                               // Port para Triac 4
  60. unsigned char Pulso_Timer1;                             // Pulsos gerados pelo Timer1
  61. unsigned char Disparo[4] = {100, 100, 100, 100};        // Valor inicias para cargas   (Apagadas)
  62. int Contador = 0;
  63. //--------------------------------
  64. void setup()
  65. {
  66.   Serial.begin(9600);
  67.  
  68.   attachInterrupt(0, zero_cross, FALLING);              // Define rotina chamada pela passagem do zero de uma senoide
  69.   Timer1.initialize(75);                                // Define interrupt de Timer1 a cada 75 us
  70.   Timer1.attachInterrupt(Timer1Zr);                  // OverFlow de Timer1
  71.  
  72.   pinMode(bLeft, INPUT_PULLUP);                         // Botoes
  73.   pinMode(bRight, INPUT_PULLUP);
  74.   pinMode(bUp, INPUT_PULLUP);
  75.   pinMode(bDown, INPUT_PULLUP);
  76.   pinMode(A3, OUTPUT);
  77.   pinMode(buzzer, OUTPUT);
  78.   pinMode(pinoativaluz, OUTPUT);                        // Define port como saida
  79.   pinMode(pinopir, INPUT);                              // Define port sensor como entrada
  80.   pinMode(SistemaOnOff, OUTPUT);
  81.   digitalWrite(SistemaOnOff, HIGH);                     // Comuta para o controle digital digital
  82.   digitalWrite(pinoativaluz, HIGH);
  83.  
  84.   pinMode(Canal1, OUTPUT);                              // Define port para Canal1 como saida
  85.   pinMode(Canal2, OUTPUT);                              // Define port para Canal2 como saida
  86.   pinMode(Canal3, OUTPUT);                              // Define port para Canal3 como saida
  87.   pinMode(Canal4, OUTPUT);                              // Define port para Canal4 como saida
  88.  
  89.   lcd.begin(16, 2);                                     // Iniciando a biblioteca do LCD
  90.   lcd.print("INICIANDO... ");
  91.   delay(500);
  92.   lcd.createChar(Dir, seta_direita);                    // vai criar novos caracteres
  93.   lcd.createChar(Esq, seta_esquerda);
  94.   lcd.createChar(Desce, seta_abaixo);
  95.   lcd.createChar(Sobe, seta_acima);
  96. }
  97. //----------------------------------
  98. void loop()
  99. {
  100.   if (MenuCarga == 1)
  101.   {
  102.     Controla_Vent_Temp();
  103.   }
  104.   acionamento = digitalRead(pinopir);                   //Le o valor do sensor
  105.   if (acionamento != 0)
  106.   {
  107.     digitalWrite(pinoativaluz, HIGH);                   //aciona a luz se estiver desligada
  108.     ConRegre = ConRegreReg;                             // reseta o contador para o valor definido pela variavel ConRegreReg
  109.   }
  110.   if (ConRegre <= 0)
  111.   {
  112.     digitalWrite(pinoativaluz, LOW);                    // desliga a luz ao final da contagem
  113.   }
  114.   ////////////////////////////////////////////////////cod. sensor
  115.   switch (state)
  116.   {
  117.     case 1: //MENU 1 - CONTROLE (LIGADO/DESLIGADO)
  118.       switch (CheckButton())
  119.       {
  120.         case bUp:
  121.           Set_state(2);
  122.           break;
  123.         case bDown:
  124.           Set_state(12);
  125.           break;
  126.         case bLeft:
  127.           digitalWrite(8, LOW);
  128.           lcd.setCursor(0, 1);
  129.           lcd.print("DESLIGADO    ");
  130.           tone(buzzer, 1500, 50);
  131.           break;
  132.         case bRight:
  133.           digitalWrite(8, HIGH);
  134.           lcd.setCursor(0, 1);
  135.           lcd.print("LIGADO       ");
  136.           tone(buzzer, 1500, 50);
  137.           break;
  138.         default:
  139.           Set_state(1);
  140.           break;
  141.       }
  142.       break;
  143.  
  144.     case 2: //ILUMINACAO
  145.       switch (CheckButton())
  146.       {
  147.         case bUp:
  148.           Set_state(3);
  149.           break;
  150.         case bDown:
  151.           Set_state(1);
  152.           break;
  153.         case bLeft:
  154.           if (ConRegreReg >= 30)
  155.           {
  156.             ConRegreReg = ConRegreReg - 30;
  157.           }
  158.           ConRegre = ConRegreReg;
  159.  
  160.           tone(buzzer, 1500, 50);
  161.           break;
  162.         case bRight:
  163.           ConRegreReg = ConRegreReg + 30;
  164.           ConRegre = ConRegreReg;
  165.           tone(buzzer, 1500, 50);
  166.           break;
  167.         default:
  168.           Set_state(2);
  169.           break;
  170.       }
  171.       break;
  172.  
  173.     case 3: //ILUMINACAO - CONFIGURA TEMPO
  174.       switch (CheckButton())
  175.       {
  176.         case bUp:
  177.           Set_state(4);
  178.           break;
  179.         case bDown:
  180.           Set_state(2);
  181.           break;
  182.         case bLeft:
  183.           if (ConRegreReg >= 30)
  184.           {
  185.             ConRegreReg = ConRegreReg - 30;
  186.           }
  187.           ConRegre = ConRegreReg;
  188.           tone(buzzer, 1500, 50);
  189.           break;
  190.         case bRight:
  191.           ConRegreReg = ConRegreReg + 30;
  192.           ConRegre = ConRegreReg;
  193.           tone(buzzer, 1500, 50);
  194.           break;
  195.         default:
  196.           Set_state(3);
  197.           break;
  198.       }
  199.       break;
  200.  
  201.     case 4: //ILUMINACAO - MONITORACAO
  202.       switch (CheckButton())
  203.       {
  204.         case bUp:
  205.           Set_state(5);
  206.           break;
  207.         case bDown:;
  208.           Set_state(3);
  209.           break;
  210.         default:
  211.           Set_state(4);
  212.           break;
  213.       }
  214.       break;
  215.  
  216.     case 5: //CARGA
  217.       switch (CheckButton())
  218.       {
  219.         case bUp:
  220.           Set_state(6);
  221.           break;
  222.         case bDown:
  223.           Set_state(4);
  224.           break;
  225.         default:
  226.           Set_state(5);
  227.           break;
  228.       }
  229.       break;
  230.  
  231.     case 6: //CARGA - 1
  232.       switch (CheckButton())
  233.       {
  234.         case bUp:
  235.           Set_state(7);
  236.           break;
  237.         case bDown:;
  238.           Set_state(5);
  239.           break;
  240.         case bLeft:
  241.           if (val1 < 100 )
  242.           {
  243.             val1 = val1 + 5;
  244.             if (val1 == 6) val1 = 5;
  245.             Disparo[0] =  105 - val1;
  246.             tone(buzzer, 1500, 50);
  247.           }
  248.           break;
  249.         case bRight:
  250.           if (val1 > 0)
  251.           {
  252.             val1 = val1 - 5;
  253.             if (val1 <= 0) val1 = 1;
  254.             Disparo[0] =  105 - val1;
  255.             tone(buzzer, 1500, 50);
  256.           }
  257.           break;
  258.         default:
  259.           Set_state(6);
  260.           break;
  261.       }
  262.       break;
  263.  
  264.     case 7: //CARGA - 2
  265.       switch (CheckButton())
  266.       {
  267.         case bUp:
  268.           Set_state(8);
  269.           break;
  270.         case bDown:
  271.           Set_state(6);
  272.           break;
  273.         case bLeft:
  274.           if (val2 < 100 )
  275.           {
  276.             val2 = val2 + 5;
  277.             if (val2 == 6) val2 = 5;
  278.             Disparo[1] =  105 - val2;
  279.             tone(buzzer, 1500, 50);
  280.           }
  281.           break;
  282.         case bRight:
  283.           if (val2 > 0)
  284.           {
  285.             val2 = val2 - 5;
  286.             if (val2 <= 0) val2 = 1;
  287.             Disparo[1] =  105 - val2;
  288.             tone(buzzer, 1500, 50);
  289.           }
  290.           break;
  291.         default:
  292.           Set_state(7);
  293.           break;
  294.       }
  295.       break;
  296.  
  297.     case 8: //CARGA - 3
  298.       switch (CheckButton())
  299.       {
  300.         case bUp:
  301.           Set_state(9);
  302.           break;
  303.         case bDown:
  304.           Set_state(7);
  305.           break;
  306.         case bLeft:
  307.           if (val3 < 100 )
  308.           {
  309.             val3 = val3 + 1;
  310.             Disparo[2] =  101 - val3;
  311.             tone(buzzer, 1500, 50);
  312.           }
  313.           break;
  314.         case bRight:
  315.           if (val3 > 0)
  316.           {
  317.             val3 = val3 - 1;
  318.             if (val3 <= 0) val3 = 1;
  319.             Disparo[2] =  101 - val3;
  320.             tone(buzzer, 1500, 50);
  321.           }
  322.           break;
  323.         default:
  324.           Set_state(8);
  325.           break;
  326.       }
  327.       break;
  328.  
  329.     case 9: //CARGA - 4
  330.       switch (CheckButton())
  331.       {
  332.         case bUp:
  333.           Set_state(10);
  334.           break;
  335.         case bDown:
  336.           Set_state(8);
  337.           break;
  338.         case bLeft:
  339.           if (val4 < 100 )
  340.           {
  341.             val4 = val4 + 1;
  342.             Disparo[3] =  101 - val4;
  343.             tone(buzzer, 1500, 50);
  344.           }
  345.           break;
  346.         case bRight:
  347.           if (val4 > 0)
  348.           {
  349.             val4 = val4 - 1;
  350.             if (val4 <= 0) val4 = 1;
  351.             Disparo[3] =  101 - val4;
  352.             tone(buzzer, 1500, 50);
  353.           }
  354.           break;
  355.         default:
  356.           Set_state(9);
  357.           break;
  358.       }
  359.       break;
  360.  
  361.     case 10: //CARGA - MONITOR TEMPERATURA
  362.       switch (CheckButton())
  363.       {
  364.         case bUp:
  365.           Set_state(11);
  366.           break;
  367.         case bDown:
  368.           Set_state(9);
  369.           break;
  370.         case bLeft:
  371.           tone(buzzer, 1500, 50);
  372.           break;
  373.         case bRight:
  374.           if (MenuCarga == 1)
  375.           {
  376.             tone(buzzer, 1500, 50);
  377.           }
  378.           else if (MenuCarga == 0)
  379.           {
  380.             tone(buzzer, 1500, 50);
  381.           }
  382.           break;
  383.         default:
  384.           Set_state(10);
  385.           break;
  386.       }
  387.       break;
  388.  
  389.     case 11: //MENU CARGA - ATIVA AUTOMACAO DE ATIVACAO DO DIMMER AUTOMATICAMENTE
  390.       switch (CheckButton())
  391.       {
  392.         case bUp:
  393.           Set_state(12);
  394.           break;
  395.         case bDown:
  396.           Set_state(10);
  397.           break;
  398.         case bLeft:
  399.           MenuCarga = 0;
  400.           lcd.setCursor(0, 1);
  401.           lcd.print("DESLIGADO   ");
  402.           tone(buzzer, 1500, 50);
  403.           break;
  404.         case bRight:
  405.           MenuCarga = 1;
  406.           lcd.setCursor(0, 1);
  407.           lcd.print("LIGADO      ");
  408.           tone(buzzer, 1500, 50);
  409.           break;
  410.         default:
  411.           Set_state(11);
  412.       }
  413.       break;
  414.  
  415.     case 12: //MENU CARGA - CONFIGURA TEMPO
  416.       switch (CheckButton())
  417.       {
  418.         case bUp:
  419.           Set_state(1);
  420.           break;
  421.         case bDown:
  422.           Set_state(11);
  423.           break;
  424.         case bLeft:
  425.           ConfigTemp++;
  426.           lcd.setCursor(0, 1);
  427.           lcd.print(ConfigTemp);
  428.           tone(buzzer, 1500, 50);
  429.           break;
  430.         case bRight:
  431.           ConfigTemp--;
  432.           lcd.setCursor(0, 1);
  433.           lcd.print(ConfigTemp);
  434.           tone(buzzer, 1500, 50);
  435.           break;
  436.         default:
  437.           Set_state(12);
  438.           lcd.setCursor(0, 1);
  439.           lcd.print(ConfigTemp);
  440.           lcd.write(B11011111);                         // Simbolo de graus celsius
  441.           lcd.print("C          ");
  442.       }
  443.     default: ;
  444.   }
  445. }
  446. //----------------------------------
  447. char CheckButton()                                      // Checa botoes acionados aLeft Inical = 0
  448. {
  449.   if (aLeft != digitalRead(bLeft))                      // Se aLeft diferente de bLeft
  450.   { // Faça
  451.     aLeft = !aLeft;                                     // Inverste aLeft
  452.     if (aLeft) return bLeft0;                           // Se aLeft diferente de 0 retorne bLeft0 (90)??
  453.     else   return bLeft;                                // Se aLeft igual a 0 retorne bLeft
  454.   }
  455.   else                                                  // Se aLeft igual de bLeft
  456.     if (aRight != digitalRead(bRight))                  // Se aRight diferente de bRight
  457.     { // Faça
  458.       aRight = !aRight;                                 // Inverste aRight
  459.       if (aRight) return bRight0;                       // Se aRight diferente de 0 retorne bRight0 (91)??
  460.       else  return bRight;                              // Se aRight igual a 0 retorne bRight
  461.     }
  462.     else                                                // Se aRight igual de bRight
  463.       if (aUp != digitalRead(bUp))                      // Se aUp diferente de bUp
  464.       { // Faça
  465.         aUp = !aUp;                                     // Inverste aUp
  466.         if (aUp) return bUp0;                           // Se aUp diferente de 0 retorne bUp0 (92)??
  467.         else  return bUp;                               // Se aUp igual a 0 retorne bUp
  468.       }
  469.       else                                              // Se aUp igual de bUp
  470.         if (aDown != digitalRead(bDown))                // Se aDown diferente de bDown
  471.         { // Faça
  472.           aDown = !aDown;                               // Inverste aDown
  473.           if (aDown) return bDown0;                     // Se aDown diferente de 0 retorne bDown0 (93)??
  474.           else  return bDown;                           // Se aDown igual a 0 retorne bDown
  475.         }
  476.         else                                            // Se aDown igual de bDown
  477.           return 0;                                     // Retorne 0
  478. }
  479. //---------------------------------
  480. void Set_state(char index)
  481. {
  482.   state = index;                                        // Atualiza a variavel state para a nova tela
  483.   switch (state)                                        // verifica qual a tela atual e exibe o conteudo correspondente
  484.   {
  485.     case 1: //==================== state 1
  486.       lcd.setCursor(0, 0);
  487.       lcd.print("CONTROLE    ");
  488.       lcd.write(Esq);
  489.       lcd.write(Dir);
  490.       lcd.write(Sobe);
  491.       lcd.write(Desce);
  492.       lcd.setCursor(0, 1);
  493.       if (digitalRead(8) == HIGH)
  494.         lcd.print("LIGADO       ");                     // Print LIGADO
  495.       else                                              // Se o sistema estiver desligado
  496.         lcd.print("DESLIGADO    ");                     // Print DESLIGADO
  497.       break;
  498.     case 2: //==================== state 2
  499.       lcd.setCursor(0, 0);
  500.       lcd.print("ILUMINACAO  ");
  501.       lcd.write(Esq);
  502.       lcd.write(Dir);
  503.       lcd.write(Sobe);
  504.       lcd.write(Desce);
  505.       lcd.setCursor(0, 1);
  506.       lcd.print("T. CONF:");
  507.       lcd.print(ConRegreReg);
  508.       lcd.print("s");
  509.       break;
  510.     case 3: //==================== state 3
  511.       lcd.setCursor(0, 0);
  512.       lcd.print("CONF. TEMPO ");
  513.       lcd.write(Esq);
  514.       lcd.write(Dir);
  515.       lcd.write(Sobe);
  516.       lcd.write(Desce);
  517.       lcd.setCursor(0, 1);
  518.       lcd.print("TEMPO: ");
  519.       lcd.print(ConRegreReg);
  520.       lcd.print("s      ");
  521.       break;
  522.     case 4: //==================== state 4
  523.       lcd.setCursor(0, 0);
  524.       lcd.print("MONIT. TEMPO  ");
  525.       lcd.write(Sobe);
  526.       lcd.write(Desce);     ;
  527.       lcd.setCursor(0, 1);
  528.       lcd.print("TEMPO: ");
  529.       lcd.print(ConRegre);
  530.       lcd.print("s  ");
  531.       break;
  532.     case 5: //==================== state 5
  533.       lcd.setCursor(0, 0);
  534.       lcd.print("CARGAS        ");
  535.       lcd.write(Sobe);
  536.       lcd.write(Desce);
  537.       lcd.setCursor(0, 1);
  538.       lcd.print("CONFIGURACAO");
  539.       break;
  540.     case 6: //==================== state 6
  541.       lcd.setCursor(0, 0);
  542.       lcd.print("CARGA 1     ");
  543.       lcd.write(Esq);
  544.       lcd.write(Dir);
  545.       lcd.write(Sobe);
  546.       lcd.write(Desce);
  547.       lcd.setCursor(0, 1);
  548.       lcd.print(val1, DEC);                             // mostra o valor de "variavel"
  549.       lcd.print(" %         ");
  550.       break;
  551.     case 7: //==================== state 7
  552.       lcd.setCursor(0, 0);
  553.       lcd.print("CARGA 2     ");
  554.       lcd.write(Esq);
  555.       lcd.write(Dir);
  556.       lcd.write(Sobe);
  557.       lcd.write(Desce);
  558.       lcd.setCursor(0, 1);
  559.       lcd.print(val2, DEC);                             // mostra o valor de "variavel"
  560.       lcd.print(" %         ");
  561.       break;
  562.     case 8: //==================== state 8
  563.       lcd.setCursor(0, 0);
  564.       lcd.print("CARGA 3     ");
  565.       lcd.write(Esq);
  566.       lcd.write(Dir);
  567.       lcd.write(Sobe);
  568.       lcd.write(Desce);
  569.       lcd.setCursor(0, 1);
  570.       lcd.print(val3, DEC);                             // mostra o valor de "variavel"
  571.       lcd.print(" %         ");
  572.       break;
  573.     case 9: //==================== state 9
  574.       lcd.setCursor(0, 0);
  575.       lcd.print("CARGA 4     ");
  576.       lcd.write(Esq);
  577.       lcd.write(Dir);
  578.       lcd.write(Sobe);
  579.       lcd.write(Desce);
  580.       lcd.setCursor(0, 1);
  581.       lcd.print(val4, DEC);                             // mostra o valor de "variavel"
  582.       lcd.print(" %         ");
  583.       break;
  584.     case 10: //==================== state 10
  585.       lcd.setCursor(0, 0);
  586.       lcd.print("TEMPERATURA   ");
  587.       lcd.write(Sobe);
  588.       lcd.write(Desce);
  589.       lcd.setCursor(0, 1);
  590.       atualizaTemperatura();                            // <------------------ Chama rotina de temperatura
  591.       lcd.print(menorValorTemp);                        // Imprime menor valor
  592.       lcd.write(B11011111);                             // Simbolo de graus celsius
  593.       lcd.print("C          ");
  594.       delay(250);
  595.       break;
  596.     case 11: //==================== state 11
  597.       lcd.setCursor(0, 0);
  598.       lcd.print("AUTOMACAO   ");
  599.       lcd.write(Esq);
  600.       lcd.write(Dir);
  601.       lcd.write(Sobe);
  602.       lcd.write(Desce);
  603.       lcd.setCursor(0, 1);
  604.       if (MenuCarga == 1)
  605.         lcd.print("LIGADO       ");                     // Print LIGADO
  606.       else                                              // Se o sistema estiver desligado
  607.         lcd.print("DESLIGADO    ");                     // Print DESLIGADO
  608.       break;
  609.     case 12: //==================== state 12
  610.       lcd.setCursor(0, 0);
  611.       lcd.print("AJUSTE TEMP ");
  612.       lcd.write(Esq);
  613.       lcd.write(Dir);
  614.       lcd.write(Sobe);
  615.       lcd.write(Desce);
  616.       break;
  617.     default:;
  618.   }
  619. }
  620. //-------------------------------------------
  621. void atualizaTemperatura()
  622. {
  623.   menorValorTemp  = INT_MAX;                            // Inicializando com o maior valor int possivel
  624.   for (int i = 1; i <= 8; i++)
  625.   {
  626.     valorSensorTemp = analogRead(sensorTemp);           // Lendo o valor do sensor de temperatura.
  627.     valorSensorTemp *= 0.54 ;                           // Transformando valor lido no sensor de temperatura em graus celsius aproximados.
  628.     if (valorSensorTemp < menorValorTemp)               // Mantendo sempre a menor temperatura lida
  629.     {
  630.       menorValorTemp = valorSensorTemp;
  631.     }
  632.   }
  633. }
  634. //--------------------------------------------
  635. void Controla_Vent_Temp()                               // define qual valor a variavel str1 vai receber de acordo com a temperatura
  636. {
  637.   int verificasistema = digitalRead(8);                 // le o valor na saida se estao ou nao ativado
  638.   int verificaLuz = digitalRead(A1);                    // le o valor na saida do luzes
  639.   if (verificasistema == HIGH)                          // verifica se o sistema estao ou nao operante
  640.   {
  641.     if (verificaLuz == HIGH)                            // verifica se a luz esta ou nao ligado
  642.     {
  643.       atualizaTemperatura();                            // chama a rotina de temperatura
  644.     }
  645.     if (menorValorTemp <= ConfigTemp)                   // compara a temperatura (LM35) menorValorTemp funcao do sensor e ConfigTemp variavel definida pelo usuario
  646.     {
  647.       str5 = 0;
  648.     }
  649.     if (menorValorTemp >= 35)
  650.     {
  651.       str5 = 90;
  652.     }
  653.     else if (menorValorTemp < 34 && menorValorTemp > 32 )
  654.     {
  655.       str5 = 60;
  656.     }
  657.     else if (menorValorTemp < 31 && menorValorTemp > 30 )
  658.     {
  659.       str5 = 40;
  660.     }
  661.   }
  662.   if (verificasistema == LOW)
  663.   {
  664.     str5 = 0;
  665.   }
  666. }
  667. //--------------------------------
  668. void Timer1Zr()                                         // Rotina chamada pelo Interrupt de Zero do Timer1
  669. {
  670.   Contador++;                                           // Incrementa contador para contar 1 Segundo
  671.   if (Contador == 13333)                                // Valor de contagem para 1 segundo
  672.   {
  673.     ConRegre--;                                         // Decrementa tempo programado
  674.     if (ConRegre <= 0) ConRegre = 0;                    // Se chegar em zero, fica em zero
  675.     Contador = 0;                                       // Zera contador
  676.   }
  677.   Pulso_Timer1++;                                       // Incrementa o tempo de controle de disparo
  678.  
  679.   if (Disparo[0] == Pulso_Timer1)                       // Se o atraso do Triac 0 for igual a tempo apos o zerocross
  680.   {
  681.     digitalWrite(Canal1, HIGH);                         // Dispara Triac
  682.     delayMicroseconds(5);                               // Tempo de disparo ligado
  683.     digitalWrite(Canal1, LOW);                          // Corta disparo Triac
  684.   }
  685.   if (Disparo[1] == Pulso_Timer1)                       // Se o atraso do Triac 1 for igual a tempo apos o zerocross
  686.   {
  687.     digitalWrite(Canal2, HIGH);                         // Dispara Triac
  688.     delayMicroseconds(5);                               // Tempo de disparo ligado
  689.     digitalWrite(Canal2, LOW);                          // Corta disparo Triac
  690.   }
  691.   if (Disparo[2] == Pulso_Timer1)                       // Se o atraso do Triac 2 for igual a tempo apos o zerocross
  692.   {
  693.     digitalWrite(Canal3, HIGH);                         // Dispara Triac
  694.     delayMicroseconds(5);                               // Tempo de disparo ligado
  695.     digitalWrite(Canal3, LOW);                          // Corta disparo Triac
  696.   }
  697.   if (Disparo[3] == Pulso_Timer1)                       // Se o atraso do Triac 3 for igual a tempo apos o zerocross
  698.   {
  699.     digitalWrite(Canal4, HIGH);                         // Dispara Triac
  700.     delayMicroseconds(5);                               // Tempo de disparo ligado
  701.     digitalWrite(Canal4, LOW);                          // Corta disparo Triac
  702.   }
  703. }
  704. //--------------------------------
  705. void zero_cross()                                       // Senoide Passou pelo zero
  706. {
  707.   Pulso_Timer1 = 0;                                     // Zera contador de tempo
  708. }
Add Comment
Please, Sign In to add comment
Public Pastes
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!