Arduino só funciona bem a primeira vez após compilação

[judson_celso]

Bom dia, boa tarde ou boa noite pessoal!
Estou precisando de uma ajuda de vocês da qual não sei se o problema pode ser no meu código ouse [e um problema fisico da minha placa. tenho uma UNO e uso ela como placa principal de uma maquina de lavar que eu recuperei. o problema é o seguinte, quando eu compilo e envio meu código para meu Arduino, assim que aperto o botão para iniciar a lavagem ele faz o processo todo corretamente, respeitando o tempo definido pelos delays, executando todos os panos definidos lo loop sem pular nenhum paco, o problema é que quando termina a lavagem ele volta para a tela principal e em teoria eu so precisaria apertar o botão para iniciar todo o processo novamente, ele até inicia, entretanto de forma incorreta exemplo: nao espera o tempo correto para para o deles de encher a maquina, parando cerca de 3 segundos após iniciar e já executando o processo de bater, as vezes enche e nao para de encher fazendo a água vazar, as vezes enche bate e nao executa o processo de centrifuga, etc.
Quando isso aconteceu a primeira vez por lógica até pensei em desligar tudo da tomada e ligar novamente para "limpar" o Arduino de energia fazendo tudo se reiniciar, porem isso nao funcionou. Para que eu bata novamente preciso ir com meu computador e compilar o código novamente para que na primeira tentativa consiga bater minas roupas kkkk
queria ajuda de vcs pois ja estou ficando cansado de ter que conectar meu computador na maquina toda vez que vou lavar as roupas rsrs vou colocar o meu código abaixo para que possam visualizar...

Obs.: Para garantir as questões autorais do código removi o código que estava com erro e coloquei o código após atualização, entretanto caso, por motivo de diretrizes do fórum, essa ação não seja permitida, tenho salvo a versão do código com erro. os moderadores podem me contactar por meios oficiais que faço a edição novamente.

#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <TimerOne.h>

//////////////////////////////////////////////////////////////////////////////////                            Codigo Maquina de Lavar                         //
//                      Desenvolvido por : Celso Judson T B Ferreira          //
//                                                                            //
//  Agradecimento aos úsuarios do forum arduino que auxiliaram na verificação //
//                         de erros durante o desenvolvimento:                //
//                                                                            //
//                           *    úsuario ruilviana                           //
//                                       e                                    //
//                           *    úsuario bubulindo                           //
//                                                                            //
//        É autorizado o uso deste código de forma pessoal, desde que:        //
//                * não seja utilizado para uso comercial sem                 //
//                 autorização por escrito do desenvolvedor                   //
//                                                                            //
//         * O nome do desenvolvedor e agradecidos sejam mantidos no          //
//      cabeçalho do código, das versões posteriores, da mesma maneira        //
//                          que consta neste código                           //
//                                                                            //
//          * O numero de distribuição deve manter o seguinte padrão,         //
//             formado pelo ome do desenvolvedor em formato numerico          //
//              e devera constar no codigo o nuvero da distribuição           //
//                                 usada como base                            //
//                                                                            //
//                                                                            //
//                                Versão: 1.0.1                               //
////////////////////////////////////////////////////////////////////////////////
//                      distribuição: 3512191510214191514                     //
////////////////////////////////////////////////////////////////////////////////                  


// Endereço I2C padrão do display 16x2
#define I2C_ADDRESS 0x27

// Pino do botões
#define BUTTON_PIN 10 // Pino do botão
// #define BUTTON_avanca 17
// #define BUTTON_volta 10
// #define BUTTON_mais 12
// #define BUTTON_menos 13
// #define BUTTON_inicia 11
 
 // Pinos do sensor nivel de agua
#define Nivel_Alto 11 // Pino do nivel de agua alto
#define Nivel_Medio 12 // Pino do nivel de agua medio
#define Nivel_Baixo 13 // Pino do nivel de agua baixo

// Pinos dos módulos de relé
#define pinRele1 8  // Porta do Arduino que irá acionar o relé 1 - motor 1 horario
#define pinRele2 9  // Porta do Arduino que irá acionar o relé 2 - motor 2 anti horario
#define pinRele3 7  // Porta do Arduino que irá acionar o relé 3 - valvula 1 - Pré lavagem
#define pinRele4 2  // Porta do Arduino que irá acionar o relé 4 - valvula 2 - Lavagem
#define pinRele5 3 // Porta do Arduino que irá acionar o relé 5 - valvula 3  - enxague amaciante
#define pinRele6 5  // Porta do Arduino que irá acionar o relé 6 - embreagem
#define pinRele7 6  // Porta do Arduino que irá acionar o relé 7 - bomba despejo
#define pinRele8 4 // Porta do Arduino que irá acionar o relé 8 - aquecimento

#define tempoContador  900    //define o tempo do contador (em segundos)



// Variaveis
int encher1 = 100;//360000;
int tela = 1;
int c1 = 0;
int tempo = tempoContador;
int tempo2 = 225;
int contador = 0;
int contadorbate = 0;
byte contadorStatus = 0; //0=Pause, 1=Run
int controle = 0;
int valoragua = 2;
int valorbotao;
int contadormolho = 0;
int vezesmolho = 4;
long tempoanterior;
long tempobater = 1000;
int tempobater2 = 1000;
int controleenche=0;

// Inicializa o objeto LiquidCrystal_I2C
LiquidCrystal_I2C lcd(I2C_ADDRESS, 16, 2);


void setup()
{

    // Inicializa o display
    lcd.init(); // inicia o display 16x2
    lcd.backlight();
    lcd.clear();                      // limpa todos os caracteres do lcd
    lcd.setCursor(0, 0);              // posiciona o cursor no display (caracter, linha)
    lcd.print(F("Lavadora"));         // imprime o texto entre aspas
    lcd.setCursor(0, 1);              // posiciona o cursor no display (caracter, linha)
    lcd.print(F("inicializando...")); // imprime o texto entre aspas
    delay(5000);                      // pausa o programa por 5 segundos
    lcd.clear();
    lcd.noBacklight();
    delay(1000);
    lcd.backlight();




    // Inicializa terminal serial
    Serial.begin(9600); // INICIALIZA A SERIAL COM TAXA DE 9600 BAUDS




    // Inicializa os botões e sensor de agua


    pinMode(BUTTON_PIN, INPUT_PULLUP);
    // pinMode(BUTTON_avanca, INPUT);
    // pinMode(BUTTON_volta, INPUT_PULLUP);
    // pinMode(BUTTON_mais, INPUT_PULLUP);
    // pinMode(BUTTON_menos, INPUT_PULLUP);
    // pinMode(BUTTON_inicia, INPUT_PULLUP);
    pinMode(Nivel_Alto, INPUT);
    pinMode(Nivel_Medio, INPUT);
    pinMode(Nivel_Baixo, INPUT);



    //INICIO DO TIMER
    Timer1.initialize(1000000);   //TIMER IRA EXECUTAR A CADA 1 SEGUNDO (PARAMETRO EM MICROSEGUNDOS)
    Timer1.attachInterrupt(contaTempo);



    // Inicializa os pinos dos relés como saída
    pinMode(pinRele1, OUTPUT);
    digitalWrite(pinRele1, LOW);
    pinMode(pinRele2, OUTPUT);
    digitalWrite(pinRele2, LOW);
    pinMode(pinRele3, OUTPUT);
    digitalWrite(pinRele3, LOW);
    pinMode(pinRele4, OUTPUT);
    digitalWrite(pinRele4, LOW);
    pinMode(pinRele5, OUTPUT);
    digitalWrite(pinRele5, LOW);
    pinMode(pinRele6, OUTPUT);
    digitalWrite(pinRele6, LOW);
    pinMode(pinRele7, OUTPUT);
    digitalWrite(pinRele7, LOW);
    pinMode(pinRele8, OUTPUT);
    digitalWrite(pinRele8, LOW);
}


void contaTempo() {
  if (contadorStatus == 1) { 
     contador--;

     if (contador <= 0) {
        contador = 0;
        contadorStatus = 0;
     }
  }
}

void tela1(int tela) {
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Fun.: ");
  lcd.print("Normal");
  lcd.setCursor(0, 1);
  lcd.print("Nivel: ");
  lcd.print("Alto");
  delay(500);
}


void encher()
{
  int estado_baixo=digitalRead(Nivel_Baixo); // Realiza a leitura do estado do botão
  int estado_medio=digitalRead(Nivel_Medio); // Realiza a leitura do estado do botão
  int estado_alto=digitalRead(Nivel_Alto); // Realiza a leitura do estado do botão

  controleenche = 1;
    lcd.setCursor(0, 0);
    lcd.print("Em funcionamento");
    lcd.setCursor(0, 1);
    lcd.print("    Enchendo    ");


while (controleenche == 1) {

    if (valoragua == 1)
    {
        while (estado_baixo == LOW) {
          estado_baixo=digitalRead(Nivel_Baixo);
          digitalWrite(pinRele4, HIGH);
        }
        digitalWrite(pinRele4, LOW);
        controleenche =0;
    }

    if (valoragua == 2)
    {
        while (estado_medio == LOW) {
          estado_medio=digitalRead(Nivel_Medio);
          digitalWrite(pinRele4, HIGH);
        }
        digitalWrite(pinRele4, LOW);
        controleenche =0;
    }

    if (valoragua == 3)
    {
        while (estado_alto == LOW) {
          estado_alto=digitalRead(Nivel_Alto);
          digitalWrite(pinRele4, HIGH);
        }
        digitalWrite(pinRele4, LOW);
        controleenche  =0;
    }
}
}

void despeja()
{
    lcd.setCursor(0, 0);
    lcd.print("Em funcionamento");
    lcd.setCursor(0, 1);
    lcd.print("   Esvaziando   ");
    digitalWrite(pinRele7, LOW);
    delay(480000);
    digitalWrite(pinRele7, HIGH);
    Serial.print("tela - enche  ");
}

void Centrifulga()
{
    lcd.setCursor(0, 0);
    lcd.print("Em funcionamento");
    lcd.setCursor(0, 1);
    lcd.print("  centrifulga   ");
    //enchr


    digitalWrite(pinRele5, LOW);
    delay(450000);
    digitalWrite(pinRele5, HIGH);
    bater();
    delay(450000);
    digitalWrite(pinRele6, LOW);
    digitalWrite(pinRele7, LOW);
    delay(450000);    
while (c1 < 5){
    delay(80000);
    digitalWrite(pinRele1, HIGH);
    delay(100000);
    digitalWrite(pinRele1, LOW);
    delay(80000);
    c1++;
}
    digitalWrite(pinRele7, HIGH);
    digitalWrite(pinRele6, HIGH);
}




void enxague()
{

  //enche enxague
  int estado_baixo=digitalRead(Nivel_Baixo); // Realiza a leitura do estado do botão
  int estado_medio=digitalRead(Nivel_Medio); // Realiza a leitura do estado do botão
  int estado_alto=digitalRead(Nivel_Alto); // Realiza a leitura do estado do botão

  controleenche = 1;
    lcd.setCursor(0, 0);
    lcd.print("Em funcionamento");
    lcd.setCursor(0, 1);
    lcd.print("    Enchendo    ");


while (controleenche == 1) {

    if (valoragua == 1)
    {
        while (estado_baixo == LOW) {
          estado_baixo=digitalRead(Nivel_Baixo);
          digitalWrite(pinRele4, HIGH);
        }
        digitalWrite(pinRele4, LOW);
        controleenche =0;
    }

    if (valoragua == 2)
    {
        while (estado_medio == LOW) {
          estado_medio=digitalRead(Nivel_Medio);
          digitalWrite(pinRele4, HIGH);
        }
        digitalWrite(pinRele4, LOW);
        controleenche =0;
    }

    if (valoragua == 3)
    {
        while (estado_alto == LOW) {
          estado_alto=digitalRead(Nivel_Alto);
          digitalWrite(pinRele4, HIGH);
        }
        digitalWrite(pinRele4, LOW);
        controleenche  =0;
    }
}

  //agita enxague
      if (tempo > 0) {
         if (contadorStatus == 0) {

           if (contador == 0) {
              contador = tempo2; 
           }

            //INICIA O CONTADOR NOVAMENTE
            Timer1.start();
            Timer1.attachInterrupt(contaTempo);
            contadorStatus = 1; 
         } else {

            //PARA O CONTADOR
            Timer1.stop();
            contadorStatus = 0; 
         }
      }
    

     if (contadorStatus == 1) { 
        while (contadorStatus == 1) {
            lcd.setCursor(0, 1);
            lcd.print("    Agitacao    ");
            static bool estad = HIGH;
            if (millis()>=tempoanterior+tempobater){
            tempoanterior = millis();
            estad = !estad;
            digitalWrite(pinRele1, estad);
            digitalWrite(pinRele2, !estad);
            }
        }
      }
    

      else {
        digitalWrite(pinRele1, LOW);
        digitalWrite(pinRele2, LOW);
    
      }

      despeja();

 //enche amaciante
 // int estado_baixo=digitalRead(Nivel_Baixo); // Realiza a leitura do estado do botão
 // int estado_medio=digitalRead(Nivel_Medio); // Realiza a leitura do estado do botão
 // int estado_alto=digitalRead(Nivel_Alto); // Realiza a leitura do estado do botão

  controleenche = 1;
    lcd.setCursor(0, 0);
    lcd.print("Em funcionamento");
    lcd.setCursor(0, 1);
    lcd.print("    Enchendo    ");


while (controleenche == 1) {

    if (valoragua == 1)
    {
        while (estado_baixo == LOW) {
          estado_baixo=digitalRead(Nivel_Baixo);
          digitalWrite(pinRele5, HIGH);
        }
        digitalWrite(pinRele5, LOW);
        controleenche =0;
    }

    if (valoragua == 2)
    {
        while (estado_medio == LOW) {
          estado_medio=digitalRead(Nivel_Medio);
          digitalWrite(pinRele5, HIGH);
        }
        digitalWrite(pinRele5, LOW);
        controleenche =0;
    }

    if (valoragua == 3)
    {
        while (estado_alto == LOW) {
          estado_alto=digitalRead(Nivel_Alto);
          digitalWrite(pinRele5, HIGH);
        }
        digitalWrite(pinRele5, LOW);
        controleenche  =0;
    }
}


//agita amaciante
      if (tempo > 0) {
         if (contadorStatus == 0) {

           if (contador == 0) {
              contador = tempo2; 
           }

            //INICIA O CONTADOR NOVAMENTE
            Timer1.start();
            Timer1.attachInterrupt(contaTempo);
            contadorStatus = 1; 
         } else {

            //PARA O CONTADOR
            Timer1.stop();
            contadorStatus = 0; 
         }
      }
    

     if (contadorStatus == 1) { 
        while (contadorStatus == 1) {
            lcd.setCursor(0, 1);
            lcd.print("    Agitacao    ");
            static bool estad = HIGH;
            if (millis()>=tempoanterior+tempobater){
            tempoanterior = millis();
            estad = !estad;
            digitalWrite(pinRele1, estad);
            digitalWrite(pinRele2, !estad);
            }
        }
      }
    

      else {
        digitalWrite(pinRele1, LOW);
        digitalWrite(pinRele2, LOW);
    
      }
}



void PreLavagem()
{

  //enche pre-lavagem
  int estado_baixo=digitalRead(Nivel_Baixo); // Realiza a leitura do estado do botão
  int estado_medio=digitalRead(Nivel_Medio); // Realiza a leitura do estado do botão
  int estado_alto=digitalRead(Nivel_Alto); // Realiza a leitura do estado do botão

  controleenche = 1;
    lcd.setCursor(0, 0);
    lcd.print("Em funcionamento");
    lcd.setCursor(0, 1);
    lcd.print("    Enchendo    ");


while (controleenche == 1) {

    if (valoragua == 1)
    {
        while (estado_baixo == LOW) {
          estado_baixo=digitalRead(Nivel_Baixo);
          digitalWrite(pinRele3, HIGH);
        }
        digitalWrite(pinRele3, LOW);
        controleenche =0;
    }

    if (valoragua == 2)
    {
        while (estado_medio == LOW) {
          estado_medio=digitalRead(Nivel_Medio);
          digitalWrite(pinRele3, HIGH);
        }
        digitalWrite(pinRele3, LOW);
        controleenche =0;
    }

    if (valoragua == 3)
    {
        while (estado_alto == LOW) {
          estado_alto=digitalRead(Nivel_Alto);
          digitalWrite(pinRele3, HIGH);
        }
        digitalWrite(pinRele3, LOW);
        controleenche  =0;
    }
}

  //agita pre-lavagem
    while(contadormolho < vezesmolho) {
      if (tempo > 0) {
         if (contadorStatus == 0) {

           if (contador == 0) {
              contador = tempo2; 
           }

            //INICIA O CONTADOR NOVAMENTE
            Timer1.start();
            Timer1.attachInterrupt(contaTempo);
            contadorStatus = 1; 
         } else {

            //PARA O CONTADOR
            Timer1.stop();
            contadorStatus = 0; 
         }
      }
    

     if (contadorStatus == 1) { 
        while (contadorStatus == 1) {
            lcd.setCursor(0, 1);
            lcd.print("    Agitacao    ");
            static bool estad = HIGH;
            if (millis()>=tempoanterior+tempobater){
            tempoanterior = millis();
            estad = !estad;
            digitalWrite(pinRele1, estad);
            digitalWrite(pinRele2, !estad);
            }
        }
        digitalWrite(pinRele1, LOW);
        digitalWrite(pinRele2, LOW);
      }
      else {
        digitalWrite(pinRele1, LOW);
        digitalWrite(pinRele2, LOW);
    
      }
            lcd.setCursor(0, 1);
            lcd.print("     Molho     ");
            delay(900000);
          contadormolho ++;
    }
}


void bater()
{
    lcd.setCursor(0, 0);
    lcd.print("Em funcionamento");
    lcd.setCursor(0, 1);
    lcd.print("   Lavando     ");
      Serial.print("tela - enche  ");

      if (tempo > 0) {
         if (contadorStatus == 0) {

           if (contador == 0) {
              contador = tempo; 
           }

            //INICIA O CONTADOR NOVAMENTE
            Timer1.start();
            Timer1.attachInterrupt(contaTempo);
            contadorStatus = 1; 
         } else {

            //PARA O CONTADOR
            Timer1.stop();
            contadorStatus = 0; 
         }
      }


   if (contadorStatus == 1) { 
      while (contadorStatus == 1) {
        lcd.setCursor(0, 1);
        lcd.print("   Lavando     ");
            static bool estad = HIGH;
            if (millis()>=tempoanterior+tempobater){
            tempoanterior = millis();
            estad = !estad;
            digitalWrite(pinRele1, estad);
            digitalWrite(pinRele2, !estad);
            }
      }

   } else {
      digitalWrite(pinRele1, LOW);
      digitalWrite(pinRele2, LOW);
    
}
}




void loop() {
Serial.print(controle);

    // === Ações no display LCD === //
  if (controle == 0)  
    { // se a variável tela for igual a 1w, faça...
    tela1(tela);
    }

    else if (controle == 1)
    {
       PreLavagem();
       despeja();
       controle ++;
       
    }
    else if (controle == 2)
    {   
        encher();     
        bater();
        delay(500);
        controle ++;
    }
    else if (controle == 3)
    {
        despeja();
        delay(500);
        controle ++;
    }
    else if (controle == 4)
   {
        enxague();
        delay(900000);
        despeja();
        controle ++;
    }
        else if (controle == 5)
    {
    
        Centrifulga();
        despeja();
        delay(5000);
        controle = 0;
    }
    

   /////////////////////////////////////////////////
    //            Verifica o estado do botão       //
    /////////////////////////////////////////////////

  
    int buttonState = digitalRead(BUTTON_PIN);




    if (buttonState == LOW)
    {
        if (controle >=6)
        {
            controle = 0;
        }
        else
        {
            controle ++;
        }
    }
  }

[bubulindo]

O uqe descreves parece ter a ver com variáveis que não são reinicializadas após a lavagem e continuam de onde foram deixadas.

Por exemplo, a tua função Centrifuga faz uso da variável c1 que não é inicializada dentro da função... isto quer dizer que da primeira vez que correste o programa ele corre bem, mas depois começa de onde ficou... que neste caso seria acima de 3.

Depois mexes com o timer dentro das funções, isto pode estar a desligá-lo. Usares o millis é muito, muito mais simples.

O teu contaTempo devia ser implementado com o millis() para ser mais fiável, na minha opinião e mais simples.

[ruilviana]

@judson_celso
vamos separar seu problemas em partes. (Chamo isso de processo JACK).

Parte1

@judson_celso

entretanto de forma incorreta exemplo: nao espera o tempo correto para para o deles de encher a maquina, parando cerca de 3 segundos após iniciar e já executando o processo de bater, as vezes enche e nao para de encher fazendo a água vazar, as vezes enche bate e nao executa o processo de centrifuga, etc.

Após completar o ciclo, uma nova lavagem não obedece a sequencia programada.

Isto parece que é como o @bubulindo explicou,
Variáveis não inicializadas contém valores diversos dos iniciais e fazem a programação da maquina parecer errada.

Parte2

@judson_celso

desligar tudo da tomada e ligar novamente para "limpar" o Arduino de energia fazendo tudo se reiniciar, porem isso nao funcionou. Para que eu bata novamente preciso ir com meu computador e compilar o código novamente para que na primeira tentativa consiga bater minas roupas kkkk

Esta parte me parece ser um problema da sua placa ou da sua fonte de alimentação,
(a fonte de alimentação também pode afetar a parte1).

Poste o seu esquemático mesmo feito a mão livre e informe qual é a fonte de alimentação do seu projeto.

PS: A vida é mesmo engraçada.
Estava aqui estudando seu codigo quando a minha esposa veio e falou: " A maquina de lavar parou de funcionar"

PS2: Resolvido. Entupimento de algo estranho antes da bomba que tira agua da maquina.

[judson_celso]

então galera eu fiz um esquema aqui mais ou menos, a numeração da porta digital do esquema não esta a ligação correta, a ligação esta correspondendo perfeitamente com o código. quanto a fonte, vi um video que dizia que não poderia usar uma fonte com mais de 5 volts na porta VIN do Arduino, como estou usando essa conexão para a alimentação dele acabei usando um carregador de celular mesmo ele é 4v - 1am se não me engano (ou aproximadamente isso. tratasse de um carregador original da Motorola.

Não sei se vão conseguir entender mas o esquema que estou usando é esse. os relés 7 e 8 não estão sendo utilizados

[judson_celso]

@ruilviana

@judson_celso
vamos separar seu problemas em partes. (Chamo isso de processo JACK).

Parte1

@judson_celso

entretanto de forma incorreta exemplo: nao espera o tempo correto para para o deles de encher a maquina, parando cerca de 3 segundos após iniciar e já executando o processo de bater, as vezes enche e nao para de encher fazendo a água vazar, as vezes enche bate e nao executa o processo de centrifuga, etc.

Após completar o ciclo, uma nova lavagem não obedece a sequencia programada.

Isto parece que é como o @bubulindo explicou,
Variáveis não inicializadas contém valores diversos dos iniciais e fazem a programação da maquina parecer errada.

Parte2

@judson_celso

desligar tudo da tomada e ligar novamente para "limpar" o Arduino de energia fazendo tudo se reiniciar, porem isso nao funcionou. Para que eu bata novamente preciso ir com meu computador e compilar o código novamente para que na primeira tentativa consiga bater minas roupas kkkk

Esta parte me parece ser um problema da sua placa ou da sua fonte de alimentação,
(a fonte de alimentação também pode afetar a parte1).

Poste o seu esquemático mesmo feito a mão livre e informe qual é a fonte de alimentação do seu projeto.

PS: A vida é mesmo engraçada.
Estava aqui estudando seu codigo quando a minha esposa veio e falou: " A maquina de lavar parou de funcionar"

PS2: Resolvido. Entupimento de algo estranho antes da bomba que tira agua da maquina.

Menos mal que não chegou a ponto do meu kkkk apesar que achei interessante a ideia de colocar o Arduino na maquina pois já tenho projetos de depois integrar um esp01 para controla-la via internet rsrsrs

[ruilviana]

@judson_celso

acabei usando um carregador de celular mesmo ele é 4v - 1am

Acho que seu problema principal está na fonte.
4V para um arduino de 5V é 20% a menos e pode torna-lo instável.

Consiga um fonte de 5V e pelo menos 2 A, faça um novo teste e conte pra gente o resultado.
A bobina de cada rele deste pode consumir até 100mA, então se 5 deles estiverem ativos, sobra quase nada para o arduino.

[judson_celso]

todas as variáveis que eu criei eu defini lá no inicio do código. Sei que enquanto a maquina estiver funcionando ela vai ficar rodando apenas o void (loop) e entendi que por isso as variáveis não serão reiniciadas. Acham que se eu copiar as linhas que as defini la em cima e colar no fim do processo de lavagem dentro do void(loop) isso seria o suficiente para reiniciar o valor destas variáveis?

[judson_celso]

entendi, uma coisa que esqueci de mencionar é que no caso do motor não estou usando o modulo rele convencional e sim dois reles de estado solido de 45amp. (vou colocar uma foto pra verem qual o modelo).
Aproveitando, qual a voltagem máxima de entrada suportada pelo Arduino na porta VIN e co conector DC? pq normalmente uso umas peças de descarte e tenho algumas fontes aqui, então quero ver se consigo usar alguma das que já tenho...

[ruilviana]

O seu modulo de rele é para que voltagem?
Pode postar um link mostrando ele?

[ruilviana]

Esta é a parte de power do arduino.
Vou falar sobre ela:
No circulo vermelho voce tem a entrada de power pelo conector DC (Preto) .
Em laranja tem a entra Vin.]Em rosa tem o regulador para fornecer 5V ao arduino.
E em verde tem o regulador para fornecer 3.3 V.

[judson_celso]

editei aqui e coloquei foto na anterior. etano uso dois desse so pra fazer o acionamento no motor, pois o rele convencional não da cota devido ao alto aquecimento do contato. aLem desses dois que fazem apenas o controle do motor tenho um modulo rele convencional de 6 saídas que utilizo para o controle dos outros itens (embreagem, válvulas e bomba de despejo)
eu não encontrei uma fonte como a que voce sugeriu, porem achei outro carregador de celular (esse 5v 2.1A) acha que se eu incluir este carregador deixando-o exclusivamente para alimentação do Arduino e deixar o outro para alimentação dos reles e display, resolveria o problema de baixa alimentação?

[ruilviana]

Continuando.
no seu projeto voce fornece 4V na entrada Vin do seu UNO.
Mas logo após a entrada tem um regulador para fornecer 5V ao arduino.
Este regulador recebendo 4V não funciona corretamente.
Segundo o datasheet dele, é necessário pelo menos 7V na entrada dele para que ele forneça corretamente os 5V na saída.
CUIDADO a entrada Vin não é protegida contra inversão de polaridade mas a entrada DC é protegida.
Veja o diodo D1 protegendo.

[ruilviana]

Não vai funcionar, desculpe, pois pensei que voce estava usando a entrada de 5V do arduino.
Se for usar 5V tem que usar o pino 5V do arduino e não Vin.
No vin precisa de pelo menos 7V.
Veja a minha descrição sobre Vin.

[judson_celso]

Pelo que intendi do esquema (me corrija se estiver errado, pois aprendi basicamente sozinho a eletrônica rsrs) a entrada na vim e no dc podem possuem a mesma faixa de entrada, pois estão na mesma linha antes do regulador de 5v, a única diferença é que existe um diodo antes do dc para impedir retorno de corrente e um capacitor de 47u.já o vin entra basicamente direto no regulador sem passar por capacitor ou diodo... certo???

[judson_celso]

como o carregador (o novo) transforma a rede que é alternada (127v) em continua (5 v 2.1A) se eu fizer como falei, mas colocar ele ligado no pino 5v do Arduino ao invés do vin daria certo (tomando os cuidados de conectar o positivo no 5v e o negativo no gnd)?

[judson_celso]

se eu tirar um diodo qualquer de uma placa de sucata e colocar entre fio do carregador e o pino 5v do Arduino ele me daria essa proteção contra retorno de corrente? isso seria viável?

[judson_celso]

fiz a seguinte alteração e estou fazendo os testes neste momento: deixei a fonte de celular para alimentar apenas o display e os módulos rele, cortando o fio que enviava energia para o pino vin da placa Arduino, peguei uma fonte que achei (12v 3A) e conectei no dc do Arduino deixando esta nova fonte para alimentação exclusiva do Arduino. No código copiei as definições das variáveis para dentro de tela 1, ou seja, sempre que ele termina o processo de lavagem volta automaticamente pra tela 1 (isso já funcionava e era uma das poucas coisas que não estava dando problema) com essa definição sempre que a tela voltar para tela 1 as variáveis vão voltar para os valores originais.
Caso essas modificações funcionem aviso aqui.
Aproveitando so mais uma pergunta, vcs acham que caso essa fonte 12v seja suficiente, eu poderia utilizar o pino 5v do Arduino para alimentar o display e modulo rele ou o regulador de tenção não disponibiliza uma amperagem boa para o consumo de todos estes modelos?

[ruilviana]

A fonte de 12V para o arduino pode funcionar, mas o regulador NCP1117 poderá esquentar muito devido a relação de potencia.
Na entrada 12V na saída 5V então teremos uma queda de 7V sobre o regulador.
E por exemplo se a corrente consumida for de 500mA, então teremos 7* 0,5 = 3.5W
de calor sendo dissipado sobre o regulador, o que é muito.
Sugiro fontes de 7 a 9 V.

[ruilviana]

@judson_celso

se eu tirar um diodo qualquer de uma placa de sucata e colocar entre fio do carregador e o pino 5v do Arduino ele me daria essa proteção contra retorno de corrente? isso seria viável?

Sim, mas haverá uma queda de voltagem de +- 0,7V no diodo, então voce terá 4,3V no arduino

[judson_celso]

coloquei com as duas fontes e continuou dando erro, coloquei a maquina para bater hoje cedo e fui para o serviço cheguei agora a tarde e ela tava jorrando agua, quase inundou minha casa kkk. eu estou achado estranho pq pelo que estou percebendo é o tempo dos delays que parece que não está contando.
exemplo:

digitalWrite(pinRele4, LOW);
Serial.print("tela - enche  ");
delay(550000);
digitalWrite(pinRele4, HIGH);

nessa parte ele teria que ligar o pinRele4 que é um rele de válvula de entrada de agua, aguardar os 550000 ms e desligar o rele, fazendo com que pare de encher a maquina. Acontece que ele liga o rele e nao desliga mais nem passa pro próximo passo.