RuiViana

GCM_Ver3 _Sem_DImmer

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