API tools faq
paste
Advertisement
RuiViana

GCM_Ver3 _Sem_DImmer

RuiViana
Jul 10th, 2016
294
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ (with Qt extensions) 20.43 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 = 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. }
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!