6 de junho de 2020

Enquanto escrevo isto, não existem arquivos de design atuais, existe um esboço de código e existe um protótipo numa protoboard!

Por outro lado, existem requisitos para o hardware e para o software:

Requisitos e estágio do software

1. Simplificar o código criando mais funções;
2. Tentar separar a parte do HTML para ter um código mais limpo;
3. Melhorar a aparência/interface do código;
4. Adicionar as leituras ao HTML;
5. Adicionar um registro de ocorrências, como sobrecorrente;
6. Adicionar mais segurança para os equipamentos;
7. Adicionar uma interface de celular (APP);
8. Adicionar uma função para acertar a hora atual;
9. Adicionar uma função para renomear cada relé, para poder relacionar o relé com a área de interesse, ou pelo menos renomear os relés com as áreas reais da fazenda.

Requisitos e situação do design

1. Precisa ser pelo menos resistente à água;

7 de junho de 2020

Hoje, 7 de junho de 2020, o desenvolvimento está assim.

Eu começo com um sistema que funciona num Uno...

O código que roda nessa montagem está no GitHub da Fabfarm: Autovalve

O Shakeel, um dos nossos voluntários, conseguiu criar uma versão que roda num ESP8266, que está no mesmo repositório, aqui. Por causa da pandemia ele teve que ir embora às pressas e não teve tempo de testar o código; então funcionava, mas não era estável, porque ele heroicamente tentou compartilhar o pino analógico com o WiFi, o que causava quedas no WiFi que deixavam o sistema quase impossível de usar. Foi com esse código que eu comecei.

8 de junho de 2020

Depois de muitas horas tentando entender o código, consegui portar o código do Shakeel para um ESP32 e também dividir o arquivo, com cada função num arquivo separado.

Neste vídeo mostro o progresso que fiz até agora juntando os códigos e fazendo tudo funcionar no ESP32.

Veja a versão em alta resolução no YouTube

Portar o código para o ESP32 pode ser simples para um programador, mas para mim levou muitas horas.

Passos:

1. separei tudo o que já era função em arquivo próprio, para ficar mais legível;
2. depois abri outra sessão da Arduino IDE e comecei a copiar cada parte do código, linha por linha, para a nova sessão; nessa sessão renomeei o arquivo principal para "esp32irrigation"
3. remapeei os pinos para os pinos do ESP32
4. rodei o beautify no HTML no Brackets
5. organizei o código para os pinos ficarem no topo
6. criei variáveis para os pinos do RTC
7. comentei as partes do código que imprimem erros no monitor serial

O código é grande demais para mostrar no HTML, então vou deixar um link para o estado do código hoje de madrugada: código aqui.

Neste vídeo dá para ver a montagem de teste do sistema de irrigação atual da fazenda.

Veja a versão em alta resolução no YouTube

9 de junho de 2020

Hoje, depois de testar os relés, percebi que alguns relés funcionam e outros não. Depois de testar direto na fonte de bancada, com 5 volts aplicados no pino de sinal, acredito que isso seja por causa da tensão baixa fornecida pelo ESP32 ou da tensão do sinal.

Aí assisti ao vídeo do GreatScott! no YouTube sobre relés e optoacopladores.

Vou garantir que os relés tenham uma alimentação de pelo menos 5 volts, que é a tensão exigida segundo o datasheet. O sinal deve funcionar bem com 3,3 V. Vai ser testado no local.

O outro ponto é a leitura de corrente, que está completamente errada. Para ter o sistema de irrigação funcionando, vou ter que rodar sem a medição de corrente até depurar isso.

10 de junho de 2020

Depois dos testes, a conclusão sobre o problema de tensão é que o ESP32 não deve alimentar o relé; isso deve vir de uma fonte externa, ajustada em 5 volts. O sinal pode vir do ESP32 sem mudança, mas o ESP32 tem que compartilhar o mesmo terra.

Mais mudanças no código:

