Secuencia de enjuagado para lavadora industrial no me funciona

Buenas, estoy haciendo un sistema de control para una lavadora, necesito hacer la secuencia de enjuagado y de lavado, tengo pensado hacerlo con millis, pero no he trabajado mucho con ello, hice un codigo pero no me funciona, la secuencia que necesito hacer es la siguiente:

//********* Secuencia de enjuagado: *********/////

// encender GIRO_FF por 10 segundos
// apagar GIRO_FF por 4 segundos
// encender GIRO_RW por 10 segundos
// apagar GIRO_RW por 4 segundos

// esa secuencia de los 4 pasos anteriores se deberá repetir por 5 minutos

a continuación el código que he hecho hasta ahora.

//Control de salidas

int APAGADO = 1;
int ENCENDIDO = 0;


// Variables de salidas

int LLENADO_FRIO1 = 12; // declaramos la variable SALIDA1 y le asignamos el pin 2
int LLENADO_FRIO2 = 11; // declaramos la variable SALIDA2 y le asignamos el pin 3
int LLENADO_CALIENTE = 10; // declaramos la variable SALIDA3 y le asignamos el pin 4
int DRENADO = 9; // declaramos la variable SALIDA4 y le asignamos el pin 5
int GIRO_FF = 8; // declaramos la variable SALIDA5 y le asignamos el pin 6
int GIRO_RW = 7; // declaramos la variable SALIDA6 y le asignamos el pin 7


// Variables de entrada

int OPCION_A = 6;
int OPCION_B = 5;
int START = 4;
int SENSOR_PUERTA = 3;
int SENSOR_NIVEL = 2;


// Variables de secuencia

int SA1;


// Variables para los millis

unsigned long t1;
unsigned long t2;
unsigned long t3;
unsigned long t4;

void setup() {

Serial.begin(115200);

//Configuracion de los pines de salida
  pinMode(LLENADO_FRIO1, OUTPUT);
  pinMode(LLENADO_FRIO2, OUTPUT);
  pinMode(LLENADO_CALIENTE, OUTPUT);
  pinMode(DRENADO, OUTPUT);
  pinMode(GIRO_FF, OUTPUT);
  pinMode(GIRO_RW, OUTPUT);


//Configuracion de los pines de entrada
  pinMode(START, INPUT);
  pinMode(OPCION_A, INPUT);
  pinMode(OPCION_B, INPUT);
  pinMode(SENSOR_PUERTA, INPUT);
  pinMode(SENSOR_NIVEL, INPUT);

  
// Inicializando las salidas
digitalWrite(LLENADO_FRIO1, APAGADO);
digitalWrite(LLENADO_FRIO2, APAGADO);
digitalWrite(LLENADO_CALIENTE, APAGADO);
digitalWrite(DRENADO, APAGADO);
digitalWrite(GIRO_FF, APAGADO);
digitalWrite(GIRO_RW, APAGADO);


SA1 = 0;

}

void loop() {


if ( (digitalRead(SENSOR_PUERTA) == HIGH) && (digitalRead(START) == HIGH) && (SA1 == 0) )

   {
     digitalWrite(LLENADO_FRIO1,ENCENDIDO);
     SA1 = 1;
   }

if ( (digitalRead(SENSOR_NIVEL) == HIGH) && (SA1 == 1) )
  {
  //digitalWrite(LLENADO_FRIO1,ENCENDIDO);
  delay(500);
  digitalWrite(LLENADO_FRIO1,APAGADO);
    SA1 = 2;
  }


//********* Secuencia de enjuagado: *********/////

// encender GIRO_FF por 10 segundos
// apagar GIRO_FF por 4 segundos
// encender GIRO_RW por 10 segundos
// apagar GIRO_RW por 4 segundos

// esa secuencia de los 4 pasos se debera repetir por 5 minutos

if ( (digitalRead(SENSOR_NIVEL) == HIGH) && (SA1 == 2) )
  {
   digitalWrite(GIRO_FF,ENCENDIDO);
   t1 = millis();
  }
   
   if (millis()-t1 >= 10000)
     {
      digitalWrite(GIRO_FF,APAGADO);
      t2 = millis();
     }
   

   if (millis()-t2 >= 4000)
     {
      digitalWrite(GIRO_RW,ENCENDIDO);
      t3 = millis();
     }
   

   if (millis()-t3 >= 10000)
     {
      digitalWrite(GIRO_RW,APAGADO);
      t4 = millis();
     }
   

 
  
//********* Fin de la Secuencia de enjuagado: *********/////


}

