API tools faq
paste
Advertisement
RuiViana

Menu_Triac_4_Canais

RuiViana
Jul 15th, 2016
288
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 24.01 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.           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. }
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!