RuiViana

Menu_Triac_4_Canais

Jul 15th, 2016
154
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.           lcd.clear();
  122.           Set_state(2);
  123.           break;
  124.         case bDown:
  125.           lcd.clear();
  126.           Set_state(12);
  127.           break;
  128.         case bLeft:
  129.           digitalWrite(8, LOW);
  130.           lcd.setCursor(0, 1);
  131.           lcd.print("DESLIGADO    ");
  132.           tone(buzzer, 1500, 50);
  133.           break;
  134.         case bRight:
  135.           digitalWrite(8, HIGH);
  136.           lcd.setCursor(0, 1);
  137.           lcd.print("LIGADO       ");
  138.           tone(buzzer, 1500, 50);
  139.           break;
  140.         default:
  141.           Set_state(1);
  142.           break;
  143.       }
  144.       break;
  145.  
  146.     case 2: //ILUMINACAO
  147.       switch (CheckButton())
  148.       {
  149.         case bUp:
  150.           lcd.clear();
  151.           Set_state(3);
  152.           break;
  153.         case bDown:
  154.           lcd.clear();
  155.           Set_state(1);
  156.           break;
  157.         case bLeft:
  158.           if (ConRegreReg >= 30)
  159.           {
  160.             ConRegreReg = ConRegreReg - 30;
  161.           }
  162.           ConRegre = ConRegreReg;
  163.  
  164.           tone(buzzer, 1500, 50);
  165.           break;
  166.         case bRight:
  167.           ConRegreReg = ConRegreReg + 30;
  168.           ConRegre = ConRegreReg;
  169.           tone(buzzer, 1500, 50);
  170.           break;
  171.         default:
  172.           Set_state(2);
  173.           break;
  174.       }
  175.       break;
  176.  
  177.     case 3: //ILUMINACAO - CONFIGURA TEMPO
  178.       switch (CheckButton())
  179.       {
  180.         case bUp:
  181.           lcd.clear();
  182.           Set_state(4);
  183.           break;
  184.         case bDown:
  185.           lcd.clear();
  186.           Set_state(2);
  187.           break;
  188.         case bLeft:
  189.           if (ConRegreReg >= 30)
  190.           {
  191.             ConRegreReg = ConRegreReg - 30;
  192.           }
  193.           ConRegre = ConRegreReg;
  194.           tone(buzzer, 1500, 50);
  195.           break;
  196.         case bRight:
  197.           ConRegreReg = ConRegreReg + 30;
  198.           ConRegre = ConRegreReg;
  199.           tone(buzzer, 1500, 50);
  200.           break;
  201.         default:
  202.           Set_state(3);
  203.           break;
  204.       }
  205.       break;
  206.  
  207.     case 4: //ILUMINACAO - MONITORACAO
  208.       switch (CheckButton())
  209.       {
  210.         case bUp:
  211.           lcd.clear();
  212.           Set_state(5);
  213.           break;
  214.         case bDown:
  215.           lcd.clear();
  216.           Set_state(3);
  217.           break;
  218.         default:
  219.           Set_state(4);
  220.           break;
  221.       }
  222.       break;
  223.  
  224.     case 5: //CARGA
  225.       switch (CheckButton())
  226.       {
  227.         case bUp:
  228.           lcd.clear();
  229.           Set_state(6);
  230.           break;
  231.         case bDown:
  232.           lcd.clear();
  233.           Set_state(4);
  234.           break;
  235.         default:
  236.           Set_state(5);
  237.           break;
  238.       }
  239.       break;
  240.  
  241.     case 6: //CARGA - 1
  242.       switch (CheckButton())
  243.       {
  244.         case bUp:
  245.           lcd.clear();
  246.           Set_state(7);
  247.           break;
  248.         case bDown:
  249.           lcd.clear();
  250.           Set_state(5);
  251.           break;
  252.         case bLeft:
  253.           if (val1 < 100 )
  254.           {
  255.             val1 = val1 + 5;
  256.             if (val1 == 6) val1 = 5;
  257.             Disparo[0] =  105 - val1;
  258.             tone(buzzer, 1500, 50);
  259.           }
  260.           break;
  261.         case bRight:
  262.           if (val1 > 0)
  263.           {
  264.             val1 = val1 - 5;
  265.             if (val1 <= 0) val1 = 1;
  266.             Disparo[0] =  105 - val1;
  267.             tone(buzzer, 1500, 50);
  268.           }
  269.           break;
  270.         default:
  271.           Set_state(6);
  272.           break;
  273.       }
  274.       break;
  275.  
  276.     case 7: //CARGA - 2
  277.       switch (CheckButton())
  278.       {
  279.         case bUp:
  280.           lcd.clear();
  281.           Set_state(8);
  282.           break;
  283.         case bDown:
  284.           lcd.clear();
  285.           Set_state(6);
  286.           break;
  287.         case bLeft:
  288.           if (val2 < 100 )
  289.           {
  290.             val2 = val2 + 5;
  291.             if (val2 == 6) val2 = 5;
  292.             Disparo[1] =  105 - val2;
  293.             tone(buzzer, 1500, 50);
  294.           }
  295.           break;
  296.         case bRight:
  297.           if (val2 > 0)
  298.           {
  299.             val2 = val2 - 5;
  300.             if (val2 <= 0) val2 = 1;
  301.             Disparo[1] =  105 - val2;
  302.             tone(buzzer, 1500, 50);
  303.           }
  304.           break;
  305.         default:
  306.           Set_state(7);
  307.           break;
  308.       }
  309.       break;
  310.  
  311.     case 8: //CARGA - 3
  312.       switch (CheckButton())
  313.       {
  314.         case bUp:
  315.           lcd.clear();
  316.           Set_state(9);
  317.           break;
  318.         case bDown:
  319.           lcd.clear();
  320.           Set_state(7);
  321.           break;
  322.         case bLeft:
  323.           if (val3 < 100 )
  324.           {
  325.             val3 = val3 + 1;
  326.             Disparo[2] =  101 - val3;
  327.             tone(buzzer, 1500, 50);
  328.           }
  329.           break;
  330.         case bRight:
  331.           if (val3 > 0)
  332.           {
  333.             val3 = val3 - 1;
  334.             if (val3 <= 0) val3 = 1;
  335.             Disparo[2] =  101 - val3;
  336.             tone(buzzer, 1500, 50);
  337.           }
  338.           break;
  339.         default:
  340.           Set_state(8);
  341.           break;
  342.       }
  343.       break;
  344.  
  345.     case 9: //CARGA - 4
  346.       switch (CheckButton())
  347.       {
  348.         case bUp:
  349.           lcd.clear();
  350.           Set_state(10);
  351.           break;
  352.         case bDown:
  353.           lcd.clear();
  354.           Set_state(8);
  355.           break;
  356.         case bLeft:
  357.           if (val4 < 100 )
  358.           {
  359.             val4 = val4 + 1;
  360.             Disparo[3] =  101 - val4;
  361.             tone(buzzer, 1500, 50);
  362.           }
  363.           break;
  364.         case bRight:
  365.           if (val4 > 0)
  366.           {
  367.             val4 = val4 - 1;
  368.             if (val4 <= 0) val4 = 1;
  369.             Disparo[3] =  101 - val4;
  370.             tone(buzzer, 1500, 50);
  371.           }
  372.           break;
  373.         default:
  374.           Set_state(9);
  375.           break;
  376.       }
  377.       break;
  378.  
  379.     case 10: //CARGA - MONITOR TEMPERATURA
  380.       switch (CheckButton())
  381.       {
  382.         case bUp:
  383.           lcd.clear();
  384.           Set_state(11);
  385.           break;
  386.         case bDown:
  387.           lcd.clear();
  388.           Set_state(9);
  389.           break;
  390.         case bLeft:
  391.           lcd.clear();
  392.           tone(buzzer, 1500, 50);
  393.           break;
  394.         case bRight:
  395.           if (MenuCarga == 1)
  396.           {
  397.             lcd.clear();
  398.             tone(buzzer, 1500, 50);
  399.           }
  400.           else if (MenuCarga == 0)
  401.           {
  402.             lcd.clear();
  403.             tone(buzzer, 1500, 50);
  404.           }
  405.           break;
  406.         default:
  407.           Set_state(10);
  408.           break;
  409.       }
  410.       break;
  411.  
  412.     case 11: //MENU CARGA - ATIVA AUTOMACAO DE ATIVACAO DO DIMMER AUTOMATICAMENTE
  413.       switch (CheckButton())
  414.       {
  415.         case bUp:
  416.           lcd.clear();
  417.           Set_state(12);
  418.           break;
  419.         case bDown:
  420.           lcd.clear();
  421.           Set_state(10);
  422.           break;
  423.         case bLeft:
  424.           MenuCarga = 0;
  425.           lcd.setCursor(0, 1);
  426.           lcd.print("DESLIGADO   ");
  427.           tone(buzzer, 1500, 50);
  428.           break;
  429.         case bRight:
  430.           MenuCarga = 1;
  431.           lcd.setCursor(0, 1);
  432.           lcd.print("LIGADO      ");
  433.           tone(buzzer, 1500, 50);
  434.           break;
  435.         default:
  436.           Set_state(11);
  437.       }
  438.       break;
  439.  
  440.     case 12: //MENU CARGA - CONFIGURA TEMPO
  441.       switch (CheckButton())
  442.       {
  443.         case bUp:
  444.           lcd.clear();
  445.           Set_state(1);
  446.           break;
  447.         case bDown:
  448.           lcd.clear();
  449.           Set_state(11);
  450.           break;
  451.         case bLeft:
  452.           ConfigTemp++;
  453.           lcd.setCursor(0, 1);
  454.           lcd.print(ConfigTemp);
  455.           tone(buzzer, 1500, 50);
  456.           break;
  457.         case bRight:
  458.           ConfigTemp--;
  459.           lcd.setCursor(0, 1);
  460.           lcd.print(ConfigTemp);
  461.           tone(buzzer, 1500, 50);
  462.           break;
  463.         default:
  464.           Set_state(12);
  465.           lcd.setCursor(0, 1);
  466.           lcd.print(ConfigTemp);
  467.           lcd.write(B11011111);                         // Simbolo de graus celsius
  468.           lcd.print("C");
  469.       }
  470.     default: ;
  471.   }
  472. }
  473. //----------------------------------
  474. char CheckButton()                                      // Checa botoes acionados aLeft Inical = 0
  475. {
  476.   if (aLeft != digitalRead(bLeft))                      // Se aLeft diferente de bLeft
  477.   { // Faça
  478.     aLeft = !aLeft;                                     // Inverste aLeft
  479.     if (aLeft) return bLeft0;                           // Se aLeft diferente de 0 retorne bLeft0 (90)??
  480.     else   return bLeft;                                // Se aLeft igual a 0 retorne bLeft
  481.   }
  482.   else                                                  // Se aLeft igual de bLeft
  483.     if (aRight != digitalRead(bRight))                  // Se aRight diferente de bRight
  484.     { // Faça
  485.       aRight = !aRight;                                 // Inverste aRight
  486.       if (aRight) return bRight0;                       // Se aRight diferente de 0 retorne bRight0 (91)??
  487.       else  return bRight;                              // Se aRight igual a 0 retorne bRight
  488.     }
  489.     else                                                // Se aRight igual de bRight
  490.       if (aUp != digitalRead(bUp))                      // Se aUp diferente de bUp
  491.       { // Faça
  492.         aUp = !aUp;                                     // Inverste aUp
  493.         if (aUp) return bUp0;                           // Se aUp diferente de 0 retorne bUp0 (92)??
  494.         else  return bUp;                               // Se aUp igual a 0 retorne bUp
  495.       }
  496.       else                                              // Se aUp igual de bUp
  497.         if (aDown != digitalRead(bDown))                // Se aDown diferente de bDown
  498.         { // Faça
  499.           aDown = !aDown;                               // Inverste aDown
  500.           if (aDown) return bDown0;                     // Se aDown diferente de 0 retorne bDown0 (93)??
  501.           else  return bDown;                           // Se aDown igual a 0 retorne bDown
  502.         }
  503.         else                                            // Se aDown igual de bDown
  504.           return 0;                                     // Retorne 0
  505. }
  506. //---------------------------------
  507. void Set_state(char index)
  508. {
  509.   state = index;                                        // Atualiza a variavel state para a nova tela
  510.   switch (state)                                        // verifica qual a tela atual e exibe o conteudo correspondente
  511.   {
  512.     case 1: //==================== state 1
  513.       lcd.setCursor(0, 0);
  514.       lcd.print("CONTROLE    ");
  515.       lcd.write(Esq);
  516.       lcd.write(Dir);
  517.       lcd.write(Sobe);
  518.       lcd.write(Desce);
  519.       lcd.setCursor(0, 1);
  520.       if (digitalRead(8) == HIGH)
  521.         lcd.print("LIGADO       ");                     // Print LIGADO
  522.       else                                              // Se o sistema estiver desligado
  523.         lcd.print("DESLIGADO    ");                     // Print DESLIGADO
  524.       break;
  525.     case 2: //==================== state 2
  526.       lcd.setCursor(0, 0);
  527.       lcd.print("ILUMINACAO  ");
  528.       lcd.write(Esq);
  529.       lcd.write(Dir);
  530.       lcd.write(Sobe);
  531.       lcd.write(Desce);
  532.       lcd.setCursor(0, 1);
  533.       lcd.print("T. CONF:");
  534.       lcd.print(ConRegreReg);
  535.       lcd.print("s");
  536.       break;
  537.     case 3: //==================== state 3
  538.       lcd.setCursor(0, 0);
  539.       lcd.print("CONF. TEMPO ");
  540.       lcd.write(Esq);
  541.       lcd.write(Dir);
  542.       lcd.write(Sobe);
  543.       lcd.write(Desce);
  544.       lcd.setCursor(0, 1);
  545.       lcd.print("TEMPO: ");
  546.       lcd.print(ConRegreReg);
  547.       lcd.print("s      ");
  548.       break;
  549.     case 4: //==================== state 4
  550.       lcd.setCursor(0, 0);
  551.       lcd.print("MONIT. TEMPO  ");
  552.       lcd.write(Sobe);
  553.       lcd.write(Desce);     ;
  554.       lcd.setCursor(0, 1);
  555.       lcd.print("TEMPO: ");
  556.       lcd.print(ConRegre);
  557.       lcd.print("s");
  558.       break;
  559.     case 5: //==================== state 5
  560.       lcd.setCursor(0, 0);
  561.       lcd.print("CARGAS        ");
  562.       lcd.write(Sobe);
  563.       lcd.write(Desce);
  564.       lcd.setCursor(0, 1);
  565.       lcd.print("CONFIGURACAO");
  566.       break;
  567.     case 6: //==================== state 6
  568.       lcd.setCursor(0, 0);
  569.       lcd.print("CARGA 1     ");
  570.       lcd.write(Esq);
  571.       lcd.write(Dir);
  572.       lcd.write(Sobe);
  573.       lcd.write(Desce);
  574.       lcd.setCursor(0, 1);
  575.       lcd.print(val1, DEC);                             // mostra o valor de "variavel"
  576.       lcd.print(" %   ");
  577.       break;
  578.     case 7: //==================== state 7
  579.       lcd.setCursor(0, 0);
  580.       lcd.print("CARGA 2     ");
  581.       lcd.write(Esq);
  582.       lcd.write(Dir);
  583.       lcd.write(Sobe);
  584.       lcd.write(Desce);
  585.       lcd.setCursor(0, 1);
  586.       lcd.print(val2, DEC);                             // mostra o valor de "variavel"
  587.       lcd.print(" %   ");
  588.       break;
  589.     case 8: //==================== state 8
  590.       lcd.setCursor(0, 0);
  591.       lcd.print("CARGA 3     ");
  592.       lcd.write(Esq);
  593.       lcd.write(Dir);
  594.       lcd.write(Sobe);
  595.       lcd.write(Desce);
  596.       lcd.setCursor(0, 1);
  597.       lcd.print(val3, DEC);                             // mostra o valor de "variavel"
  598.       lcd.print(" %   ");
  599.       break;
  600.     case 9: //==================== state 9
  601.       lcd.setCursor(0, 0);
  602.       lcd.print("CARGA 4     ");
  603.       lcd.write(Esq);
  604.       lcd.write(Dir);
  605.       lcd.write(Sobe);
  606.       lcd.write(Desce);
  607.       lcd.setCursor(0, 1);
  608.       lcd.print(val4, DEC);                             // mostra o valor de "variavel"
  609.       lcd.print(" %   ");
  610.       break;
  611.     case 10: //==================== state 10
  612.       lcd.clear();  //limpa o display do LCD.
  613.       lcd.setCursor(0, 0);
  614.       lcd.print("TEMPERATURA   ");
  615.       lcd.write(Sobe);
  616.       lcd.write(Desce);
  617.       lcd.setCursor(0, 1);
  618.       atualizaTemperatura();                            // <------------------ Chama rotina de temperatura
  619.       lcd.print(menorValorTemp);                        // Imprime menor valor
  620.       lcd.write(B11011111);                             // Simbolo de graus celsius
  621.       lcd.print("C");
  622.       delay(250);
  623.       break;
  624.     case 11: //==================== state 11
  625.       lcd.setCursor(0, 0);
  626.       lcd.print("AUTOMACAO   ");
  627.       lcd.write(Esq);
  628.       lcd.write(Dir);
  629.       lcd.write(Sobe);
  630.       lcd.write(Desce);
  631.       lcd.setCursor(0, 1);
  632.       if (MenuCarga == 1)
  633.         lcd.print("LIGADO       ");                     // Print LIGADO
  634.       else                                              // Se o sistema estiver desligado
  635.         lcd.print("DESLIGADO    ");                     // Print DESLIGADO
  636.       break;
  637.     case 12: //==================== state 12
  638.       lcd.setCursor(0, 0);
  639.       lcd.print("AJUSTE TEMP ");
  640.       lcd.write(Esq);
  641.       lcd.write(Dir);
  642.       lcd.write(Sobe);
  643.       lcd.write(Desce);
  644.       break;
  645.     default:;
  646.   }
  647. }
  648. //-------------------------------------------
  649. void atualizaTemperatura()
  650. {
  651.   menorValorTemp  = INT_MAX;                            // Inicializando com o maior valor int possivel
  652.   for (int i = 1; i <= 8; i++)
  653.   {
  654.     valorSensorTemp = analogRead(sensorTemp);           // Lendo o valor do sensor de temperatura.
  655.     valorSensorTemp *= 0.54 ;                           // Transformando valor lido no sensor de temperatura em graus celsius aproximados.
  656.     if (valorSensorTemp < menorValorTemp)               // Mantendo sempre a menor temperatura lida
  657.     {
  658.       menorValorTemp = valorSensorTemp;
  659.     }
  660.   }
  661. }
  662. //--------------------------------------------
  663. void Controla_Vent_Temp()                               // define qual valor a variavel str1 vai receber de acordo com a temperatura
  664. {
  665.   int verificasistema = digitalRead(8);                 // le o valor na saida se estao ou nao ativado
  666.   int verificaLuz = digitalRead(A1);                    // le o valor na saida do luzes
  667.   if (verificasistema == HIGH)                          // verifica se o sistema estao ou nao operante
  668.   {
  669.     if (verificaLuz == HIGH)                            // verifica se a luz esta ou nao ligado
  670.     {
  671.       atualizaTemperatura();                            // chama a rotina de temperatura
  672.     }
  673.     if (menorValorTemp <= ConfigTemp)                   // compara a temperatura (LM35) menorValorTemp funcao do sensor e ConfigTemp variavel definida pelo usuario
  674.     {
  675.       str5 = 0;
  676.     }
  677.     if (menorValorTemp >= 35)
  678.     {
  679.       str5 = 90;
  680.     }
  681.     else if (menorValorTemp < 34 && menorValorTemp > 32 )
  682.     {
  683.       str5 = 60;
  684.     }
  685.     else if (menorValorTemp < 31 && menorValorTemp > 30 )
  686.     {
  687.       str5 = 40;
  688.     }
  689.   }
  690.   if (verificasistema == LOW)
  691.   {
  692.     str5 = 0;
  693.   }
  694. }
  695. //--------------------------------
  696. void Timer1Zr()                                         // Rotina chamada pelo Interrupt de Zero do Timer1
  697. {
  698.   Contador++;                                           // Incrementa contador para contar 1 Segundo
  699.   if (Contador == 13333)                                // Valor de contagem para 1 segundo
  700.   {
  701.     ConRegre--;                                         // Decrementa tempo programado
  702.     if (ConRegre <= 0) ConRegre = 0;                    // Se chegar em zero, fica em zero
  703.     Contador = 0;                                       // Zera contador
  704.   }
  705.   Pulso_Timer1++;                                       // Incrementa o tempo de controle de disparo
  706.  
  707.   if (Disparo[0] == Pulso_Timer1)                       // Se o atraso do Triac 0 for igual a tempo apos o zerocross
  708.   {
  709.     digitalWrite(Canal1, HIGH);                         // Dispara Triac
  710.     delayMicroseconds(5);                               // Tempo de disparo ligado
  711.     digitalWrite(Canal1, LOW);                          // Corta disparo Triac
  712.   }
  713.   if (Disparo[1] == Pulso_Timer1)                       // Se o atraso do Triac 1 for igual a tempo apos o zerocross
  714.   {
  715.     digitalWrite(Canal2, HIGH);                         // Dispara Triac
  716.     delayMicroseconds(5);                               // Tempo de disparo ligado
  717.     digitalWrite(Canal2, LOW);                          // Corta disparo Triac
  718.   }
  719.   if (Disparo[2] == Pulso_Timer1)                       // Se o atraso do Triac 2 for igual a tempo apos o zerocross
  720.   {
  721.     digitalWrite(Canal3, HIGH);                         // Dispara Triac
  722.     delayMicroseconds(5);                               // Tempo de disparo ligado
  723.     digitalWrite(Canal3, LOW);                          // Corta disparo Triac
  724.   }
  725.   if (Disparo[3] == Pulso_Timer1)                       // Se o atraso do Triac 3 for igual a tempo apos o zerocross
  726.   {
  727.     digitalWrite(Canal4, HIGH);                         // Dispara Triac
  728.     delayMicroseconds(5);                               // Tempo de disparo ligado
  729.     digitalWrite(Canal4, LOW);                          // Corta disparo Triac
  730.   }
  731. }
  732. //--------------------------------
  733. void zero_cross()                                       // Senoide Passou pelo zero
  734. {
  735.   Pulso_Timer1 = 0;                                     // Zera contador de tempo
  736. }
RAW Paste Data