No se si ademas de millis sea mas facil usar otras sentencias, como un for por ejemplo, he intentado hacerlo y no se me ocurre como, porque el proceso lleva varios enjuagados, y la idea es replicar el primer codigo de la secuencia y usarlo para los otros, solo que modificando el tiempo que dura.

Muchas gracias, espero y puedan ayudarme a adelantar esta parte para continuar con el desarrollo.

Pues si, porque con los if es que no lo logro. prueba con whiles a ver si te vale.

//Control de salidas

int APAGADO = 1;
int ENCENDIDO = 0;


// Variables de salidas

int LLENADO_FRIO1 = 12; // declaramos la variable SALIDA1 y le asignamos el pin 2
int LLENADO_FRIO2 = 11; // declaramos la variable SALIDA2 y le asignamos el pin 3
int LLENADO_CALIENTE = 10; // declaramos la variable SALIDA3 y le asignamos el pin 4
int DRENADO = 9; // declaramos la variable SALIDA4 y le asignamos el pin 5
int GIRO_FF = 8; // declaramos la variable SALIDA5 y le asignamos el pin 6
int GIRO_RW = 7; // declaramos la variable SALIDA6 y le asignamos el pin 7


// Variables de entrada

int OPCION_A = 6;
int OPCION_B = 5;
int START = 4;
int SENSOR_PUERTA = 3;
int SENSOR_NIVEL = 2;


// Variables de secuencia

int SA1;


// Variables para los millis

unsigned long t1;
unsigned long t2;
unsigned long t3;
unsigned long t4;

void setup() {

  Serial.begin(115200);

  //Configuracion de los pines de salida
  pinMode(LLENADO_FRIO1, OUTPUT);
  pinMode(LLENADO_FRIO2, OUTPUT);
  pinMode(LLENADO_CALIENTE, OUTPUT);
  pinMode(DRENADO, OUTPUT);
  pinMode(GIRO_FF, OUTPUT);
  pinMode(GIRO_RW, OUTPUT);


  //Configuracion de los pines de entrada
  pinMode(START, INPUT);
  pinMode(OPCION_A, INPUT);
  pinMode(OPCION_B, INPUT);
  pinMode(SENSOR_PUERTA, INPUT);
  pinMode(SENSOR_NIVEL, INPUT);


  // Inicializando las salidas
  digitalWrite(LLENADO_FRIO1, APAGADO);
  digitalWrite(LLENADO_FRIO2, APAGADO);
  digitalWrite(LLENADO_CALIENTE, APAGADO);
  digitalWrite(DRENADO, APAGADO);
  digitalWrite(GIRO_FF, APAGADO);
  digitalWrite(GIRO_RW, APAGADO);


  SA1 = 0;

}