1. aumentei o intervalo em que a hora é mostrada de 3000 para 5000 ms (5 s), na variável RTCtimeInterval
2. aumentei o intervalo em que a configuração é mostrada de 10000 para 30000 ms (30 s), na variável configTimeInterval
3. coloquei nomes reconhecíveis na interface HTML dos relés
4. limpei mais um pouco o monitor serial, tirando os segundos da exibição das configurações

Hoje de manhã vou colocar a montagem para trabalhar de novo, programar os horários de cada irrigação e testar em campo o módulo de irrigação com ESP32.

Estranhamente, o relógio RTC externo não está marcando a hora certa. Vou ver como usar o relógio interno com uma bateria externa para o caso de falta de energia.

Segundo esta discussão encerrada no repositório do ESP no GitHub e este tópico sobre a precisão do ESP, o relógio interno vai atrasar/adiantar: "Internal RTC clock frequency error is about 5%" (o erro de frequência do relógio RTC interno é de cerca de 5%). Isso pode ser resolvido com um cristal externo de 32,768 kHz montado conforme o esquema abaixo:

Outra solução seria deixar o ESP sempre conectado à Internet, pegando a hora da Internet para compensar a imprecisão.

Atualização depois de acordar

Hoje fui instalar a montagem de teste temporária. Resolvi alguns problemas.

1. A montagem não funcionava quando desconectada do computador. Solução: a ligação da alimentação não estava certa; acabei ligando 2 cabos USB, um para o ESP32 e outro para os relés, e os dois compartilham o mesmo terra. Talvez eu também tenha resolvido o problema do relógio RTC com a mesma abordagem.

É assim que o protótipo está agora:

Ainda falta ligar a bomba e as válvulas solenoides.

Espero que as vespas não se importem com a invasão

Ligando o sistema

testando...testando...

Depois dos testes voltei para o código para personalizar mais.

Primeiro assisti a uma série de vídeos no YouTube sobre funções, criando funções de verdade, e depois comecei a criar ainda mais funções.

Basicamente fui ver como reduzir a repetição de código e como mandar um valor para uma função.

A partir do código que eu tinha, criei esta função:

void turnOffRelay(int valveHere){
  // wait then turn valve relay OFF
  Serial.print("Waiting ");
  Serial.print(waitTimeValveOff / 1000);
  Serial.println("s before deactivating Valve Relay 3.");
  delay(waitTimeValveOff);
  digitalWrite(valveHere, LOW);
  valveHere = 0;
  Serial.print("*** Valve Relay ");
  Serial.print(valveHere);
  Serial.println("3 turned OFF ***");
}

Atenção: valveHere = 0; roda antes de Serial.print(valveHere);, então a mensagem sai sempre "Valve Relay 03 turned OFF", seja qual for a válvula. O "3" também está fixo nas duas mensagens. Imprima valveHere antes de zerar (ou tire essa linha) e tire o "3" fixo dos textos.

Toda vez que quero chamar esta função, uso:

      {
        int valveHere = valveRelay3;
        turnOffRelay (valveHere);
      }

O motivo de eu usar as {} é que eu tinha que declarar a variável local valveHere; assim eu podia substituir só aquele pedaço de código cada vez que chamava a função.

Tecnicamente, chamar essa função seria só ter este código aqui: turnOffRelay (valveHere); mas isso não funcionaria sozinho, porque estou sempre substituindo o pino do relé da válvula com int valveHere = valveRelay3;

Atenção: as {} e a variável local não são necessárias: o pino já vai como argumento, então só turnOffRelay(valveRelay3); faz a mesma coisa.

Ainda não testei o comportamento, mas pelo menos compila :-)

11 de junho de 2020

Gravei no ESP32 e o comportamento é inesperado. A função fica imprimindo sem parar. Acho que preciso devolver o estado de uma variável e não fiz isso. Vou tentar usar o código return variable; para fazer isso e depois testar, mas antes vou assistir de novo ao vídeo sobre funções para entender melhor.

13 de junho de 2020

