
#include <Wire.h>                      // needed for LCD with PCF8574 port expander
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd (0x27,20,4);

int entragua;
int batea1;
int batea2;
byte tempera;
int ib=0;
int vandera [4];

////

void setup(){



Serial.begin(9600);
pinMode(13, OUTPUT); ///RESISTENCIA
pinMode(23, OUTPUT); 
pinMode(25, OUTPUT);
pinMode(27, OUTPUT);
pinMode(29, OUTPUT);
pinMode(22, OUTPUT);
pinMode(24, OUTPUT);
pinMode(26, OUTPUT);
pinMode(28, OUTPUT);
pinMode(12, INPUT);
pinMode(A7, INPUT);
pinMode(A14, INPUT);


//--------estado inicial


digitalWrite(13, LOW);
digitalWrite(23, LOW);
digitalWrite(25, LOW);
digitalWrite(27, LOW);
digitalWrite(29, LOW);
digitalWrite(22, LOW);
digitalWrite(24, LOW);
digitalWrite(26, LOW);
digitalWrite(28, LOW);
digitalWrite(12; LOW);



lcd.init();
lcd.backlight();
lcd.clear();
lcd.setCursor(0,0);
lcd.print("ESTADO OFF");
lcd.setCursor(0,1);
lcd.print("TRESQUINCELAB");

}
//------------------------


void loop() {

  byte selector = analogRead(A7);
  Serial.println(selector);



  if (selector >= 30 and selector <=70)Programauno();
  else if (selector >= 160 and selector <=220)Programados();
  else if (selector >= 10 and selector <=29)Programados();


}


void Programauno() {

  if( vandera [1]==0){
  Serial.println("Programa C41 ");
  lcd.clear();
  lcd.setCursor(0,0);
  lcd.print("PROGRAMA C41       ");
  lcd.setCursor(0,1);
  lcd.print("TRESQUINCELAB")
  delay(20000);

  Llenaragua (1);
  delay(5000);
  Tanquec41(1);
  delay(5000);
  desagotec41(1);
  delay(5000);
  Enjuague1(1);
  delay(5000);
  desagote(1);
  delay(5000);  
  Tanquebleach(1);
  delay(5000);
  desagotebleach(1);
  delay(5000);
  Enjuague2(1);
  delay(5000);
  desagote(1);
  delay(5000);  
  tanquefix(1);
  delay(5000);
  desagotefix(1);
  delay(5000)
  Enjuague3(1);
  delay(5000);  
  desagote()


  vandera[1]=1;
  lcd.clear();
  lcd.setCursor(1,0);
  lcd.print("PROCESO TERMINADO");
  lcd.setCursor(4,1);
  lcd.Print("SACAR ROLLOS");

  }


}


void llenaragua(int llena){

  if (ib = 0){


    for(; ib<llena; ib++){
      if digitalRead(12==HIGH)
      serial.print("ENTRADA DE AGUA:   ");
      serial.println(ib);
      pecera = digitalRead(12);
      lcd.clear;
      lcd.setCursor(0,0);
      lcd.print("ENTRADA DE AGUA");
      lcd.setCursor(0,1);
      lcd.print("CARGA AGUA:   ");
      lcd.setCursor(13,1);
    
      digitalWrite(22, HIGH);
      delay(1000)
      digitalwrite(23, HIGH);
      delay(1000);
      lcd.print(llena-ib);
     
    

    }
  }
}
//fin llenar agua

void Tanquec41(){

  digitalWrite(24, HIGH);
  digitalWrite(25, HIGH);
  
  
}







}



jobitos.ino

diagram.json


/*
   \brief a line of a menu screen

   holds a text and a callback function for each menu line
*/
//menuLine
class MenuLine {
  protected:
    using Callback = void (*)(byte, byte, byte, int);
    friend class MenuScreen;
    template<typename T>
    friend class MenuSystem;
    const char *text;
    Callback cbOnSelect = nullptr;
  public:
    MenuLine(const char * text): text(text) {}
    MenuLine(const char * text, Callback cbOnSelect) : text(text), cbOnSelect(cbOnSelect) {}
    // weiterer Konstruktur mit drittem Parameter für den RückgabewertWert für den Callback
};

