API tools faq
paste
Advertisement
RuiViana

Agua_NTP

RuiViana
Jan 27th, 2020
630
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 20.13 KB | None | 0 0
raw download clone embed print report
  1. /*  Este sketch aciona o sistema de irrigação
  2.   O sistema é ligado automaticamente a cada tempo calculado por
  3.   numero de segundos / 40 segundos
  4.   Está programado para ligar a cada 86400 segundos (24 Horas) 2160 ciclos de 40 segundos
  5.   O valor é definido para variavel count.
  6.   O sistema fica ligado pelo tempo definido pela variavel Tempo em usegundos.
  7.   A tecla ajuste deine o horario de inicio do ciclo de aguar.
  8.  
  9.   Sistema rodando a partir de 09/06/2017
  10.   modificado em 17/10/2018
  11.   Salvar ciclo e duração na EEPROM
  12.   Corrigir o  problema de manual
  13. */
  14. extern "C"                                                    // rotina para usar o timer do ESP
  15. {
  16. #include "user_interface.h"
  17. }
  18. os_timer_t mTimer;
  19. #include <EEPROM.h>                                           // Biblioteca do EEPROM
  20.  
  21. #include <EEPROM.h>                                           // Biblioteca do EEPROM
  22. #include <NTPClient.h>                                        // Biblioteca do NTP.
  23. //#include <ESP8266WiFi.h>                                      // Biblioteca do WiFi.
  24. #include <WiFiUdp.h>                                          // Biblioteca do UDP.
  25.  
  26. int countAuto = 1;                                            // Contador de tempo entre ciclos
  27. int countManual = 1;                                          // Contador de tempo entre ciclos
  28. int somaMinu = 0;                                             // Contreole de minutos fora da internet
  29. int horaD = 0;                                                // Hora de ligar
  30. int minD = 0;                                                 // Minuto de ligar
  31.  
  32. int acertoHora = 0;                                           // Para acertar hora da internet
  33. int acertoMin = 0;                                            // Para acertar hora da internet
  34.  
  35. int tempo = 2;                                                // Tempo de agua ligada
  36. long cicloAgua = 2880;                                        // Intervalo entre aguadas
  37. #include <ESP8266WebServer.h>                                 // Bibioteca para Servidor Web ESP8266  
  38. #include "setting.h"                                          // Minhas credenciais
  39. ESP8266WebServer server(80);                                  // Instancia server
  40.  
  41. String A_1 = "<!DOCTYPE HTML><html><head><meta http-equiv='refresh' content='1;URL=/Controle'/></head><h3><center> Controle de Agua V05</center></h3>";
  42. String A_2 = "</p></center><h3><BR></h3><html>\r\n";
  43. String Al = "";                                               // Agua ligada
  44. String Ad = "";                                               // Agua desligada
  45. String Ail = "";
  46. String Aid = "";
  47. String agua;                                                  // Seleciona opcao de Agua
  48. String hora;                                                  // Seleciona opcao de Hora
  49. String minu ;                                                 // Seleciona opcao de Min
  50. String duracao;                                               // Seleciona opcao de Duracao
  51. String ciclo;                                                 // Seleciona opcao de Ciclo
  52.  
  53. #define Saida1 2                                              // GPIO Port para ligar Controle do triac (Pino 2 do MOC3023)
  54. const int Switch1 = 4;                                        // GPIO Port para ligar o interruptor
  55. byte Switch1_atual = 0;                                       // Variavel para staus de GPIO (Status do interruptor)
  56. bool flagAgua = LOW;                                          // Controle de acao manual
  57. bool salva = LOW;                                             // Controle de salvar programacao na EEPROM
  58. bool acertei = LOW;                                           // Controle do acerto pela internet
  59. int salvaDados = 0;                                           // Controle do savamento dos dados na EEPROM
  60. String horario = "";                                          // Variavel para horario da internet
  61. WiFiUDP UDP;                                                  // Cria um objeto "UDP".
  62. const char* NTPServerName = "ntp.br";                         // Define o servidor NTP utilizado
  63. NTPClient timeClient(UDP, "a.st1.ntp.br", -3 * 3600, 60000);  // Cria um objeto "NTP" e corrige fuso
  64. IPAddress timeServerIP;
  65. //---------------------------
  66. void tCallback(void *tCall)                                   // Rotina chamada pelo interrupt de timer
  67. {
  68.   countAuto++;                                                // Incrementa contador de tempo automatico
  69.   countManual++;                                              // Incrementa contador de tempo manual
  70.   salvaDados++;                                               // Incrementa controle salvamento dos dados
  71.   somaMinu++;                                                 // Incrementa minutos fora da internet
  72. }
  73. //---------------------------
  74. void usrInit(void)                                            // Rotina de interrupt
  75. {
  76.   os_timer_disarm(&mTimer);
  77.   os_timer_setfn(&mTimer, tCallback, NULL);
  78.   os_timer_arm(&mTimer, 30000, true);                         // Interrupt a cada 30.000ms (30 seg)
  79. }
  80. //---------------------------------------
  81. void setup(void)
  82. {
  83.   EEPROM.begin(100);                                          // Inicia a EEPROM
  84.   EEPROM.get(0, tempo);                                       // Recupera dados da EEPROM
  85.   EEPROM.get(4, cicloAgua);
  86.  
  87.   usrInit();                                                  // Ativar a interrupcao
  88.   Al += A_1;                                                  // Monta tela pra informar que a luz
  89.   Al += "<p><center><a href=\"/Controle?agua=off \"><button style=\"background-color: rgb(255, 0,   0);height: 80px; width: 200px;\"><h2> ON</h2></button></a>";
  90.   Al += "<p><center><a href=\"/Controle?duracao=off \"><button style=\"background-color: rgb(0,255,  0);height: 50px; width: 200px;\"><h2>Duracao-1M</h2></button>&nbsp;&nbsp;</a>";
  91.   Al += "<a href=\"/Controle?duracao=on \"><button style=\"background-color: rgb(0, 0,255);height: 50px; width: 200px;\"><h2>Duracao+1M</h2></button></a>";
  92.   Al += "<p><a href=\"/Controle?ciclo=off \"><button style=\"background-color: rgb(0,255,  0);height: 50px; width: 200px;\"><h2>Ciclo-1H</h2></button>&nbsp;&nbsp;</a>";
  93.   Al += "<a href=\"/Controle?ciclo=on \"><button style=\"background-color: rgb(0, 0,255);height: 50px; width: 200px;\"><h2>Ciclo+1H</h2></button></a>";
  94.  
  95.   Ad += A_1;                                                  // Monta tela pra informar que a luz
  96.   Ad += "<p><center><a href=\"/Controle?agua=on \"><button style=\"background-color: rgb(0, 255,   0);height: 80px; width: 200px;\"><h2> OFF</h2></button></a>";
  97.   Ad += "<p><center><a href=\"/Controle?duracao=off \"><button style=\"background-color: rgb(0,255,  0);height: 50px; width: 200px;\"><h2>Duracao-1M</h2></button>&nbsp;&nbsp;</a>";
  98.   Ad += "<a href=\"/Controle?duracao=on \"><button style=\"background-color: rgb(0, 0,255);height: 50px; width: 200px;\"><h2>Duracao+1M</h2></button></a>";
  99.   Ad += "<p><a href=\"/Controle?ciclo=off \"><button style=\"background-color: rgb(0,255,  0);height: 50px; width: 200px;\"><h2>Ciclo-1H</h2></button>&nbsp;&nbsp;</a>";
  100.   Ad += "<a href=\"/Controle?ciclo=on \"><button style=\"background-color: rgb(0, 0,255);height: 50px; width: 200px;\"><h2>Ciclo+1H</h2></button></a>";
  101.  
  102.   pinMode(Switch1, INPUT_PULLUP);                             // Define GPIO5 como entrada e liga o resistor de pullup
  103.   Switch1_atual = digitalRead(Switch1);                       // Atualisa status de GPIO
  104.   pinMode(Saida1, OUTPUT);                                    // Define GPIO como saida
  105.   digitalWrite(Saida1, LOW);                                  // Liga GPIO
  106.   Serial.begin(115200);                                       // Inicialisa o serial port em 115200
  107.   Serial.println(" ");
  108.   Serial.print("tempo: ");
  109.   Serial.println(tempo);
  110.   Serial.print("cicloAgua: ");
  111.   Serial.println(cicloAgua);
  112.  
  113.   WiFi.begin(ssid, password);                                 // Conecta wifi
  114.   while (WiFi.status() != WL_CONNECTED)
  115.   {
  116.     delay(250);
  117.     Serial.print('.');
  118.   }
  119.   Serial.println(" ");
  120.   UDP.begin(123);                                             // Inicia protocolo UDP      
  121.  
  122.   if (!WiFi.hostByName(NTPServerName, timeServerIP))          // Conecta no servidor NTP
  123.   {
  124.     Serial.println("DNS lookup failed. Rebooting.");
  125.     Serial.flush();
  126.     ESP.reset();
  127.   }
  128.   Serial.print("IP do servidor NTP:\t");
  129.   Serial.println(timeServerIP);
  130.   timeClient.begin();                                               // Inicia o NTP.
  131.   timeClient.forceUpdate();                                         // Forca atualizacao da hora
  132.   Serial.printf("IP DHCP  %s, UDP port %d\n", WiFi.localIP().toString().c_str());
  133.   horario = timeClient.getFormattedTime();                          // Armazena na váriavel HORA, o horario atual.
  134.   Serial.println(horario);
  135.  
  136.   WiFi.begin(ssid, password);                                 // Inicialisa o wifi
  137.   IPAddress subnet(255, 255, 255, 0);                                             // Acrescentei para fixar o IP  12/5/2017
  138.   //  WiFi.config(IPAddress(192, 168, 0, 27), IPAddress(192, 168, 0, 1), subnet);     // Idem Em uso
  139.   WiFi.config(IPAddress(192, 168, 0, 44), IPAddress(192, 168, 0, 1), subnet);     // Idem Geste
  140.  
  141.   Serial.println("");                                         // Imprime
  142.   while (WiFi.status() != WL_CONNECTED)                       // Aguarda conexão
  143.   {
  144.     delay(500);                                               // Delay
  145.     Serial.print(".");                                        // Imprime . enquanto não conecta
  146.   }
  147.   Serial.println("");                                         // Imprime
  148.   Serial.print("Connected to ");
  149.   Serial.println(ssid);
  150.   Serial.print("IP address: ");
  151.   Serial.println(WiFi.localIP());
  152.  
  153.   server.on("/", []()                                         // Ao requeste
  154.   { server.send(200, "text/html", Al);                        // Executa o HTML Al (Agua ligada)
  155.   });
  156.   server.on("/Controle", []()                                 // Ao requeste /Agua
  157.   {
  158.     agua = server.arg("agua");                                // Recupera o valor do parametro Agua enviado
  159.     hora = server.arg("hora");                                // Recupera o valor do parametro Hora enviado
  160.     minu = server.arg("minu");                                // Recupera o valor do parametro Min enviado
  161.     duracao = server.arg("duracao");                          // Recupera o valor do parametro Duracao enviado
  162.     ciclo = server.arg("ciclo");                              // Recupera o valor do parametro Ciclo enviado
  163.     if (agua == "off") digitalWrite(Saida1, LOW);             // Se o valor de Agua e off desliga a saida
  164.     if (agua == "on")                                         // Se o valor de Agua e on
  165.     {
  166.       digitalWrite(Saida1, HIGH);                             // Liga a saida
  167.       countManual = 0;                                        // Zera contador de tempo em maual
  168.     }
  169.     horaD = countAuto / 120;                                  // Atualiza  horario
  170.     minD  = (countAuto / 2) - (horaD * 60);                   // Atualiza minutos
  171.     if (countAuto < 0) countAuto = 0;                         // Se Count for negativo, zera
  172.     if (duracao == "on")                                      // Aumentar duracao
  173.     {
  174.       tempo = tempo + 1;                                      // Se o valor de Duracao e on muda intervalo ligado
  175.       salva = HIGH;                                           // Libera salvar na EEPROM
  176.       salvaDados = 0;                                         // Zera tempo de salvamento
  177.     }
  178.     if (duracao == "off")                                     // Diminuir duracao
  179.     {
  180.       tempo = tempo - 1;                                      // Se o valor de Duracao e off muda intervalo ligado
  181.       salva = HIGH;                                           // Libera salvar na EEPROM
  182.       salvaDados = 0;                                         // Zera tempo de salvamento
  183.     }
  184.     if (tempo < 0) tempo = 0;                                 // Se Tempo for negativo, zera
  185.     if (ciclo == "on")                                        // Aumentar ciclo
  186.     {
  187.       cicloAgua = cicloAgua + 120;                            // Se o valor de Ciclo e on muda Ciclo de ligar
  188.       salva = HIGH;                                           // Libera salvar na EEPROM
  189.       salvaDados = 0;                                         // Zera tempo de salvamento
  190.     }
  191.     if (ciclo == "off")                                       // Diminuir ciclo
  192.     {
  193.       cicloAgua = cicloAgua - 120;                            // Se o valor de Ciclo e offn muda Ciclo de ligar
  194.       salva = HIGH;                                           // Libera salvar na EEPROM
  195.       salvaDados = 0;                                         // Zera tempo de salvamento
  196.     }
  197.     if (cicloAgua <= 0) cicloAgua = 2880;                     // Se CicloAgua for negativo, muda pra 2880   (2880 = 24 H)
  198.     if (cicloAgua > 2880) cicloAgua = 120;                    // Se CicloAgua for maior que 2880, muda pra 120 (120 = 1 H)
  199.     if (digitalRead(Saida1) == HIGH)                          // Se a saida esta ligada, carrega a pagina "ligada"
  200.     {
  201.       Ail += Al;                                              // Monta tela nova Agua ligada
  202.       Ail +=  "<p><h2><center>Hora: " + String(acertoHora) + ":" + String(acertoMin) + "&nbsp;&nbsp; Decorrida: " + String(horaD) + ":" + String(minD) + "&nbsp;&nbsp; </p>";
  203.       Ail +=  "<p><center>Duracao: " + String((float)tempo / 2) + "    Ciclo " + String(cicloAgua / 120) + " </h2></p>";
  204.       Ail += A_2;
  205.       server.send(200, "text/html", Ail);                     // Mostra Agua ligada
  206.       Ail = "";                                               // Limpa valor de temperatura e umidade
  207.     }
  208.     if (digitalRead(Saida1) == LOW)    // Se a saida esta desligada, carrega a pagina "desligada"
  209.     {
  210.       Aid += Ad;                                              // Monta tela nova Agua desligada
  211.       Aid +=  "<p><h2><center>Hora: " + String(acertoHora) + ":" + String(acertoMin) + "&nbsp;&nbsp; Decorrida: " + String(horaD) + ":" + String(minD) + "&nbsp;&nbsp; </p>";
  212.       Aid +=  "<p><center>Duracao: " + String((float)tempo / 2) + "    Ciclo " + String(cicloAgua / 120) + " </h2></p>";
  213.       Aid += A_2;
  214.       server.send(200, "text/html", Aid);                     // Mostra Agua desligada
  215.       Aid = "";                                               // Limpa valor de temperatura e umidade
  216.     }
  217.     delay(100);                                               // Delay
  218.   });
  219.   server.begin();                                             // Inicaliza servidor
  220.   Serial.println("HTTP server started");                      // Imprime
  221.   calctempo();                                                // Busca tempo na internet
  222. }
  223. //--------------------------------------------------
  224. void loop(void)
  225. {
  226.   if (somaMinu >= 2)                                          // Se passou 1 minuto
  227.   {
  228.     acertoMin++;                                              // Incrementa minuto
  229.     somaMinu = 0;                                             // Zera contador de minuto
  230.   }
  231.   if (acertoMin >= 60)                                        // Se passou 1 hoa
  232.   {
  233.     acertoHora++;                                              // Incrementa hora
  234.     acertoMin = 0;                                             // Zera contador de minutoera
  235.     if (acertoHora >= 24)                                      // Se passaram 24 horas
  236.     {
  237.       acertoHora = 0;                                          // Zera hora
  238.     }
  239.   }
  240.   if (acertoHora == 23)                                       // Se está no horario de acertar
  241.   {
  242.     if (acertei == LOW)                                       // Se ainda nao acertou
  243.     {
  244.       acertei = HIGH;                                         // Informa que acertou
  245.       calctempo();                                            // Acerta
  246.     }
  247.   }
  248.   if (acertoHora == 0)                                        // Se hora incial
  249.   {
  250.     acertei = LOW;                                            // Libera acerto
  251.   }
  252.  
  253.   server.handleClient();                                      // Executa instancia
  254.   if (countAuto >= cicloAgua)                                 // Se atingiu o Tempo do ciclo
  255.   {
  256.     digitalWrite(Saida1, HIGH);                               // Liga agua
  257.     countAuto = 0;                                            // Zera contador de tempo de ciclo
  258.   }
  259.   if (flagAgua == LOW)                                        // Se esta em automatico
  260.   {
  261.     if (countAuto >= tempo)                                   // Se passou o tempo de aguar
  262.     {
  263.       digitalWrite(Saida1, LOW);                              // Desliga a agua
  264.     }
  265.   }
  266.   if (countManual == 0)                                       // Se manual foi zerado
  267.   {
  268.     digitalWrite(Saida1, HIGH);                               // Liga agua
  269.     flagAgua = HIGH;                                          // Indica manual mode
  270.  
  271.   }
  272.   if (flagAgua == HIGH and countManual >= tempo)              // Se esta em manual e atingiu contagem amnual
  273.   {
  274.     digitalWrite(Saida1, LOW);                                // Desliga a agua
  275.     flagAgua = LOW;                                           // Indica automatico
  276.   }
  277.   if (flagAgua == HIGH and agua == "off")                     // Se esta em manual e foi desligado
  278.   {
  279.     digitalWrite(Saida1, LOW);                                // Desliga a agua
  280.     flagAgua = LOW;                                           // Indica automatico
  281.     countManual = 50;                                         // Impede novo acionamento maunal
  282.   }
  283.  
  284.   if (salvaDados >=  1)                                       // Se tempo de salvar passou
  285.   {
  286.     if (salva ==  HIGH)                                       // Se  ainda nao salvou
  287.     {
  288.       calctempo();                                            // Calcula tempo da intenete
  289.       //      EEPROM.put(0, tempo);                           // Salva
  290.       //      EEPROM.put(4, cicloAgua);
  291.       //      EEPROM.commit();
  292.       salva =  LOW;
  293.       Serial.print("tempo: ");                                // Imprime
  294.       Serial.println(tempo);
  295.       Serial.print("cicloAgua: ");
  296.       Serial.println(cicloAgua);
  297.     }
  298.   }
  299.   yield();                                                    // Um putosegundo soh pra respirar
  300. }
  301. //---------------------------------------------
  302. void calctempo()                                              // Recalcula tempo da internet
  303. {
  304.   horario = timeClient.getFormattedTime();                    // Obtem horario da internet
  305.   //   horario = "22:59:50";                                  // Debug
  306.   String horaNet = horario.substring(0, 2);                   // Separa hora de horario
  307.   String minNet = horario.substring(3, 5);                    // Separa minuto de horario
  308.   acertoHora = horaNet.toInt();                               // Transforma string em int
  309.   acertoMin = minNet.toInt();                                 // Transforma string em int
  310.   int calcAtual = acertoHora * 60 + acertoMin;                // Cacula tempo em 1/2 segundos
  311.   int calcCiclo = cicloAgua / 2;                              // Calcula Ciclos
  312.   int result = 0;                                             // Calculo dos periodos
  313.  
  314.   Serial.print(" calcAtual :"); Serial.println(calcAtual);    // Debug
  315.   Serial.print(" calcCiclo :"); Serial.println(calcCiclo);    // Debug
  316.   if (calcAtual >=  calcCiclo)                                // Verifica se horario é maior que ciclo
  317.   {
  318.     result = calcAtual - calcCiclo;                           // Se for subtri um ciclo
  319.   }
  320.   else
  321.     result = calcAtual;                                       // Se nao for considera tempo decorrido
  322.   Serial.print(" result :"); Serial.println(result);          // Debug
  323.   while (result > calcCiclo)                                  // Equanto resultado for maior que ciclo
  324.   {
  325.     result = result - calcCiclo;                              // Subtrai ciclo de resultado
  326.     Serial.print(" result :"); Serial.println(result);        // Debug
  327.   }
  328.   Serial.print(" result :"); Serial.println(result);          // Debug
  329.   countAuto =  result * 2;                                    // Contador automatico igual ao resultado * 2
  330. }
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!