Argh... OK, faz tempo que não atualizo. Bom, o último código que subi funciona e tenho algumas funções, mas ainda não estou satisfeito, porque funciona no Arduino mas não no PlatformIO. O que aprendi até agora é que a Arduino IDE faz muita coisa "por baixo dos panos", e no PlatformIO você precisa configurar tudo com mais detalhe.

Leia o seguinte:

• Tópico na comunidade do PlatformIO
• Documentação do PlatformIO

No fim consegui gravar um arquivo no SPIFFS usando o PlatformIO. Eu já conseguia fazer isso com o Arduino, mas sem entender direito como. Agora acho que talvez tenha entendido. Para fazer isso, tive que configurar o arquivo platformio.ini e a árvore de diretórios seguindo uma série de passos, então vamos ver:

1. Criei um novo arquivo de projeto na área da aba "projects" do PlatformIO
2. Depois criei uma pasta data no mesmo nível da pasta src. Outra opção é colocar no arquivo platformio.ini um caminho diferente para a pasta data.
3. Depois, com a placa conectada, rodei pio run -t uploadfs
4. Tive que tirar a biblioteca Time do PlatformIO, porque ela estava em conflito com a ESPAsyncWebServer, e foi aqui que encontrei a informação.

Funcionou.

Com isso comecei a entender como eu não sabia o que estava fazendo. O código com que comecei tinha o HTML dentro do sketch do Arduino. Isso me incomodava. Agora, com esse novo entendimento, consigo deixar o HTML separado do arquivo do sketch.

Depois encontrei este tutorial: ESP32 Web Server using SPIFFS

E este, caso eu queira usar o plugin da Arduino IDE para o upload.

Queria muito ter entendido isso melhor antes! Passei tantos dias nisso!