/*
    A MenuScreen consist of up to 8 menu lines
*/
class MenuScreen {
  protected:
    MenuLine *line0;
    MenuLine *line1;
    MenuLine *line2;
    MenuLine *line3;
    MenuLine *line4;
    MenuLine *line5;
    MenuLine *line6;
    MenuLine *line7;
    const byte noOfLines;
    template<typename T>
    friend class MenuSystem;
  public:
    MenuScreen(MenuLine *line0) :
      line0(line0), noOfLines(1) {}
    MenuScreen(MenuLine *line0, MenuLine *line1) :
      line0(line0), line1(line1), noOfLines(2) {}
    MenuScreen(MenuLine *line0, MenuLine *line1, MenuLine *line2) :
      line0(line0), line1(line1), line2(line2), noOfLines(3) {}
    MenuScreen(MenuLine *line0, MenuLine *line1, MenuLine *line2, MenuLine *line3) :
      line0(line0), line1(line1), line2(line2), line3(line3), noOfLines(4) {}
    MenuScreen(MenuLine *line0, MenuLine *line1, MenuLine *line2, MenuLine *line3, MenuLine *line4) :
      line0(line0), line1(line1), line2(line2), line3(line3), line4(line4), noOfLines(5) {}
    MenuScreen(MenuLine *line0, MenuLine *line1, MenuLine *line2, MenuLine *line3, MenuLine *line4, MenuLine *line5) :
      line0(line0), line1(line1), line2(line2), line3(line3), line4(line4), line5(line5), noOfLines(6) {}
    MenuScreen(MenuLine *line0, MenuLine *line1, MenuLine *line2, MenuLine *line3, MenuLine *line4, MenuLine *line5, MenuLine *line6) :
      line0(line0), line1(line1), line2(line2), line3(line3), line4(line4), line5(line5), line6(line6), noOfLines(7) {}
    MenuScreen(MenuLine *line0, MenuLine *line1, MenuLine *line2, MenuLine *line3, MenuLine *line4, MenuLine *line5, MenuLine *line6, MenuLine *line7) :
      line0(line0), line1(line1), line2(line2), line3(line3), line4(line4), line5(line5), line6(line6), line7(line7), noOfLines(8) {}
};

/*
   a MenuSystem consist of up to 8 menu screens.
   It offers several member functions to operate a menu
*/
template<class T>
class MenuSystem {
    T &display;                   // a display based on LCD API
    const byte rows;
    MenuScreen *screen0;
    MenuScreen *screen1;
    MenuScreen *screen2;
    MenuScreen *screen3;
    MenuScreen *screen4;
    MenuScreen *screen5;
    MenuScreen *screen6;
    MenuScreen *screen7;
    const byte noOfScreens;
    static const char markCursor = '>';  // a character to display the cursor position
    static const char markActive = '*';  // a character to display the current setting
    // uint32_t lastChange = 0;   // timestamp of last change
  public:
    byte screen = 0;              // the current screen to be shown
    byte line = 0;                // the current line to be shown
    byte id = 0;                  // can be used for the previous screen
    byte active = 255;            // which line should get an active marker (-1 for no mark?)

    MenuSystem(T &display, byte rows) : display(display), rows(rows), noOfScreens(0) {
      (void)cols;
    }
    MenuSystem(T &display, byte rows, MenuScreen *screen0) :
      display(display), rows(rows), screen0(screen0), noOfScreens(1) {}
    MenuSystem(T &display, byte rows, MenuScreen *screen0, MenuScreen *screen1) :
      display(display), rows(rows), screen0(screen0), screen1(screen1), noOfScreens(2) {}
    MenuSystem(T &display, byte rows, MenuScreen *screen0, MenuScreen *screen1, MenuScreen *screen2) :
      display(display), rows(rows), screen0(screen0), screen1(screen1), screen2(screen2), noOfScreens(3) {}
    MenuSystem(T &display, byte rows, MenuScreen *screen0, MenuScreen *screen1, MenuScreen *screen2, MenuScreen *screen3) :
      display(display), rows(rows), screen0(screen0), screen1(screen1), screen2(screen2), screen3(screen3), noOfScreens(4) {}
    MenuSystem(T &display, byte rows, MenuScreen *screen0, MenuScreen *screen1, MenuScreen *screen2, MenuScreen *screen3, MenuScreen *screen4) :
      display(display), rows(rows), screen0(screen0), screen1(screen1), screen2(screen2), screen3(screen3), screen4(screen4), noOfScreens(5) {}
    MenuSystem(T &display, byte rows, MenuScreen *screen0, MenuScreen *screen1, MenuScreen *screen2, MenuScreen *screen3, MenuScreen *screen4, MenuScreen *screen5) :
      display(display), rows(rows), screen0(screen0), screen1(screen1), screen2(screen2), screen3(screen3), screen4(screen4), screen5(screen5), noOfScreens(6) {}
    MenuSystem(T &display, byte rows, MenuScreen *screen0, MenuScreen *screen1, MenuScreen *screen2, MenuScreen *screen3, MenuScreen *screen4, MenuScreen *screen5, MenuScreen *screen6) :
      display(display), rows(rows), screen0(screen0), screen1(screen1), screen2(screen2), screen3(screen3), screen4(screen4), screen5(screen5), screen6(screen6), noOfScreens(7) {}