void loop() {


  if ( (digitalRead(SENSOR_PUERTA) == HIGH) && (digitalRead(START) == HIGH) && (SA1 == 0) )

  {
    digitalWrite(LLENADO_FRIO1, ENCENDIDO);
    SA1 = 1;
  }

  if ( (digitalRead(SENSOR_NIVEL) == HIGH) && (SA1 == 1) )
  {
    //digitalWrite(LLENADO_FRIO1,ENCENDIDO);
    delay(500);
    digitalWrite(LLENADO_FRIO1, APAGADO);
    SA1 = 2;
  }


  //********* Secuencia de enjuagado: *********/////

  // encender GIRO_FF por 10 segundos
  // apagar GIRO_FF por 4 segundos
  // encender GIRO_RW por 10 segundos
  // apagar GIRO_RW por 4 segundos

  // esa secuencia de los 4 pasos se debera repetir por 5 minutos

  if ( (digitalRead(SENSOR_NIVEL) == HIGH) && (SA1 == 2) ) {
    //temporizar 5 minutos
    t1 = millis();
    while (millis() - t1 <= 300000) {

      digitalWrite(GIRO_FF, ENCENDIDO);
      //temporizar 10seg
      t2 = millis();
      while (millis() - t2 <= 10000) {
        /* o no hago nada o llamo a funcion que haga halgo*/
      }
      //fin del delay 10seg

      digitalWrite(GIRO_FF, APAGADO);
      //temporizar 4seg
      t2 = millis();
      while (millis() - t2 <= 4000) {
        /* o no hago nada o llamo a funcion que haga halgo*/
      }
      //fin del delay 4seg

      digitalWrite(GIRO_RW, ENCENDIDO);
      //temporizar 10seg
      t2 = millis();
      while (millis() - t2 <= 10000) {
        /* o no hago nada o llamo a funcion que haga halgo*/
      }
      //fin del delay 10seg

      //temporizar 4seg
      digitalWrite(GIRO_FF, APAGADO);
      t2 = millis();
      while (millis() - t2 <= 4000) {
        /* o no hago nada o llamo a funcion que haga halgo*/
      }
      //fin del delay 4seg
    }
    //fin del delay 5 minutos
  }

  //********* Fin de la Secuencia de enjuagado: *********/////
}

Saludos.

hola @gonpezzi
Muchas gracias por tu aporte, sabes que lo corrí y el loop nunca se detiene, no se porque, pero probando y probando, cambie el primer while con millis, el de la secuencia de los 5 minutos por un for, y a modo de prueba lo ajuste a 1 minuto par no esperar tanto, y lo que hice fue lo siguiente, como la secuencia de encendido y apagado de los dos giros dura 28 segundos en total, que son 10+4+10+4 = 28 segundos, hice un for y lo repetí 2 veces, en total me da 56 segundos ( 4 segundos menos que el minuto), pero como las secuencias que voy a hacer de enjuagado se van a tardar entre 5 y 15 minutos, porque tenga unos segundos mas o menos no va a importar. así me quedo el código final:

//Control de salidas

int APAGADO = 1;
int ENCENDIDO = 0;


// Variables de salidas

int LLENADO_FRIO1 = 12; // declaramos la variable SALIDA1 y le asignamos el pin 2
int LLENADO_FRIO2 = 11; // declaramos la variable SALIDA2 y le asignamos el pin 3
int LLENADO_CALIENTE = 10; // declaramos la variable SALIDA3 y le asignamos el pin 4
int DRENADO = 9; // declaramos la variable SALIDA4 y le asignamos el pin 5
int GIRO_FF = 8; // declaramos la variable SALIDA5 y le asignamos el pin 6
int GIRO_RW = 7; // declaramos la variable SALIDA6 y le asignamos el pin 7


// Variables de entrada

int OPCION_A = 6;
int OPCION_B = 5;
int START = 4;
int SENSOR_PUERTA = 3;
int SENSOR_NIVEL = 2;


// Variables de secuencia

int SA1;


// Variables para los millis

unsigned long t1;
unsigned long t2;
unsigned long t3;
unsigned long t4;