O código C++ até agora.

                    /****************************************************************************
                    *                                  Aknowledments                           * 
                    *                                  by LucioPGN                             * 
                    ****************************************************************************/
                   /*  Up to this date: 07th of June 2020 I don't consider myself a programer 
                    *  so I need to stand on top of giants sholders for my programing projects:
                    *  A Portion of this code was based on Rui Santos Code;
                    *  A Portion of this code was based on losely based Shakeels code for ESP8266;
                    *  A Portion of this code was based on several websites I lost track of....!
                    *  My contributions: 
                    *     -So far I made it work on platformio :), that took me quite a lot of time
                    *     -That means:
                    *        +created a new project;
                    *        +created a folder named data under the main folder (fabfarm_irrigation)
                    *        +linked the platformio.ini to the folder of the project + the data folder
                    *        +linked the needed libraries to their github repo in the platformio.ini
                    *        +found a conflict with time library and ESPAsyncWebserverLibrary can be solved by renaming time library or by removing it
                    *        +Made it work with a separate HTML file under the data folder using SPIFFS
                    *        +I can load the data to Spiffs inside platformio
                    *  Things I still want to program for my final project:
                    *    -so far I ported Shakeels code into ESP32;
                    *    -simplify the code creating functions rather than repeating the code;
                    *    -try to separate the HTML part for a cleaner code (this applies to maybe mix up the other previous code to this);
                    *    -Improve the appearance/Interface of the code
                    *    -Add readings to HTML
                    *    -Add a log of occurrences like over current
                    *    -Add more safety for the equipment
                    *    -Add a phone interface (APP)
                    *    -Add function to set current time
                    *    -Add renaming function to each relay so one can relate the relay to the area of interest or at least rename relays to actual areas of the farm.
                    * 
                    ****************************************************************************/
                    
                   
                   //Required Libraries
                   #include "WiFi.h"
                   #include "ESPAsyncWebServer.h"
                   #include "SPIFFS.h"
                   #include <AsyncTCP.h>
                   
                   // Network Credentials
                   const char* ssid = "rato";
                   const char* password = "imakestuff";
                   
                   //Start the Async Web Server listening on port 80
                   AsyncWebServer server(80);
                   
                   // Set to true to define Relay as Normally Open (NO)
                   #define RELAY_NO false
                   
                   // Set number of relays, will be used in the array
                   #define NUM_RELAYS  4
                   
                   // Assign each GPIO to a relay
                   int relayGPIOs[NUM_RELAYS] = {26, 25, 33, 32};
                   
                   //
                   const char* PARAM_INPUT_1 = "relay";  
                   const char* PARAM_INPUT_2 = "state";
                   
                   // Replaces placeholder with button section in your web page
                   String processor(const String& var){
                     //Serial.println(var);
                     if(var == "BUTTONPLACEHOLDER"){
                       String buttons ="";
                       for(int i=1; i<=NUM_RELAYS; i++){
                         String relayStateValue = relayState(i);
                         //Here parts of the HTML will be parsed to index.html like Relay # followed by its value in variable for the GPIO numbers
                         buttons+= "<h4>Turn on water on " + String(i) + "</h4><h4>Valve (relay) #" + String(i) + " - GPIO " + relayGPIOs[i-1] + "</h4><label class=\"switch\"><input type=\"checkbox\" onchange=\"toggleCheckbox(this)\" id=\"" + String(i) + "\" "+ relayStateValue +"><span class=\"slider\"></span></label>";
                       }
                       return buttons;
                     }
                     return String();
                   }
                   
                   String relayState(int valveRelayNum){
                     if(RELAY_NO){
                       if(digitalRead(relayGPIOs[valveRelayNum-1])){
                         return "";
                       }
                       else {
                         return "checked";
                       }
                     }
                     else {
                       if(digitalRead(relayGPIOs[valveRelayNum-1])){
                         return "checked";
                       }
                       else {
                         return "";
                       }
                     }
                     return "";
                   }
                   
                   void setup(){
                     // Serial port for debugging purposes
                     Serial.begin(9600);
                     // Initialize SPIFFS
                     if(!SPIFFS.begin(true)){
                       Serial.println("An Error has occurred while mounting SPIFFS");
                       return;
                     }
                     // Set all relays to off when the program starts - if set to Normally Open (NO), the relay is off when you set the relay to HIGH
                     for(int i=1; i<=NUM_RELAYS; i++){
                       pinMode(relayGPIOs[i-1], OUTPUT);
                       if(RELAY_NO){
                         digitalWrite(relayGPIOs[i-1], HIGH);
                       }
                       else{
                         digitalWrite(relayGPIOs[i-1], LOW);
                       }
                     }
                     
                     // Connect the ESP to the Wi-Fi using the credentials entered before
                     WiFi.begin(ssid, password);
                     while (WiFi.status() != WL_CONNECTED) {
                       delay(1000);
                       Serial.println("Connecting to WiFi..");
                     }
                   
                     // Print ESP32 Local IP Address
                     Serial.println(WiFi.localIP());
                   
                   /*
                   *Now we are going to configure the route where server will be listening for incoming HTTP requests 
                   and a function that will be executed when a request is received on that route.
                   We specify this by calling the "on" method on the server object. With server.on(){}; 
                   As first input, this method receives a string with the path where it will be listening. 
                   We are going to set it to listen for requests on the "/" route. This could be anything. 
                   It is basically what you write after the ip adress when in the browser or an APP.
                   This website has a great explanation of the ESP32 Arduino: Asynchronous HTTP web server
                   https://techtutorialsx.com/2017/12/01/esp32-arduino-asynchronous-http-webserver/
                   So... 
                   - First parameter here is: "/" thats the root directory.
                   - Second parameter is HTTP_GET thats an enum of type WebRequestMethod a method defined in the library here --> https://github.com/me-no-dev/ESPAsyncWebServer/blob/63b5303880023f17e1bca517ac593d8a33955e94/src/ESPAsyncWebServer.h
                   - Third parameter is a the function AsyncWebServerRequest
                   So there is this c++ lambda function used here. My litle understanding is that they are locally declared unamed function this means they dont have a name and are declared locally :-)
                    I don't grasp the concept fully haha.
                    the syntax is [captures](params){body} where in here [] is empity
                   */
                   
                     // Route for root / web page
                     server.on("/", HTTP_GET, [](AsyncWebServerRequest *request){
                       request->send(SPIFFS, "/index.html", String(), false, processor);
                     });
                   
            // Send a GET request to <ESP_IP>/update?relay=<inputMessage>&state=<inputMessage2>
             server.on("/update", HTTP_GET, [] (AsyncWebServerRequest *request) {
               String inputMessage;
               String inputParam;
               String inputMessage2;
               String inputParam2;
               // GET input1 value on <ESP_IP>/update?relay=<inputMessage>
               if (request->hasParam(PARAM_INPUT_1) & request->hasParam(PARAM_INPUT_2)) {
                 inputMessage = request->getParam(PARAM_INPUT_1)->value();
                 inputParam = PARAM_INPUT_1;
                 inputMessage2 = request->getParam(PARAM_INPUT_2)->value();
                 inputParam2 = PARAM_INPUT_2;
                 if(RELAY_NO){
                   Serial.print("NO ");
                   digitalWrite(relayGPIOs[inputMessage.toInt()-1], !inputMessage2.toInt());
                 }
                 else{
                   Serial.print("NC ");
                   digitalWrite(relayGPIOs[inputMessage.toInt()-1], inputMessage2.toInt());
                 }
               }
               else {
                 inputMessage = "No message sent";
                 inputParam = "none";
               }
               Serial.println(inputMessage + inputMessage2);
           
               //This is the last part of the lambda function. 
               //This method receives as first input the HTTP response code, which will be 200 in our case.  This is the HTTP response code for "OK".
               request->send_P(200, "text/plain", "OK");
             });
           
             // Start server here
             server.begin();
           }
           
           void loop(){
           
           }
        