    /*
        \param &display a reference to the LCD object
        \param cols how many colums does your LCD have (currently not used)
        \param rows how many rows does your LCD have
        \param *screen0 up eight screens
    */
    MenuSystem(T &display, byte rows, MenuScreen *screen0, MenuScreen *screen1, MenuScreen *screen2, MenuScreen *screen3, MenuScreen *screen4, MenuScreen *screen5, MenuScreen *screen6, MenuScreen *screen7) :
      display(display), rows(rows), screen0(screen0), screen1(screen1), screen2(screen2), screen3(screen3), screen4(screen4), screen5(screen5), screen6(screen6), screen7(screen7), noOfScreens(8) {}

    /*
        \brief return the number of lines of the current screen
    */
    byte getNumberOfLines()
    {
      MenuScreen *screenActual;
      switch (screen)
      {
        case 7 : screenActual = screen7; break;
        case 6 : screenActual = screen6; break;
        case 5 : screenActual = screen5; break;
        case 4 : screenActual = screen4; break;
        case 3 : screenActual = screen3; break;
        case 2 : screenActual = screen2; break;
        case 1 : screenActual = screen1; break;
        default : screenActual = screen0;
      }
      return screenActual->noOfLines;
    }

    /*
        \brief activate the defined callback for the line
    */
    void activate(int value = 0)
    {
      MenuScreen *screenActual;
      switch (screen)
      {
        case 7 : screenActual = screen7; break;
        case 6 : screenActual = screen6; break;
        case 5 : screenActual = screen5; break;
        case 4 : screenActual = screen4; break;
        case 3 : screenActual = screen3; break;
        case 2 : screenActual = screen2; break;
        case 1 : screenActual = screen1; break;
        default : screenActual = screen0;
      }
      switch (line)
      {
        case 0 : if (screenActual->line0->cbOnSelect) screenActual->line0->cbOnSelect(screen, id, line, value); break;
        case 1 : if (screenActual->line1->cbOnSelect) screenActual->line1->cbOnSelect(screen, id, line, value); break;
        case 2 : if (screenActual->line2->cbOnSelect) screenActual->line2->cbOnSelect(screen, id, line, value); break;
        case 3 : if (screenActual->line3->cbOnSelect) screenActual->line3->cbOnSelect(screen, id, line, value); break;
        case 4 : if (screenActual->line4->cbOnSelect) screenActual->line4->cbOnSelect(screen, id, line, value); break;
        case 5 : if (screenActual->line5->cbOnSelect) screenActual->line5->cbOnSelect(screen, id, line, value); break;
        case 6 : if (screenActual->line6->cbOnSelect) screenActual->line6->cbOnSelect(screen, id, line, value); break;
        case 7 : if (screenActual->line7->cbOnSelect) screenActual->line7->cbOnSelect(screen, id, line, value); break;
      }
    }

    /*
        \brief go back to main screen
    */
    void cursorBack()
    {
      if (screen != 0)
      {
        line = screen;
        screen = 0;
        id = 0;
      }
      show();
    }

    /*
        \brief move the cursor up (if possible)
    */
    void cursorUp()
    {
      if (line > 0) line--;              // stop up button at the first menu entry
      show();
    }

    /*
        \brief move the cursor down (if possible)
    */
    void cursorDown()
    {
      if (line < getNumberOfLines() - 1) line++;      // stop down button at the last menu entry
      show();
    }

    void setScreen(byte newScreen)
    {
      if (newScreen < noOfScreens) screen = newScreen;
    }

    void setId(byte newId)
    {
      id = newId;
    }

    void setLine(byte newLine)
    {
      line = newLine;
    }

    void setActive(byte newActive)
    {
      active = newActive;
    }

    byte getScreen()
    {
      return screen;
    }

    byte getId() 
    {
      return id;
    }
    byte getLine()
    {
      return line;
    }