void setup() {

Serial.begin(115200);

//Configuracion de los pines de salida
  pinMode(LLENADO_FRIO1, OUTPUT);
  pinMode(LLENADO_FRIO2, OUTPUT);
  pinMode(LLENADO_CALIENTE, OUTPUT);
  pinMode(DRENADO, OUTPUT);
  pinMode(GIRO_FF, OUTPUT);
  pinMode(GIRO_RW, OUTPUT);


//Configuracion de los pines de entrada
  pinMode(START, INPUT);
  pinMode(OPCION_A, INPUT);
  pinMode(OPCION_B, INPUT);
  pinMode(SENSOR_PUERTA, INPUT);
  pinMode(SENSOR_NIVEL, INPUT);

  
// Inicializando las salidas
digitalWrite(LLENADO_FRIO1, APAGADO);
digitalWrite(LLENADO_FRIO2, APAGADO);
digitalWrite(LLENADO_CALIENTE, APAGADO);
digitalWrite(DRENADO, APAGADO);
digitalWrite(GIRO_FF, APAGADO);
digitalWrite(GIRO_RW, APAGADO);


SA1 = 0;

}

void loop() {


if ( (digitalRead(SENSOR_PUERTA) == HIGH) && (digitalRead(START) == HIGH) && (SA1 == 0) )

   {
     digitalWrite(LLENADO_FRIO1,ENCENDIDO);
     SA1 = 1;
   }

if ( (digitalRead(SENSOR_NIVEL) == HIGH) && (SA1 == 1) )
  {
  //digitalWrite(LLENADO_FRIO1,ENCENDIDO);
  delay(500);
  digitalWrite(LLENADO_FRIO1,APAGADO);
    SA1 = 2;
  }


//********* Secuencia de enjuagado: *********/////

// encender GIRO_FF por 10 segundos
// apagar GIRO_FF por 4 segundos
// encender GIRO_RW por 10 segundos
// apagar GIRO_RW por 4 segundos

// esa secuencia de los 4 pasos se debera repetir por 5 minutos

if ( (digitalRead(SENSOR_NIVEL) == HIGH) && (SA1 == 2) ) {
    //temporizar 1 minutos
    
    for (int i=0; i <= 2; i++) {

      digitalWrite(GIRO_FF, ENCENDIDO);
      //temporizar 10seg
      t2 = millis();
      while (millis() - t2 <= 10000) {
        /* o no hago nada o llamo a funcion que haga halgo*/
      }
      //fin del delay 10seg

      digitalWrite(GIRO_FF, APAGADO);
      //temporizar 4seg
      t2 = millis();
      while (millis() - t2 <= 4000) {
        /* o no hago nada o llamo a funcion que haga halgo*/
      }
      //fin del delay 4seg

      digitalWrite(GIRO_RW, ENCENDIDO);
      //temporizar 10seg
      t2 = millis();
      while (millis() - t2 <= 10000) {
        /* o no hago nada o llamo a funcion que haga halgo*/
      }
      //fin del delay 10seg

      //temporizar 4seg
      digitalWrite(GIRO_RW, APAGADO);
      t2 = millis();
      while (millis() - t2 <= 4000) {
        /* o no hago nada o llamo a funcion que haga halgo*/
      }
      //fin del delay 4seg
    }
    //fin del delay 1 minutos
    
    digitalWrite(GIRO_FF, APAGADO);
    digitalWrite(GIRO_RW, APAGADO);
    SA1 = 3;

    
  }

  //********* Fin de la Secuencia de enjuagado: *********/////
}

Lo probe y me trabaja de maravilla, ya puedo temporizar las otras secuencias de lavado, simplemente aumentando las veces que corre el for, sacando la cuenta multiplicandolo cada 28 segundos y así tener un estimado del tiempo deseado.

Muchas gracias

Me alegro. Saludos

Buenas,

