RuiViana

Menu_LCD.ino

Dec 10th, 2018
138
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  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. }
RAW Paste Data