    /*
        \brief show the current screen of the menu
    */
    void show(/*byte activeLine*/)
    {
      byte from = 0;
      byte activeLine = line;
      from = (activeLine / rows) * rows;         // the first entry on the LCD is calculated depending on the available LCD rows and the current entry
      byte to = from + rows - 1;                 // the last entry depends on the available rows on the LCD
      MenuScreen *screenActual;
      switch (screen)
      {
        case 7 : screenActual = screen7; break;
        case 6 : screenActual = screen6; break;
        case 5 : screenActual = screen5; break;
        case 4 : screenActual = screen4; break;
        case 3 : screenActual = screen3; break;
        case 2 : screenActual = screen2; break;
        case 1 : screenActual = screen1; break;
        default : screenActual = screen0;
      }
      byte noOfLines = screenActual->noOfLines;
      //Serial.print(F("noOfLines=")); Serial.println(noOfLines);
      if (to >= noOfLines) to = noOfLines - 1;
      byte rowActual = 0;
      display.clear();
      Serial.println();
      for (byte i = from; i <= to; i++)
      {
        display.setCursor(0, rowActual);
        if (i == activeLine)
        {
          display.write(markCursor);     // marker to indicate the actual menu entry
          Serial.print(markCursor);
        }
        else
        {
          display.write(' ');
          Serial.print(' ');
        }
        switch (i)
        {
          case 0 : display.print(screenActual->line0->text); Serial.print(screenActual->line0->text); break;
          case 1 : display.print(screenActual->line1->text); Serial.print(screenActual->line1->text); break;
          case 2 : display.print(screenActual->line2->text); Serial.print(screenActual->line2->text); break;
          case 3 : display.print(screenActual->line3->text); Serial.print(screenActual->line3->text); break;
          case 4 : display.print(screenActual->line4->text); Serial.print(screenActual->line4->text); break;
          case 5 : display.print(screenActual->line5->text); Serial.print(screenActual->line5->text); break;
          case 6 : display.print(screenActual->line6->text); Serial.print(screenActual->line6->text); break;
          case 7 : display.print(screenActual->line7->text); Serial.print(screenActual->line7->text); break;
        }
        if (i == active)
        {
          display.write(markActive);     // marker to indicate the actual menu entry
          Serial.print(markActive);
        }
        Serial.println();
        rowActual++;
      }
    }
};


menu.h


int ahoras = 0;            //Variable a mostrar por LCD de las horas
int aminutos = 0;          //Variable a mostrar por LCD de los minutos
int asegundos = 0;         //Variable a mostrar por LCD de los segundos
int segundostotal = 0;     //Tiempo total
int msg= 0;                //Barrera para el mensaje de bienvenida

int start = A3;            //Pulsador de arranque
int empieza = 1024;        // Variable para almacenaje del pulsador de arranque

int buth = A5;             //Pulsador de Horas
int butm = A0;             //Pulsador de Minutos
int buts = A1;             //Pulsador de segundos

int varbuth = 0;           //Variable para almacenar el valor del pulsador de horas
int varbutm = 0;           //Variable para almacenar el valor del pulsador de minutos
int varbuts = 0;           //Variable para almacenar el valor del pulsador de segundos


{
   lcd.begin(16, 2);         // Configuramos el numero de columnas y filas del LCD.  
   
   pinMode(buzzer, OUTPUT);  //Pin de alarma --> Salida
   pinMode(buth, INPUT);     //Pin de pulsador de horas --> Entrada
   pinMode(butm, INPUT);     //Pin de pulsador de minutos --> Entrada
   pinMode(buts, INPUT);     //Pin de pulsador de segundos --> Entrada
   pinMode(start, INPUT);    //Pin de pulsador de arranque --> Entrada
   
   msg = 0;                  //Barrera del mensaje de bienvenida
   empieza = 1024;           //Barrera de arranque
   
   varbuth = 1;              //Barrera de horas
   varbutm = 1;              //Barrera de minutos
   varbuts = 1;              //Barrera de segundos
}