Me encuentro haciendo un proyecto para la automatización de una lavadora industrial con arduino, tiene varios pasos, como llenado de la tina, varios enjuagados, lavado, etc, etc. en total estos pasos duran entre 30 o 35 minutos en ejecutarse todos, ya hice el programa y me funciona de maravilla, pero me ha surgido un problema que no tome en cuenta, en el país donde yo vivo (Venezuela), hay muchos problemas con el servicio eléctrico, hay bajas de voltajes, cortes, etc. El problema que me ha surgido en el proyecto, es que cuando el sistema esta realizado las tareas, y hay una falla eléctrica, ya sea una baja de voltaje, o corte, el arduino se apaga y se enciende, por tal motivo pierde la secuencia de todo el proceso de trabajo que llevaba, es decir, comienza desde cero todo el proceso.

mi duda es la siguiente:

¿ De que forma puedo hacer que al momento que haya una falla de electricidad, y el arduino se reinicie, que el proceso continúe por donde quedo ?.

He pensado varias opciones, como por ejemplo, colocar un capacitor grande en la alimentación regulada, y poner en una entrada analógica la señal de alimentación principal, y cuando se detecte que esta falle, por el capacitor el arduino quedara encendido unos segundos, y en este tiempo que me guarde en la memoria EEPROM una variable que se vaya incrementando a lo largo de la ejecución del programa, no se si esto sera posible hacerlo porque nunca he trabajado con la memoria EEPROM del arduino. y así al momento en que arranque el microcontrolador, verifique el valor de esa variable, y así puede saber si esta arrancando desde cero, o fue que hubo una falla y pueda proseguir por el paso donde se quedo.

Otra opción que se me ocurre es hablar con mi cliente y que compre un UPS para que el sistema tenga respaldo al momento de un bajón de electricidad, aunque esto no es muy viable, primero porque incrementaría el costo del proyecto, y segundo, que si en vez de una baja de voltaje, hay un corte de luz, el sistema seguiría con la secuencia y no se ejecutaría en realidad porque la parte de potencia no esta operativa.

Agradezco alguien que se le haya presentado este inconveniente, o haya hecho algo parecido si me pudiera orientar a ver como puedo solucionar esto de forma sencilla, sin código complejo :stuck_out_tongue_winking_eye:.

Saludos a todos y muchas gracias.

La primer opción es muy acertada.
Busca acá mismo en el foro o en la web, que hay temas al respecto (incluso hay uno de hace pocos días).

Saludos

Humm... Muy grande deberia ser ese capacitor, yo haria una mezcla de las dos opciones, una pequeña ups con una lipo ESQUEMA, junto con un SENSOR AC de tal forma que al detectarse el corte de luz pones a dormir al arduino para optimizar la duracion de la bateria y al restablecerce el suministro electrico recuperas lo guardado en la eeprom y continuas con el programa.
saludos.

Moderador:
@iotaa ten cuidado cuano aùn tienes un hilo abierto con un tema similar y luego abres otro siguiendo con el problema en lineas generales.
Esto constituyo un doble posteo. Por esa razón uní los hilos.

Para mi la solucion gira en torno a detectar la falta de energía y eso lo puedes hacer fácilmente ya se como has dicho o bien con un optoacoplador que con cada cruce por cero le envie al pin 2 o 3 (interrupciones del Arduino UNO/NANO u otro en MEGA pq no se cual usas) un pulso. Ese pulso será cada 10 mseg en paises con 50 Hz y cada 18.3 mseg en paises con 60Hz. Asi que hablamos en el peor caso de 10 mseg para mantener la energía.
Podrias si quieres usar una especie de sistema de backup DC para el Arduino. Todo el tiempo cargas unas baterias las que alimentan el arduino, si se corta la energía no pasa nada porque sigue alimentado por las baterias solo que ahora no se recargan. Es el principio de las UPS online.
Ahora bien, tu sistema detecta a los 10 mseg que se cortó, guarda los datos en EEPROM y se preparara para la restauración. Tmb deberías llevar el tiempo de lavado y tener una máquina de estados donde sepas donde quedaste.
Hay muchas opciones. Para mi que el cliente compre una UPS que alimente todo me parece exagerado.