Atenção: hasParam(PARAM_INPUT_1) & hasParam(PARAM_INPUT_2) usa o & bit a bit; o E lógico é &&. Com dois bool o resultado acaba sendo o mesmo, mas não faz curto-circuito, e o operador certo é &&.

Versão atual deste código (E-SPlash no GitHub)

O código HTML até agora.

<!DOCTYPE HTML><html>
<head>
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <style>
    html {font-family: Arial; display: inline-block; text-align: center;}
    h2 {font-size: 3.0rem;}
    p {font-size: 3.0rem;}
    body {max-width: 600px; margin:0px auto; padding-bottom: 25px;}
    .switch {position: relative; display: inline-block; width: 120px; height: 68px} 
    .switch input {display: none}
    .slider {position: absolute; top: 0; left: 0; right: 0; bottom: 0; background-color: #ccc; border-radius: 34px}
    .slider:before {position: absolute; content: ""; height: 52px; width: 52px; left: 8px; bottom: 8px; background-color: #fff; -webkit-transition: .4s; transition: .4s; border-radius: 68px}
    input:checked+.slider {background-color: #2196F3}
    input:checked+.slider:before {-webkit-transform: translateX(52px); -ms-transform: translateX(52px); transform: translateX(52px)}
  </style>
</head>
<body>
  <h2>Fab Farm Irrigation System</h2>
  %BUTTONPLACEHOLDER%
<script>function toggleCheckbox(element) {
  var xhr = new XMLHttpRequest();
  if(element.checked){ xhr.open("GET", "/update?relay="+element.id+"&state=1", true); }
  else { xhr.open("GET", "/update?relay="+element.id+"&state=0", true); }
  xhr.send();
}</script>
</body>
</html>
                

Versão atual deste código (E-SPlash no GitHub)

Ele está assim agora:

A aparência e o código agora são bem parecidos com os do site Random Nerd Tutorials, sobre relés controlados com o ESP32.

A principal diferença em relação ao código original é que ele roda no PlatformIO para VS Code e também usa uma estrutura de pastas separada para o arquivo HTML, que é gravado no SPIFFS do ESP.

14 de junho de 2020

Depois de toda essa descoberta pessoal, decidi que preciso começar o código do zero e usar só o algoritmo geral do sistema de irrigação atual instalado na fazenda. O motivo é que o código está bagunçado e repetitivo demais; as abordagens que encontrei nas fontes de ontem me fizeram perceber que é mais rápido adicionar as funcionalidades ao último código, uma por uma, do que recodificar tudo a partir do código que roda hoje na fazenda.

Hoje vou tentar adicionar informações atualizadas, como temperatura e umidade. Estou me baseando de novo no trabalho do Rui Santos, nesta página sobre uma estação meteorológica. Com essa abordagem acredito que também vou conseguir incluir a hora do dia usando um relógio RTC.

O esquema para ligar o DHT22 é do site dele:

Ele usa um resistor de 4,7k Ohm como pull-up.

Depois de um pouco de trabalho, a página está assim:

Acredito que a temperatura agora está negativa porque o sensor de temperatura e umidade está com defeito ou a minha fiação está meio frouxa. Acho que, quando eu fresar a minha própria placa e soldar tudo em vez de espetar numa protoboard, vai ficar mais confiável. De qualquer forma, estou recebendo os valores e consigo mostrá-los na interface web.

No monitor serial já consigo mostrar a hora da Internet e as informações da rede; agora preciso descobrir um jeito de pegar o valor da hora e mostrar na interface web. No momento estou mandando pelo código a palavra TESTE, e é ela que aparece no lugar da hora.

15 de junho de 2020

Hoje vou me concentrar em mostrar a hora na interface web e talvez criar uma função para ligar o relé num horário definido.

Atualização das 20:44:

- Depois de passar o dia inteiro tentando, consegui mostrar a hora da máquina e a hora do sistema de irrigação (ESP32).

Agora a interface está assim:

Quando eu crescer quero ser programador :-) e não passar um dia inteiro numa coisa que alguém resolve em poucas linhas!

O meu sofrimento acabou graças a um santo, com esta resposta no Stack Exchange.

Aqui está a função original postada lá:

void printLocalTime()
{
  time_t rawtime;
  struct tm timeinfo;
  if(!getLocalTime(&timeinfo))
  {
    Serial.println("Failed to obtain time");
   return;
  }
  char timeStringBuff[50]; //50 chars should be enough
  strftime(timeStringBuff, sizeof(timeStringBuff), "%A, %B %d %Y %H:%M:%S", &timeinfo);
  //print like "const char*"
  Serial.println(timeStringBuff);

  //Optional: Construct String object 
  String asString(timeStringBuff);
}

Com pequenas modificações, mudando de uma função void para uma função String e adicionando um return que chamei de "timeAsAString":

//this function was found here https://arduino.stackexchange.com/questions/52676/how-do-you-convert-a-formatted-print-statement-into-a-string-variable
//I did a minor change so instead of a void function it now returns a string to be used to show time in the webinterface
String printFarmTime()
{
  time_t rawtime;
  struct tm timeinfo;
  getLocalTime(&timeinfo);
  char timeStringBuff[50]; //50 chars should be enough
  strftime(timeStringBuff, sizeof(timeStringBuff), "%A, %B %d %Y %H:%M:%S", &timeinfo);
  //print like "const char*"
  Serial.println(timeStringBuff);

  //Construct to create the String object
  String timeAsAString(timeStringBuff);
  return timeAsAString;
}

Atenção: esta versão tirou a verificação if(!getLocalTime(&timeinfo)), então, se o NTP ainda não respondeu, ela formata uma hora vazia (lixo). Mantenha a verificação e devolva algo como "time not set" quando falhar.

Então, com isso resolvido, vou tentar criar as funções para ligar e desligar os relés de acordo com o horário programado. Vamos ver se consigo terminar hoje...

16 de junho de 2020

Não, não trabalhei nisso, eu estava cansado, então hoje fiz alguns esboços.

Neste esboço mostro como vai ser o formato da caixa e como vai ser a interface web também.

Também estou lendo sobre String e sobre a sua manipulação.

Eu poderia seguir a abordagem de dividir as datas como String e convertê-las para outros tipos de valor para as operações que pretendo fazer. Outra possibilidade é pegar os dados já no tipo de que preciso desde o começo; embora eu prefira a segunda, ainda não encontrei uma solução, porque ainda não entendo bem a função getLocalTime(). Então vou ler mais sobre ela agora.

Peraí... essa foi rápida! Encontrei um post que resolve o que eu preciso. Aqui está:

Post no Fórum do Arduino do usuário Abhay

Então me baseei no post acima para criar a função abaixo:

          
      int gimeTime(char what) {

          int OnlyYear;
          int onlyMonth;
          int onlyDay;
          int onlyHour;
          int onlyMin;
          int onlySec;
      
          struct tm timeinfo;
          if(!getLocalTime(&timeinfo)){
            Serial.println("Failed to obtain time");
            //return;
            }
          onlyHour = timeinfo.tm_hour;
          onlyMin  = timeinfo.tm_min;
          onlySec  = timeinfo.tm_sec;
          onlyDay = timeinfo.tm_mday;
          onlyMonth = timeinfo.tm_mon + 1;
          OnlyYear = timeinfo.tm_year +1900;
      
          switch (what) {
            case 1:
            return onlyHour;
            break;
            case 2:
            return onlyMin;
            break;
            case 3:
            return onlySec;
            break;
            default:
          // if nothing else matches, do the default
          // default is optional
          break;
          }
      }
    
    

Atenção: o default termina sem return, então a função devolve um valor indefinido para qualquer coisa que não seja 1, 2 ou 3 (ponha return -1; ali). O mesmo quando o getLocalTime() falha: com o return comentado, ela segue lendo um timeinfo sem hora válida.

É isso, agora finalmente posso trabalhar no código de agendamento dos timers. Aliás, passei quase o dia inteiro tentando um jeito mais simples de pegar os horários, mas simplesmente não consegui, porque estou penando para entender o tipo (struct). Bom, talvez eu volte a isso no futuro, mas por enquanto está bom.

17 de junho de 2020

Atualização de madrugada:

Estou muito frustrado; preciso passar para os átomos e fechar a parte dos bits do meu projeto.

Tarde da noite, o máximo que avancei foi fazer uma pequena função para desligar os relés; aqui está:

        int zoneStartStop (int zone, int startStop){
        int waitTime = 1000;
        if (startStop == 1){
        digitalWrite(relayGPIOs[zone], startStop);
        Serial.print("*** Zone Valve");
        Serial.print(zone);
        Serial.println("ON ***");
        delay(waitTime);
        digitalWrite(pumpGpio, startStop);
        Serial.print("*** Pump turned ON ***");
        }
        else{
        digitalWrite(pumpGpio, startStop);
        Serial.println("*** Pump turned OFF ***");
        delay(waitTime);
        digitalWrite(relayGPIOs[zone], startStop);
        Serial.print("*** Zone Valve");
        Serial.print(zone);
        Serial.println("OFF ***");
        }
        }

(Código corrigido depois: ao parar, agora a bomba desliga antes de a válvula fechar, para nunca empurrar contra a válvula fechada, e a mensagem diz OFF.)

É um começo, mas ainda não chegou lá, e eu ainda não testei.

Atualização da manhã:

Então agora vou olhar outro exemplo para programar um timer, de novo do Rui Santos; está aqui. Talvez eu consiga mudar um pouco, integrar ao meu código e adicionar um horário de início, e depois usar o slider para definir quantos minutos vai rodar. Isso já seria suficiente por enquanto!

Até agora deixei o código compatível com o PlatformIO e também separei o arquivo index.html do código C++ e coloquei numa pasta própria, para ser gravado pela rotina de gravação no SPIFFS que descrevi em 13/06/2020.