void loop() 
{
     if(msg==0)             //Mostramos el mensaje de bienvenida solo una vez
     {
       lcd.setCursor(0,0);
       lcd.print("Temporizador con");
       lcd.setCursor(1,1);
       lcd.print("Arduino + LCD");
       delay(2500); 
       msg = 1;
       lcd.clear();
     }
     
     //-------------------------------------------------------------------------------------------------     
     // LECTURA DE LOS BOTONES Y ELECCIÓN DEL TIEMPO, NO SALE DEL BUCLE HASTA PULSAR 
     // EL BOTON DE ARRANQUE
     //-------------------------------------------------------------------------------------------------
     
     do                   
     {
       
       varbuth = analogRead(buth);   //Leemos boton de horas
       varbutm = analogRead(butm);   //Leemos boton de minutos
       varbuts = analogRead(buts);   //Leemos boton de segundos
       
       if(varbuth == 0)              //Si el boton ha sido pulsado, aumentamos las horas en una unidad
       {
        ahoras = ahoras + 1 ;
        delay(250);
       }  
       
        if(varbutm == 0)            //Si el boton ha sido pulsado, aumentamos los minutos en una unidad
       {
         aminutos = aminutos + 1;
         delay(250);
       }  
       
        if(varbuts == 0)            //Si el boton ha sido pulsado, aumentamos los segundos en una unidad
       {
         asegundos = asegundos + 1; 
         delay(250);
       }  
             
       lcd.setCursor(0,0);
       lcd.print("Elige el tiempo");  //Muestra mensaje y las HH:MM:SS que vayamos aumentando
       
       lcd.setCursor(4,1);     

      if (ahoras < 10) lcd.print("0");    // Si las horas son menor que 10, pone un "0" delante.
       lcd.print(ahoras);                 // Sin este codigo, se muestra asi: H:M:S  (1:M:S)
       lcd.print(":");

      if (aminutos < 10) lcd.print("0");  // Si los minutos son menor que 10, pone un "0" delante.
       lcd.print(aminutos);               // Sin este codigo, se muestra asi: H:M:S  (H:1:S)

       lcd.print(":");
      if (asegundos < 10) lcd.print("0"); // Si los segundos son menor que 10, pone un "0" delante.
       lcd.print(asegundos);              // Sin este codigo, se muestra asi: H:M:S  (H:M:1)
       
       empieza = analogRead(start);   //Lee el boton de arranque
       
       if (empieza == 0)              //Si el boton de arranque, fue pulsado...
       {
        segundostotal = asegundos + (aminutos * 60) + (ahoras * 60 * 60);  //Convierte el tiempo elegido en segundos!!
       }
             
     } while(empieza != 0);  // Se repite el menu de elegir tiempo hasta que pulsemos el boton de arranque.
       
      //-------------------------------------------------------------------------------------------------
      // UNA VEZ PULSADO EL BOTON DE ARRANQUE Y ACUMULADO EL TIEMPO, ENTRA EN EL SIGUIENTE WHILE
      // Y NO FINALIZA HASTA TERMINAR LA CUENTA.
      //-------------------------------------------------------------------------------------------------

      while (segundostotal > 0) 
      {
        delay (1000);          //Descontamos en periodos de 1 segundo
        segundostotal--;     
   
        ahoras = ((segundostotal / 60)/ 60);   //Convertimos los segundos totales en horas
        aminutos = (segundostotal / 60) % 60;  //Convertimos los segundos totales en minutos
        asegundos = segundostotal % 60;        //Convertimos los segundos totales en periodos de 60 segundos

        lcd.setCursor(0,0);
        lcd.print("Tiempo restante");        //Mostramos mensaje de tiempo restante
  
        lcd.setCursor(4,1);
        if (ahoras < 10) lcd.print("0");     // Si las horas son menor que 10, pone un "0" delante.
        lcd.print(ahoras);                   // Sin este codigo, se muestra asi: H:M:S  (1:M:S)
        lcd.print(":");

        if (aminutos < 10) lcd.print("0");   // Si los minutos son menor que 10, pone un "0" delante.
        lcd.print(aminutos);                 // Sin este codigo, se muestra asi: H:M:S  (H:1:S)

        lcd.print(":");
        if (asegundos < 10) lcd.print("0");  // si el valor de segundo esta por debajo de 9 (unidad) antepone un cero
        lcd.print(asegundos);                // Sin este codigo, se muestra asi: H:M:S  (H:M:1)
        
          if (segundostotal == 0)            //Si finaliza el tiempo
          {           
             while(1)                        //Bucle infinito mostrando mensaje y haciendo parpadear un led
             {               
                  lcd.clear();
                  lcd.setCursor(5,0);
                  lcd.print("Tiempo");
                  lcd.setCursor(3,1);
                  lcd.print("Finalizado");
               
                 digitalWrite(buzzer, HIGH);
                 delay(200);
                 digitalWrite(buzzer, LOW);
                 delay(200);
             }      
          }
     }
      

timer.h

# Wokwi Library List
# See https://docs.wokwi.com/guides/libraries

# Automatically added based on includes:
LiquidCrystal I2C

Pico PIO USB