#include <Wire.h> // needed for LCD with PCF8574 port expander
#include <LiquidCrystal_I2C.h>
#include <Stepper.h>
long tiempoBleach = 0; // Declara tiempoBleach como una variable long
const int stepsPerRevolution = 1400; // Define el número de pasos por revolución del motor
const long durationC = 195000; // Define la duración del programa en milisegundos (3 minutos 15 segund
const long durationC1 = 225000; // Define la duración del programa en milisegundos (3 minutos 45 segund
const long durationC2 = 255000; // Define la duración del programa en milisegundos (4 minutos 15segund
const long durationC3 = 285000; // Define la duración del programa en milisegundos (4 minutos 45 segund
const long durationB = 200000; //3 minutos y moneditas
const long durationF = 300000; //5 minutos
const long durationW = 30000; //30 segundos
const long duration6 = 360000;
const long duration7 = 420000;
const long duration8 = 480000;
const long duration9 = 540000;
const long duration10 = 600000;
const long durationprueva = 6000;
const int sensor_pin = A10; // Pin del sensor analógico
const int threshold = 500; // Umbral para apagar la bomba de agua
const int NTC_PIN = A15; // Pin del sensor NTC
const int RELAY_PIN = 29; // Pin del relay
const int B = 3950; // Constante B del sensor NTC
const int R0 = 10000; // Valor de resistencia del sensor NTC a 25 grados Celsius
const float TEMPERATURE_ON = 37.8; // Temperatura a partir de la cual se encenderá el relay
const float TEMPERATURE_OFF = 38; // Temperatura a partir de la cual se apagará el relay
int pulsador = digitalRead(5);
const byte thermoDO = 6;
const byte thermoCS = 5;
const byte thermoCLK = 4;
constexpr byte cols = 20; // columns/characters per row
constexpr byte rows = 4; // how many rows
constexpr byte addr = 0x27; // set the LCD address to 0x3F or 0x27
LiquidCrystal_I2C lcd(addr, cols, rows); // create lcd object - with support of special characters
Stepper myStepper(stepsPerRevolution, 12, 13);
// this example uses buttons to navigate through the menu
constexpr byte upButton = A0;
constexpr byte downButton = A1;
constexpr byte backButton = A2;
constexpr byte selectButton = A3;
constexpr byte encoderButton = 4;
constexpr byte start = 2;
// prototype
void action0(byte, byte, byte, int);
void action1(byte, byte, byte, int);
void action2(byte, byte, byte, int);
void action3(byte, byte, byte, int);
void action4(byte, byte, byte, int);
void action5(byte, byte, byte, int);
void action6(byte, byte, byte, int);
void action7(byte, byte, byte, int);
void action8(byte, byte, byte, int);
void action9(byte, byte, byte, int);
void action10(byte, byte, byte, int);
void action11(byte, byte, byte, int);
void action12(byte, byte, byte, int);
void action13(byte, byte, byte, int);
void action14(byte, byte, byte, int);
void action15(byte, byte, byte, int);
void action16(byte, byte, byte, int);
void action17(byte, byte, byte, int);
void action18(byte, byte, byte, int);
void action19(byte, byte, byte, int);
void action20(byte, byte, byte, int);
void action21(byte, byte, byte, int);
void back(byte, byte, byte, int);
#include "menu.h"
//each menu line needs an prompter (text to be displayed) and a function will should be called
//const char theString[] PROGMEM ="Option F"; // https://forum.arduino.cc/t/progmem-and-class-constructor/346118/3
MenuLine menu0line0("C41 580ML", action0);
MenuLine menu0line1("C41 PROGRAMAS", action1);
MenuLine menu0line2("BYN MINUTOS REV ", action2);
MenuLine menu0line3("BYN FIJADOR", action3);
MenuLine menu0line4("BYN TEMP", action6);
MenuLine menu0line5("ING REV BYN", action5);
MenuLine menuLineOnOff0("240ml", action8);
MenuLine menuLineOnOff1("PUSH +1 240ML ", action9);
MenuLine menuLineOnOff1B("PUSH +1 580ML", action10);
MenuLine menuLineOnOff2("PUSH +2 240ML", action11);
MenuLine menuLineOnOff3("PUSH +3 240ML", action21);
MenuLine menuLineOnOffBack("(return)", back);
MenuLine menuLineRGB0("6 minutos", action13);
MenuLine menuLineRGB1("7 minutos", action14);
MenuLine menuLineRGB2("8 minutos", action15);
MenuLine menuLineRGB3("9 minutos", action16);
MenuLine menuLineRGB4("10 minutos", action17);
MenuLine menuLineRGBBack("(return)", back);
MenuLine menuLineSpeed0("NUEVO", action18);
MenuLine menuLineSpeed1("MEDIO", action19);
MenuLine menuLineSpeed2("AGOTADO", back);
MenuLine menuLineBack("(return)", back);
MenuLine menuLineNothing("nothing");
MenuLine menuLineOKOff0("Off", back);
MenuLine menuLineOKOff1("On", back);
MenuLine menuLineOKOffBack("(return)", back);
// menu screens are collection of several lines:
MenuScreen menuScreenMain(&menu0line0, &menu0line1, &menu0line2, &menu0line3, &menu0line4, &menu0line5);
MenuScreen menuScreenOnOff(&menuLineOnOff0, &menuLineOnOff1, &menuLineOnOff1B, &menuLineOnOff2, &menuLineOnOff3, &menuLineBack);
MenuScreen menuScreenRGB(&menuLineRGB0, &menuLineRGB1, &menuLineRGB2, &menuLineRGB3, &menuLineRGB4, &menuLineBack);
MenuScreen menuScreenSpeed(&menuLineSpeed0, &menuLineSpeed1, &menuLineSpeed2, &menuLineNothing, &menuLineBack);
MenuScreen menuScreenoknook(&menuLineOKOff0, &menuLineOKOff1, &menuLineBack); // example of screen with exit/back/return
// menu system is the collection of several menu screens:
MenuSystem<LiquidCrystal_I2C> menuSystem(lcd, rows, &menuScreenMain, &menuScreenOnOff, &menuScreenRGB, &menuScreenSpeed, &menuScreenoknook);
// besser wäre etwas ala "ID" und "option"
void action0(byte screen, byte id, byte line, int value) // do what ever is needed
{
Serial.println(F("action0"));
(void)screen; // if you don't use the screen, avoid warning for unused varialbe
(void)id;
(void)line;
(void)value;
lcd.clear();
lcd.print("-PROGRAMA C41 580ML");
////// C41 /////
delay(1500);
lcd.clear();
lcd.setCursor(3,1);
lcd.print("INGRESANDO C41 ");
delay(2000);
//ingresa. agua al tanque interno que calentara el quimico
for(int i = 0; i <= 2;i++ ){
analogRead(A10);
if (analogRead(A10) < 100)
{
digitalWrite(23, LOW);
digitalWrite(33, LOW);
Serial.println("SENSOR ACTIVADO");
delay(500);
}
else if (analogRead(A10) > 100)
{
digitalWrite(23, HIGH);
digitalWrite(33, HIGH);
Serial.println("INGRESANDO QUIMICO");
delay(500);
i=i-1;
}
}
lcd.clear();
lcd.print("CALENTANDO");
lcd.setCursor(2,1);
lcd.print("QUIMICOS");
// esscribir codigo para calentar quimico
for (int i = 10; i >= 0; i--) {
// Lee el valor de resistencia del sensor NTC
int sensorValue = analogRead(NTC_PIN);
//////////////////////////////////////////
float temperature = 1 / (log(1 / (1023. / sensorValue - 1)) / B + 1.0 / 298.15) - 273.15;
// Comprueba si la temperatura es menor de 37,8 grados
if (temperature < TEMPERATURE_ON) {
// Enciende el relay
lcd.setCursor(0,2);
lcd.print(temperature);
digitalWrite(22, HIGH);
lcd.setCursor(6,2);
lcd.print("ENCENDIDO");
i=i+1;
}
// Comprueba si la temperatura es mayor o igual a 38 grados
else if (temperature >= TEMPERATURE_OFF) {
// Apaga el relay
digitalWrite(22, LOW);
lcd.setCursor(0,2);
lcd.print(temperature);
lcd.setCursor(6,2);
lcd.print("ENFRIANDO");
i=i+1;
}
// Si la temperatura está entre 37,8 y 38 grados
else {
lcd.setCursor(0,2);
lcd.print(temperature);
lcd.setCursor(8,3);
lcd.print(i);
// No hace nada, deja el relay en su estado actual
}
// Espera 1 segundo antes de volver a medir
delay(1000);
}
digitalWrite(47, HIGH);
digitalWrite(11, HIGH); //prender bomba pumpfill
delay(500);
lcd.clear();
lcd.setCursor(3,1);
lcd.print("ingresando C41");
lcd.println("al tanque");
delay(5000); //probar con cuanto llena el tanque
digitalWrite(47, LOW);
digitalWrite(11, LOW);
delay (2000);
//codigo motor agregar const duration y numero para que gire el motor durante distintos tiempos
lcd.clear();
lcd.setCursor(0, 0); // Coloca el cursor en la primera columna de la primera fila
lcd.print("Tiempo restante:"); // Imprime el texto "Tiempo restante:" en el LCD)
long startTime = millis(); // Guarda el tiempo actual en milisegundos en la variable startTime
long elapsedTime = 0; // Inicializa la variable elapsedTime en 0
while (elapsedTime < durationC) { // Mientras elapsedTime sea menor que la duración del programa
myStepper.step(stepsPerRevolution); // Gira el motor 400 pasos a la derecha
Serial.println("clockwise");
delay(1000); // Espera 500 milisegundos
myStepper.step(-stepsPerRevolution); // Gira el motor 400 pasos a la izquierda
Serial.println("counterclockwise");
delay(1000); // Espera 500 milisegundos
elapsedTime = millis() - startTime; // Actualiza elapsedTime con la diferencia entre el tiempo actual y startTime
long remainingTime = durationC - elapsedTime; // Calcula el tiempo restante como la diferencia entre la duración del programa y elapsedTime
int minutes = remainingTime / 60000; // Calcula el número de minutos restantes
int seconds = (remainingTime % 60000) / 1000; // Calcula el número de segundos restantes
lcd.setCursor(0, 1); // Coloca el cursor en la primera columna de la segunda fila
lcd.print(minutes); // Imprime el número de minutos restantes en el LCD
lcd.setCursor(1, 1); // Coloca el cursor en la primera columna de la segunda fila
lcd.print(":"); // Imprime el número de minutos restantes en el LCD
// Verifica si el número de segundos es menor que 10
lcd.setCursor(2, 1);
if (seconds < 10) {
lcd.print("0"); // Imprime un cero adicional si el número de segundos es menor que 10
}
lcd.print(seconds); // Imprime el número de segundos restantes en el LCD
}
lcd.clear();
lcd.setCursor(0,1);
lcd.print("vaciando TANQUE");
lcd.println(" ");
digitalWrite(41, HIGH);
delay(4000);
digitalWrite(41, LOW);
lcd.clear();
lcd.print("C41 ");
lcd.println(" 1/3");
////// c41 /////
delay(1000);
////// LImPIEZAAAAAAA /////
lcd.clear();
lcd.print("activando limpieza ");
lcd.println(" 1/3");
for(int i = 0; i <= 2;i++ ){
analogRead(A10);
if (analogRead(A10) < 100)
{
digitalWrite(29, LOW);
digitalWrite(33, LOW);
Serial.println("SENSOR ACTIVADO");
delay(500);
}
else if (analogRead(A10) > 100)
{
digitalWrite(29, HIGH);
digitalWrite(33, HIGH);
Serial.println("INGRESANDO AGUA");
delay(500);
i=i-1;
}
}
digitalWrite(11, HIGH); //prender bomba pumpfill
delay(500);
lcd.clear();
lcd.setCursor(3,1);
lcd.print("ingresando AGUA");
lcd.println("al tanque");
delay(12000); //probar con cuanto llena el tanque 240 APROX 8segundos
digitalWrite(11, LOW);
lcd.clear();
lcd.setCursor(0, 1); // Coloca el cursor en la primera columna de la primera fila
lcd.print("Tiempo restante:"); // Imprime el texto "Tiempo restante:" en el LCD)
while (elapsedTime < durationW) { // Mientras elapsedTime sea menor que la duración del programa
myStepper.step(stepsPerRevolution); // Gira el motor 400 pasos a la derecha
Serial.println("clockwise");
delay(1000); // Espera 500 milisegundos
myStepper.step(-stepsPerRevolution); // Gira el motor 400 pasos a la izquierda
Serial.println("counterclockwise");
delay(1000); // Espera 500 milisegundos
elapsedTime = millis() - startTime; // Actualiza elapsedTime con la diferencia entre el tiempo actual y startTime
long remainingTime = durationW - elapsedTime; // Calcula el tiempo restante como la diferencia entre la duración del programa y elapsedTime
int minutes = remainingTime / 60000; // Calcula el número de minutos restantes
int seconds = (remainingTime % 60000) / 1000; // Calcula el número de segundos restantes
lcd.setCursor(0, 2); // Coloca el cursor en la primera columna de la segunda fila
lcd.print(minutes); // Imprime el número de minutos restantes en el LCD
lcd.setCursor(1, 2); // Coloca el cursor en la primera columna de la segunda fila
lcd.print(":"); // Imprime el número de minutos restantes en el LCD
// Verifica si el número de segundos es menor que 10
lcd.setCursor(2, 2);
if (seconds < 10) {
lcd.print("0"); // Imprime un cero adicional si el número de segundos es menor que 10
}
lcd.print(seconds); // Imprime el número de segundos restantes en el LCD
}
delay(1000);
lcd.print("vaciando TANQUE");
lcd.println(" ");
digitalWrite(49, HIGH);
delay(4000);
digitalWrite(49, LOW);
lcd.clear();
lcd.print("LIMPIEZA ");
lcd.println(" 1/3");
////// LIMPIEZAAAAA //////////
////// bleach /////
delay(1500);
lcd.clear();
lcd.setCursor(3,1);
lcd.print("INGRESADO BLEACH ");
delay(2000);
//ingresa. agua al tanque interno que calentara el quimico
for(int i = 0; i <= 2;i++ ){
analogRead(A10);
if (analogRead(A10) < 100)
{
digitalWrite(25, LOW);
digitalWrite(33, LOW);
Serial.println("SENSOR ACTIVADO");
delay(500);
}
else if (analogRead(A10) > 100)
{
digitalWrite(25, HIGH);
digitalWrite(33, HIGH);
Serial.println("INGRESANDO QUIMICO");
delay(500);
i=i-1;
}
}
lcd.clear();
lcd.print("CALENTANDO");
lcd.setCursor(2,1);
lcd.print("BLEACH");
// esscribir codigo para calentar quimico
for (int i = 10; i >= 0; i--) {
// Lee el valor de resistencia del sensor NTC
int sensorValue = analogRead(NTC_PIN);
//////////////////////////////////////////
float temperature = 1 / (log(1 / (1023. / sensorValue - 1)) / B + 1.0 / 298.15) - 273.15;
// Comprueba si la temperatura es menor de 37,8 grados
if (temperature < TEMPERATURE_ON) {
// Enciende el relay
lcd.setCursor(0,2);
lcd.print(temperature);
digitalWrite(22, HIGH);
lcd.setCursor(6,2);
lcd.print("ENCENDIDO");
i=i+1;
}
// Comprueba si la temperatura es mayor o igual a 38 grados
else if (temperature >= TEMPERATURE_OFF) {
// Apaga el relay
digitalWrite(22, LOW);
lcd.setCursor(0,2);
lcd.print(temperature);
lcd.setCursor(6,2);
lcd.print("ENFRIANDO");
i=i+1;
}
// Si la temperatura está entre 37,8 y 38 grados
else {
lcd.setCursor(0,2);
lcd.print(temperature);
lcd.setCursor(8,3);
lcd.print(i);
// No hace nada, deja el relay en su estado actual
}
// Espera 1 segundo antes de volver a medir
delay(1000);
}
digitalWrite(11, HIGH); //prender bomba pumpfill
delay(500);
lcd.clear();
lcd.setCursor(3,1);
lcd.print("ingresando BLEACH");
lcd.println("al tanque");
delay(5000); //probar con cuanto llena el tanque
digitalWrite(11, LOW);
delay (2000);
//codigo motor agregar const duration y numero para que gire el motor durante distintos tiempos
lcd.clear();
lcd.setCursor(0, 0); // Coloca el cursor en la primera columna de la primera fila
lcd.print("Tiempo restante:"); // Imprime el texto "Tiempo restante:" en el LCD)
while (elapsedTime < durationB) { // Mientras elapsedTime sea menor que la duración del programa
myStepper.step(stepsPerRevolution); // Gira el motor 400 pasos a la derecha
Serial.println("clockwise");
delay(1000); // Espera 500 milisegundos
myStepper.step(-stepsPerRevolution); // Gira el motor 400 pasos a la izquierda
Serial.println("counterclockwise");
delay(1000); // Espera 500 milisegundos
elapsedTime = millis() - startTime; // Actualiza elapsedTime con la diferencia entre el tiempo actual y startTime
long remainingTime = durationB - elapsedTime; // Calcula el tiempo restante como la diferencia entre la duración del programa y elapsedTime
int minutes = remainingTime / 60000; // Calcula el número de minutos restantes
int seconds = (remainingTime % 60000) / 1000; // Calcula el número de segundos restantes
lcd.setCursor(0, 1); // Coloca el cursor en la primera columna de la segunda fila
lcd.print(minutes); // Imprime el número de minutos restantes en el LCD
lcd.setCursor(1, 1); // Coloca el cursor en la primera columna de la segunda fila
lcd.print(":"); // Imprime el número de minutos restantes en el LCD
// Verifica si el número de segundos es menor que 10
lcd.setCursor(2, 1);
if (seconds < 10) {
lcd.print("0"); // Imprime un cero adicional si el número de segundos es menor que 10
}
lcd.print(seconds); // Imprime el número de segundos restantes en el LCD
}
lcd.clear();
lcd.setCursor(0,1);
lcd.print("vaciando TANQUE");
lcd.println(" ");
digitalWrite(43, HIGH);
delay(4000);
digitalWrite(43, LOW);
lcd.clear();
lcd.print("BLEACH ");
lcd.println(" 2/3");
////// BLEACH /////
////// LImPIEZAAAAAAA /////
for(int i = 0; i <= 2;i++ ){
analogRead(A10);
if (analogRead(A10) < 100)
{
digitalWrite(29, LOW);
digitalWrite(33, LOW);
Serial.println("SENSOR ACTIVADO");
delay(500);
}
else if (analogRead(A10) > 100)
{
digitalWrite(29, HIGH);
digitalWrite(33, HIGH);
Serial.println("INGRESANDO AGUA");
delay(500);
i=i-1;
}
}
digitalWrite(11, HIGH); //prender bomba pumpfill
delay(500);
lcd.clear();
lcd.setCursor(3,1);
lcd.print("ingresando AGUA");
lcd.println("al tanque");
delay(12000); //probar con cuanto llena el tanque 240 APROX 8segundos
digitalWrite(11, LOW);
lcd.clear();
lcd.setCursor(0, 1); // Coloca el cursor en la primera columna de la primera fila
lcd.print("Tiempo restante:"); // Imprime el texto "Tiempo restante:" en el LCD)
while (elapsedTime < durationW) { // Mientras elapsedTime sea menor que la duración del programa
myStepper.step(stepsPerRevolution); // Gira el motor 400 pasos a la derecha
Serial.println("clockwise");
delay(1000); // Espera 500 milisegundos
myStepper.step(-stepsPerRevolution); // Gira el motor 400 pasos a la izquierda
Serial.println("counterclockwise");
delay(1000); // Espera 500 milisegundos
elapsedTime = millis() - startTime; // Actualiza elapsedTime con la diferencia entre el tiempo actual y startTime
long remainingTime = durationW - elapsedTime; // Calcula el tiempo restante como la diferencia entre la duración del programa y elapsedTime
int minutes = remainingTime / 60000; // Calcula el número de minutos restantes
int seconds = (remainingTime % 60000) / 1000; // Calcula el número de segundos restantes
lcd.setCursor(0, 2); // Coloca el cursor en la primera columna de la segunda fila
lcd.print(minutes); // Imprime el número de minutos restantes en el LCD
lcd.setCursor(1, 2); // Coloca el cursor en la primera columna de la segunda fila
lcd.print(":"); // Imprime el número de minutos restantes en el LCD
// Verifica si el número de segundos es menor que 10
lcd.setCursor(2, 2);
if (seconds < 10) {
lcd.print("0"); // Imprime un cero adicional si el número de segundos es menor que 10
}
lcd.print(seconds); // Imprime el número de segundos restantes en el LCD
}
delay(1000);
lcd.print("vaciando TANQUE");
lcd.println(" ");
digitalWrite(49, HIGH);
delay(4000);
digitalWrite(49, LOW);
lcd.clear();
lcd.print("LIMPIEZA ");
lcd.println(" 2/3");
////// LIMPIEZAAAAA //////////
////// FIJADOR /////
delay(1500);
lcd.clear();
lcd.setCursor(3,1);
lcd.print("INGRESADO FIX");
delay(2000);
//ingresa. agua al tanque interno que calentara el quimico
for(int i = 0; i <= 2;i++ ){
analogRead(A10);
if (analogRead(A10) < 100)
{
digitalWrite(23, LOW);
digitalWrite(33, LOW);
Serial.println("SENSOR ACTIVADO");
delay(500);
}
else if (analogRead(A10) > 100)
{
digitalWrite(23, HIGH);
digitalWrite(33, HIGH);
Serial.println("INGRESANDO QUIMICO");
delay(500);
i=i-1;
}
}
lcd.clear();
lcd.print("CALENTANDO");
lcd.setCursor(2,1);
lcd.print("FIX");
// esscribir codigo para calentar quimico
for (int i = 10; i >= 0; i--) {
// Lee el valor de resistencia del sensor NTC
int sensorValue = analogRead(NTC_PIN);
//////////////////////////////////////////
float temperature = 1 / (log(1 / (1023. / sensorValue - 1)) / B + 1.0 / 298.15) - 273.15;
// Comprueba si la temperatura es menor de 37,8 grados
if (temperature < TEMPERATURE_ON) {
// Enciende el relay
lcd.setCursor(0,2);
lcd.print(temperature);
digitalWrite(22, HIGH);
lcd.setCursor(6,2);
lcd.print("ENCENDIDO");
i=i+1;
}
// Comprueba si la temperatura es mayor o igual a 38 grados
else if (temperature >= TEMPERATURE_OFF) {
// Apaga el relay
digitalWrite(22, LOW);
lcd.setCursor(0,2);
lcd.print(temperature);
lcd.setCursor(6,2);
lcd.print("ENFRIANDO");
i=i+1;
}
// Si la temperatura está entre 37,8 y 38 grados
else {
lcd.setCursor(0,2);
lcd.print(temperature);
lcd.setCursor(8,3);
lcd.print(i);
// No hace nada, deja el relay en su estado actual
}
// Espera 1 segundo antes de volver a medir
delay(1000);
}
digitalWrite(11, HIGH); //prender bomba pumpfill
delay(500);
lcd.clear();
lcd.setCursor(3,1);
lcd.print("ingresando FIJADOR");
lcd.println("al tanque");
delay(5000); //probar con cuanto llena el tanque
digitalWrite(11, LOW);
delay (2000);
//codigo motor agregar const duration y numero para que gire el motor durante distintos tiempos
lcd.clear();
lcd.setCursor(0, 0); // Coloca el cursor en la primera columna de la primera fila
lcd.print("Tiempo restante:"); // Imprime el texto "Tiempo restante:" en el LCD)
while (elapsedTime < durationF) { // Mientras elapsedTime sea menor que la duración del programa
myStepper.step(stepsPerRevolution); // Gira el motor 400 pasos a la derecha
Serial.println("clockwise");
delay(1000); // Espera 500 milisegundos
myStepper.step(-stepsPerRevolution); // Gira el motor 400 pasos a la izquierda
Serial.println("counterclockwise");
delay(1000); // Espera 500 milisegundos
elapsedTime = millis() - startTime; // Actualiza elapsedTime con la diferencia entre el tiempo actual y startTime
long remainingTime = durationF - elapsedTime; // Calcula el tiempo restante como la diferencia entre la duración del programa y elapsedTime
int minutes = remainingTime / 60000; // Calcula el número de minutos restantes
int seconds = (remainingTime % 60000) / 1000; // Calcula el número de segundos restantes
lcd.setCursor(0, 1); // Coloca el cursor en la primera columna de la segunda fila
lcd.print(minutes); // Imprime el número de minutos restantes en el LCD
lcd.setCursor(1, 1); // Coloca el cursor en la primera columna de la segunda fila
lcd.print(":"); // Imprime el número de minutos restantes en el LCD
// Verifica si el número de segundos es menor que 10
lcd.setCursor(2, 1);
if (seconds < 10) {
lcd.print("0"); // Imprime un cero adicional si el número de segundos es menor que 10
}
lcd.print(seconds); // Imprime el número de segundos restantes en el LCD
}
lcd.clear();
lcd.setCursor(0,1);
lcd.print("vaciando TANQUE");
lcd.println(" ");
digitalWrite(45, HIGH);
delay(4000);
digitalWrite(45, LOW);
lcd.clear();
lcd.print("FIX ");
lcd.println(" 3/3");
////// FIJADOR /////
////// LImPIEZAAAAAAA /////
for(int i = 0; i <= 2;i++ ){
analogRead(A10);
if (analogRead(A10) < 100)
{
digitalWrite(27, LOW);
digitalWrite(33, LOW);
Serial.println("SENSOR ACTIVADO");
delay(500);
}
else if (analogRead(A10) > 100)
{
digitalWrite(27, HIGH);
digitalWrite(33, HIGH);
Serial.println("INGRESANDO AGUA");
delay(500);
i=i-1;
}
}
digitalWrite(11, HIGH); //prender bomba pumpfill
delay(500);
lcd.clear();
lcd.setCursor(3,1);
lcd.print("ingresando AGUA");
lcd.println("al tanque");
delay(12000); //probar con cuanto llena el tanque 240 APROX 8segundos
digitalWrite(11, LOW);
lcd.clear();
lcd.setCursor(0, 1); // Coloca el cursor en la primera columna de la primera fila
lcd.print("Tiempo restante:"); // Imprime el texto "Tiempo restante:" en el LCD)
while (elapsedTime < durationW) { // Mientras elapsedTime sea menor que la duración del programa
myStepper.step(stepsPerRevolution); // Gira el motor 400 pasos a la derecha
Serial.println("clockwise");
delay(1000); // Espera 500 milisegundos
myStepper.step(-stepsPerRevolution); // Gira el motor 400 pasos a la izquierda
Serial.println("counterclockwise");
delay(1000); // Espera 500 milisegundos
elapsedTime = millis() - startTime; // Actualiza elapsedTime con la diferencia entre el tiempo actual y startTime
long remainingTime = durationW - elapsedTime; // Calcula el tiempo restante como la diferencia entre la duración del programa y elapsedTime
int minutes = remainingTime / 60000; // Calcula el número de minutos restantes
int seconds = (remainingTime % 60000) / 1000; // Calcula el número de segundos restantes
lcd.setCursor(0, 2); // Coloca el cursor en la primera columna de la segunda fila
lcd.print(minutes); // Imprime el número de minutos restantes en el LCD
lcd.setCursor(1, 2); // Coloca el cursor en la primera columna de la segunda fila
lcd.print(":"); // Imprime el número de minutos restantes en el LCD
// Verifica si el número de segundos es menor que 10
lcd.setCursor(2, 2);
if (seconds < 10) {
lcd.print("0"); // Imprime un cero adicional si el número de segundos es menor que 10
}
lcd.print(seconds); // Imprime el número de segundos restantes en el LCD
}
delay(1000);
lcd.print("vaciando TANQUE");
lcd.println(" ");
digitalWrite(49, HIGH);
delay(4000);
digitalWrite(49, LOW);
lcd.clear();
lcd.print("LIMPIEZA ");
lcd.println(" 3/3");
delay(4000);
lcd.clear();
lcd.print("PROCESO C41 ");
lcd.println(" FIN");
delay(4000);
////// LIMPIEZAAAAA //////////
menuSystem.screen = 0;
menuSystem.show();
}
//switch to menuScreen 1
void action1(byte screen, byte id, byte line, int value)
{
Serial.println(F("action1"));
(void)screen;
(void)id;
(void)line;
(void)value;
menuSystem.setId(menuSystem.getLine()); // preserve former line into id
menuSystem.setScreen(1);
menuSystem.show();
}
//switch to menuScreen 2
void action2(byte screen, byte id, byte line, int value)
{
Serial.println(F("action2"));
(void)screen;
(void)id;
(void)line;
(void)value;
menuSystem.setId(menuSystem.getLine()); // preserve former screen into id
menuSystem.setScreen(2);
menuSystem.show();
}
void action3(byte screen, byte id, byte line, int value)
{
Serial.println(F("action3"));
(void)screen;
(void)id;
(void)line;
(void)value;
menuSystem.setId(menuSystem.getLine());// preserve former screen into id
menuSystem.setScreen(3);
menuSystem.show();
}
void action4(byte screen, byte id, byte line, int value)
{
Serial.println(F("action4"));
(void)screen;
(void)id;
(void)line;
(void)value;
lcd.clear();
lcd.print(F("-Executing E"));
delay(1500);
menuSystem.setLine(4);
menuSystem.setScreen(0);
menuSystem.show();
}
void action5(byte screen, byte id, byte line, int value)
{
Serial.print(F("Action5 "));
Serial.print(F(" screen=")); Serial.print(screen);
Serial.print(F(" id=")); Serial.print(id);
Serial.print(F(" line=")); Serial.print(line);
Serial.print(F(" value=")); Serial.println(value);
lcd.clear();
lcd.print(F("NO PROGRAMMSSS"));
delay(2000);
menuSystem.setLine(5);
menuSystem.setScreen(0);
menuSystem.setId(0);
menuSystem.show();
}
void action6(byte screen, byte id, byte line, int value)
{
Serial.print(F("Action6 "));
Serial.print(F(" screen=")); Serial.print(screen);
Serial.print(F(" id=")); Serial.print(id);
Serial.print(F(" line=")); Serial.print(line);
Serial.print(F(" value=")); Serial.println(value);
lcd.clear();
lcd.print("-MIDIENDO TEMP");
delay(1500);
int sensorValue = analogRead(NTC_PIN);
//////////////////////////////////////////
float temperature = 1 / (log(1 / (1023. / sensorValue - 1)) / B + 1.0 / 298.15) - 273.15;
lcd.setCursor(0,1);
lcd.print("la temp es: ");
lcd.println(temperature);
delay(4000);
menuSystem.setLine(6);
menuSystem.setScreen(0);
menuSystem.setId(0);
menuSystem.show();
}
void action7(byte screen, byte id, byte line, int value)
{
Serial.println(F("action7"));
(void)screen;
(void)id;
(void)line;
(void)value;
lcd.clear();
lcd.print("-Executing #7");
delay(1500);
menuSystem.setLine(7);
menuSystem.setScreen(0);
menuSystem.setId(0);
menuSystem.show();
}
void action8(byte screen, byte id, byte line, int value)
{
Serial.println(F("action8"));
(void)screen;
(void)id;
(void)line;
(void)value;
lcd.clear();
lcd.print(F("EJECUTANDO C41 240ML"));
delay(1500);
////// C41 /////
delay(1500);
lcd.clear();
lcd.setCursor(3,1);
lcd.print("INGRESANDO C41 240 ");
delay(2000);
//ingresa. agua al tanque interno que calentara el quimico
for(int i = 0; i <= 2;i++ ){
analogRead(A11);
if (analogRead(A11) < 100)
{
digitalWrite(23, LOW);
digitalWrite(33, LOW);
Serial.println("SENSOR ACTIVADO");
delay(500);
}
else if (analogRead(A11) > 100)
{
digitalWrite(23, HIGH);
digitalWrite(33, HIGH);
Serial.println("INGRESANDO QUIMICO");
delay(500);
i=i-1;
}
}
lcd.clear();
lcd.print("CALENTANDO");
lcd.setCursor(2,1);
lcd.print("QUIMICOS");
// esscribir codigo para calentar quimico
for (int i = 10; i >= 0; i--) {
// Lee el valor de resistencia del sensor NTC
int sensorValue = analogRead(NTC_PIN);
//////////////////////////////////////////
float temperature = 1 / (log(1 / (1023. / sensorValue - 1)) / B + 1.0 / 298.15) - 273.15;
// Comprueba si la temperatura es menor de 37,8 grados
if (temperature < TEMPERATURE_ON) {
// Enciende el relay
lcd.setCursor(0,2);
lcd.print(temperature);
digitalWrite(22, HIGH);
lcd.setCursor(6,2);
lcd.print("ENCENDIDO");
i=i+1;
}
// Comprueba si la temperatura es mayor o igual a 38 grados
else if (temperature >= TEMPERATURE_OFF) {
// Apaga el relay
digitalWrite(22, LOW);
lcd.setCursor(0,2);
lcd.print(temperature);
lcd.setCursor(6,2);
lcd.print("ENFRIANDO");
i=i+1;
}
// Si la temperatura está entre 37,8 y 38 grados
else {
lcd.setCursor(0,2);
lcd.print(temperature);
lcd.setCursor(8,3);
lcd.print(i);
// No hace nada, deja el relay en su estado actual
}
// Espera 1 segundo antes de volver a medir
delay(1000);
}
digitalWrite(47, HIGH);
digitalWrite(11, HIGH); //prender bomba pumpfill
delay(500);
lcd.clear();
lcd.setCursor(3,1);
lcd.print("ingresando C41");
lcd.println("al tanque");
delay(5000); //probar con cuanto llena el tanque
digitalWrite(47, LOW);
digitalWrite(11, LOW);
delay (2000);
//codigo motor agregar const duration y numero para que gire el motor durante distintos tiempos
lcd.clear();
lcd.setCursor(0, 0); // Coloca el cursor en la primera columna de la primera fila
lcd.print("Tiempo restante:"); // Imprime el texto "Tiempo restante:" en el LCD)
long startTime = millis(); // Guarda el tiempo actual en milisegundos en la variable startTime
long elapsedTime = 0; // Inicializa la variable elapsedTime en 0
while (elapsedTime < durationC) { // Mientras elapsedTime sea menor que la duración del programa
myStepper.step(stepsPerRevolution); // Gira el motor 400 pasos a la derecha
Serial.println("clockwise");
delay(1000); // Espera 500 milisegundos
myStepper.step(-stepsPerRevolution); // Gira el motor 400 pasos a la izquierda
Serial.println("counterclockwise");
delay(1000); // Espera 500 milisegundos
elapsedTime = millis() - startTime; // Actualiza elapsedTime con la diferencia entre el tiempo actual y startTime
long remainingTime = durationC - elapsedTime; // Calcula el tiempo restante como la diferencia entre la duración del programa y elapsedTime
int minutes = remainingTime / 60000; // Calcula el número de minutos restantes
int seconds = (remainingTime % 60000) / 1000; // Calcula el número de segundos restantes
lcd.setCursor(0, 1); // Coloca el cursor en la primera columna de la segunda fila
lcd.print(minutes); // Imprime el número de minutos restantes en el LCD
lcd.setCursor(1, 1); // Coloca el cursor en la primera columna de la segunda fila
lcd.print(":"); // Imprime el número de minutos restantes en el LCD
// Verifica si el número de segundos es menor que 10
lcd.setCursor(2, 1);
if (seconds < 10) {
lcd.print("0"); // Imprime un cero adicional si el número de segundos es menor que 10
}
lcd.print(seconds); // Imprime el número de segundos restantes en el LCD
}
lcd.clear();
lcd.setCursor(0,1);
lcd.print("vaciando TANQUE");
lcd.println(" ");
digitalWrite(41, HIGH);
delay(4000);
digitalWrite(41, LOW);
lcd.clear();
lcd.print("C41 ");
lcd.println(" 1/3");
////// c41 /////
delay(1000);
////// LImPIEZAAAAAAA /////
lcd.clear();
lcd.print("activando limpieza ");
lcd.println(" 1/3");
for(int i = 0; i <= 2;i++ ){
analogRead(A11);
if (analogRead(A11) < 100)
{
digitalWrite(29, LOW);
digitalWrite(33, LOW);
Serial.println("SENSOR ACTIVADO");
delay(500);
}
else if (analogRead(A11) > 100)
{
digitalWrite(29, HIGH);
digitalWrite(33, HIGH);
Serial.println("INGRESANDO AGUA");
delay(500);
i=i-1;
}
}
digitalWrite(11, HIGH); //prender bomba pumpfill
delay(500);
lcd.clear();
lcd.setCursor(3,1);
lcd.print("ingresando AGUA");
lcd.println("al tanque");
delay(12000); //probar con cuanto llena el tanque 240 APROX 8segundos
digitalWrite(11, LOW);
lcd.clear();
lcd.setCursor(0, 1); // Coloca el cursor en la primera columna de la primera fila
lcd.print("Tiempo restante:"); // Imprime el texto "Tiempo restante:" en el LCD)
while (elapsedTime < durationW) { // Mientras elapsedTime sea menor que la duración del programa
myStepper.step(stepsPerRevolution); // Gira el motor 400 pasos a la derecha
Serial.println("clockwise");
delay(1000); // Espera 500 milisegundos
myStepper.step(-stepsPerRevolution); // Gira el motor 400 pasos a la izquierda
Serial.println("counterclockwise");
delay(1000); // Espera 500 milisegundos
elapsedTime = millis() - startTime; // Actualiza elapsedTime con la diferencia entre el tiempo actual y startTime
long remainingTime = durationW - elapsedTime; // Calcula el tiempo restante como la diferencia entre la duración del programa y elapsedTime
int minutes = remainingTime / 60000; // Calcula el número de minutos restantes
int seconds = (remainingTime % 60000) / 1000; // Calcula el número de segundos restantes
lcd.setCursor(0, 2); // Coloca el cursor en la primera columna de la segunda fila
lcd.print(minutes); // Imprime el número de minutos restantes en el LCD
lcd.setCursor(1, 2); // Coloca el cursor en la primera columna de la segunda fila
lcd.print(":"); // Imprime el número de minutos restantes en el LCD
// Verifica si el número de segundos es menor que 10
lcd.setCursor(2, 2);
if (seconds < 10) {
lcd.print("0"); // Imprime un cero adicional si el número de segundos es menor que 10
}
lcd.print(seconds); // Imprime el número de segundos restantes en el LCD
}
delay(1000);
lcd.print("vaciando TANQUE");
lcd.println(" ");
digitalWrite(49, HIGH);
delay(4000);
digitalWrite(49, LOW);
lcd.clear();
lcd.print("LIMPIEZA ");
lcd.println(" 1/3");
////// LIMPIEZAAAAA //////////
////// bleach /////
delay(1500);
lcd.clear();
lcd.setCursor(3,1);
lcd.print("INGRESADO BLEACH ");
delay(2000);
//ingresa. agua al tanque interno que calentara el quimico
for(int i = 0; i <= 2;i++ ){
analogRead(A11);
if (analogRead(A11) < 100)
{
digitalWrite(25, LOW);
digitalWrite(33, LOW);
Serial.println("SENSOR ACTIVADO");
delay(500);
}
else if (analogRead(A11) > 100)
{
digitalWrite(25, HIGH);
digitalWrite(33, HIGH);
Serial.println("INGRESANDO QUIMICO");
delay(500);
i=i-1;
}
}
lcd.clear();
lcd.print("CALENTANDO");
lcd.setCursor(2,1);
lcd.print("BLEACH");
// esscribir codigo para calentar quimico
for (int i = 10; i >= 0; i--) {
// Lee el valor de resistencia del sensor NTC
int sensorValue = analogRead(NTC_PIN);
//////////////////////////////////////////
float temperature = 1 / (log(1 / (1023. / sensorValue - 1)) / B + 1.0 / 298.15) - 273.15;
// Comprueba si la temperatura es menor de 37,8 grados
if (temperature < TEMPERATURE_ON) {
// Enciende el relay
lcd.setCursor(0,2);
lcd.print(temperature);
digitalWrite(22, HIGH);
lcd.setCursor(6,2);
lcd.print("ENCENDIDO");
i=i+1;
}
// Comprueba si la temperatura es mayor o igual a 38 grados
else if (temperature >= TEMPERATURE_OFF) {
// Apaga el relay
digitalWrite(22, LOW);
lcd.setCursor(0,2);
lcd.print(temperature);
lcd.setCursor(6,2);
lcd.print("ENFRIANDO");
i=i+1;
}
// Si la temperatura está entre 37,8 y 38 grados
else {
lcd.setCursor(0,2);
lcd.print(temperature);
lcd.setCursor(8,3);
lcd.print(i);
// No hace nada, deja el relay en su estado actual
}
// Espera 1 segundo antes de volver a medir
delay(1000);
}
digitalWrite(11, HIGH); //prender bomba pumpfill
delay(500);
lcd.clear();
lcd.setCursor(3,1);
lcd.print("ingresando BLEACH");
lcd.println("al tanque");
delay(5000); //probar con cuanto llena el tanque
digitalWrite(11, LOW);
delay (2000);
//codigo motor agregar const duration y numero para que gire el motor durante distintos tiempos
lcd.clear();
lcd.setCursor(0, 0); // Coloca el cursor en la primera columna de la primera fila
lcd.print("Tiempo restante:"); // Imprime el texto "Tiempo restante:" en el LCD)
while (elapsedTime < durationB) { // Mientras elapsedTime sea menor que la duración del programa
myStepper.step(stepsPerRevolution); // Gira el motor 400 pasos a la derecha
Serial.println("clockwise");
delay(1000); // Espera 500 milisegundos
myStepper.step(-stepsPerRevolution); // Gira el motor 400 pasos a la izquierda
Serial.println("counterclockwise");
delay(1000); // Espera 500 milisegundos
elapsedTime = millis() - startTime; // Actualiza elapsedTime con la diferencia entre el tiempo actual y startTime
long remainingTime = durationB - elapsedTime; // Calcula el tiempo restante como la diferencia entre la duración del programa y elapsedTime
int minutes = remainingTime / 60000; // Calcula el número de minutos restantes
int seconds = (remainingTime % 60000) / 1000; // Calcula el número de segundos restantes
lcd.setCursor(0, 1); // Coloca el cursor en la primera columna de la segunda fila
lcd.print(minutes); // Imprime el número de minutos restantes en el LCD
lcd.setCursor(1, 1); // Coloca el cursor en la primera columna de la segunda fila
lcd.print(":"); // Imprime el número de minutos restantes en el LCD
// Verifica si el número de segundos es menor que 10
lcd.setCursor(2, 1);
if (seconds < 10) {
lcd.print("0"); // Imprime un cero adicional si el número de segundos es menor que 10
}
lcd.print(seconds); // Imprime el número de segundos restantes en el LCD
}
lcd.clear();
lcd.setCursor(0,1);
lcd.print("vaciando TANQUE");
lcd.println(" ");
digitalWrite(43, HIGH);
delay(4000);
digitalWrite(43, LOW);
lcd.clear();
lcd.print("BLEACH ");
lcd.println(" 2/3");
////// BLEACH /////
////// LImPIEZAAAAAAA /////
for(int i = 0; i <= 2;i++ ){
analogRead(A11);
if (analogRead(A11) < 100)
{
digitalWrite(29, LOW);
digitalWrite(33, LOW);
Serial.println("SENSOR ACTIVADO");
delay(500);
}
else if (analogRead(A11) > 100)
{
digitalWrite(29, HIGH);
digitalWrite(33, HIGH);
Serial.println("INGRESANDO AGUA");
delay(500);
i=i-1;
}
}
digitalWrite(11, HIGH); //prender bomba pumpfill
delay(500);
lcd.clear();
lcd.setCursor(3,1);
lcd.print("ingresando AGUA");
lcd.println("al tanque");
delay(12000); //probar con cuanto llena el tanque 240 APROX 8segundos
digitalWrite(11, LOW);
lcd.clear();
lcd.setCursor(0, 1); // Coloca el cursor en la primera columna de la primera fila
lcd.print("Tiempo restante:"); // Imprime el texto "Tiempo restante:" en el LCD)
while (elapsedTime < durationW) { // Mientras elapsedTime sea menor que la duración del programa
myStepper.step(stepsPerRevolution); // Gira el motor 400 pasos a la derecha
Serial.println("clockwise");
delay(1000); // Espera 500 milisegundos
myStepper.step(-stepsPerRevolution); // Gira el motor 400 pasos a la izquierda
Serial.println("counterclockwise");
delay(1000); // Espera 500 milisegundos
elapsedTime = millis() - startTime; // Actualiza elapsedTime con la diferencia entre el tiempo actual y startTime
long remainingTime = durationW - elapsedTime; // Calcula el tiempo restante como la diferencia entre la duración del programa y elapsedTime
int minutes = remainingTime / 60000; // Calcula el número de minutos restantes
int seconds = (remainingTime % 60000) / 1000; // Calcula el número de segundos restantes
lcd.setCursor(0, 2); // Coloca el cursor en la primera columna de la segunda fila
lcd.print(minutes); // Imprime el número de minutos restantes en el LCD
lcd.setCursor(1, 2); // Coloca el cursor en la primera columna de la segunda fila
lcd.print(":"); // Imprime el número de minutos restantes en el LCD
// Verifica si el número de segundos es menor que 10
lcd.setCursor(2, 2);
if (seconds < 10) {
lcd.print("0"); // Imprime un cero adicional si el número de segundos es menor que 10
}
lcd.print(seconds); // Imprime el número de segundos restantes en el LCD
}
delay(1000);
lcd.print("vaciando TANQUE");
lcd.println(" ");
digitalWrite(49, HIGH);
delay(4000);
digitalWrite(49, LOW);
lcd.clear();
lcd.print("LIMPIEZA ");
lcd.println(" 2/3");
////// LIMPIEZAAAAA //////////
////// FIJADOR /////
delay(1500);
lcd.clear();
lcd.setCursor(3,1);
lcd.print("INGRESADO FIX");
delay(2000);
//ingresa. agua al tanque interno que calentara el quimico
for(int i = 0; i <= 2;i++ ){
analogRead(A11);
if (analogRead(A11) < 100)
{
digitalWrite(23, LOW);
digitalWrite(33, LOW);
Serial.println("SENSOR ACTIVADO");
delay(500);
}
else if (analogRead(A11) > 100)
{
digitalWrite(23, HIGH);
digitalWrite(33, HIGH);
Serial.println("INGRESANDO QUIMICO");
delay(500);
i=i-1;
}
}
lcd.clear();
lcd.print("CALENTANDO");
lcd.setCursor(2,1);
lcd.print("FIX");
// esscribir codigo para calentar quimico
for (int i = 10; i >= 0; i--) {
// Lee el valor de resistencia del sensor NTC
int sensorValue = analogRead(NTC_PIN);
//////////////////////////////////////////
float temperature = 1 / (log(1 / (1023. / sensorValue - 1)) / B + 1.0 / 298.15) - 273.15;
// Comprueba si la temperatura es menor de 37,8 grados
if (temperature < TEMPERATURE_ON) {
// Enciende el relay
lcd.setCursor(0,2);
lcd.print(temperature);
digitalWrite(22, HIGH);
lcd.setCursor(6,2);
lcd.print("ENCENDIDO");
i=i+1;
}
// Comprueba si la temperatura es mayor o igual a 38 grados
else if (temperature >= TEMPERATURE_OFF) {
// Apaga el relay
digitalWrite(22, LOW);
lcd.setCursor(0,2);
lcd.print(temperature);
lcd.setCursor(6,2);
lcd.print("ENFRIANDO");
i=i+1;
}
// Si la temperatura está entre 37,8 y 38 grados
else {
lcd.setCursor(0,2);
lcd.print(temperature);
lcd.setCursor(8,3);
lcd.print(i);
// No hace nada, deja el relay en su estado actual
}
// Espera 1 segundo antes de volver a medir
delay(1000);
}
digitalWrite(11, HIGH); //prender bomba pumpfill
delay(500);
lcd.clear();
lcd.setCursor(3,1);
lcd.print("ingresando FIJADOR");
lcd.println("al tanque");
delay(5000); //probar con cuanto llena el tanque
digitalWrite(11, LOW);
delay (2000);
//codigo motor agregar const duration y numero para que gire el motor durante distintos tiempos
lcd.clear();
lcd.setCursor(0, 0); // Coloca el cursor en la primera columna de la primera fila
lcd.print("Tiempo restante:"); // Imprime el texto "Tiempo restante:" en el LCD)
while (elapsedTime < durationF) { // Mientras elapsedTime sea menor que la duración del programa
myStepper.step(stepsPerRevolution); // Gira el motor 400 pasos a la derecha
Serial.println("clockwise");
delay(1000); // Espera 500 milisegundos
myStepper.step(-stepsPerRevolution); // Gira el motor 400 pasos a la izquierda
Serial.println("counterclockwise");
delay(1000); // Espera 500 milisegundos
elapsedTime = millis() - startTime; // Actualiza elapsedTime con la diferencia entre el tiempo actual y startTime
long remainingTime = durationF - elapsedTime; // Calcula el tiempo restante como la diferencia entre la duración del programa y elapsedTime
int minutes = remainingTime / 60000; // Calcula el número de minutos restantes
int seconds = (remainingTime % 60000) / 1000; // Calcula el número de segundos restantes
lcd.setCursor(0, 1); // Coloca el cursor en la primera columna de la segunda fila
lcd.print(minutes); // Imprime el número de minutos restantes en el LCD
lcd.setCursor(1, 1); // Coloca el cursor en la primera columna de la segunda fila
lcd.print(":"); // Imprime el número de minutos restantes en el LCD
// Verifica si el número de segundos es menor que 10
lcd.setCursor(2, 1);
if (seconds < 10) {
lcd.print("0"); // Imprime un cero adicional si el número de segundos es menor que 10
}
lcd.print(seconds); // Imprime el número de segundos restantes en el LCD
}
lcd.clear();
lcd.setCursor(0,1);
lcd.print("vaciando TANQUE");
lcd.println(" ");
digitalWrite(45, HIGH);
delay(4000);
digitalWrite(45, LOW);
lcd.clear();
lcd.print("FIX ");
lcd.println(" 3/3");
////// FIJADOR /////
////// LImPIEZAAAAAAA /////
for(int i = 0; i <= 2;i++ ){
analogRead(A11);
if (analogRead(A11) < 100)
{
digitalWrite(27, LOW);
digitalWrite(33, LOW);
Serial.println("SENSOR ACTIVADO");
delay(500);
}
else if (analogRead(A11) > 100)
{
digitalWrite(27, HIGH);
digitalWrite(33, HIGH);
Serial.println("INGRESANDO AGUA");
delay(500);
i=i-1;
}
}
digitalWrite(11, HIGH); //prender bomba pumpfill
delay(500);
lcd.clear();
lcd.setCursor(3,1);
lcd.print("ingresando AGUA");
lcd.println("al tanque");
delay(12000); //probar con cuanto llena el tanque 240 APROX 8segundos
digitalWrite(11, LOW);
lcd.clear();
lcd.setCursor(0, 1); // Coloca el cursor en la primera columna de la primera fila
lcd.print("Tiempo restante:"); // Imprime el texto "Tiempo restante:" en el LCD)
while (elapsedTime < durationW) { // Mientras elapsedTime sea menor que la duración del programa
myStepper.step(stepsPerRevolution); // Gira el motor 400 pasos a la derecha
Serial.println("clockwise");
delay(1000); // Espera 500 milisegundos
myStepper.step(-stepsPerRevolution); // Gira el motor 400 pasos a la izquierda
Serial.println("counterclockwise");
delay(1000); // Espera 500 milisegundos
elapsedTime = millis() - startTime; // Actualiza elapsedTime con la diferencia entre el tiempo actual y startTime
long remainingTime = durationW - elapsedTime; // Calcula el tiempo restante como la diferencia entre la duración del programa y elapsedTime
int minutes = remainingTime / 60000; // Calcula el número de minutos restantes
int seconds = (remainingTime % 60000) / 1000; // Calcula el número de segundos restantes
lcd.setCursor(0, 2); // Coloca el cursor en la primera columna de la segunda fila
lcd.print(minutes); // Imprime el número de minutos restantes en el LCD
lcd.setCursor(1, 2); // Coloca el cursor en la primera columna de la segunda fila
lcd.print(":"); // Imprime el número de minutos restantes en el LCD
// Verifica si el número de segundos es menor que 10
lcd.setCursor(2, 2);
if (seconds < 10) {
lcd.print("0"); // Imprime un cero adicional si el número de segundos es menor que 10
}
lcd.print(seconds); // Imprime el número de segundos restantes en el LCD
}
delay(1000);
lcd.print("vaciando TANQUE");
lcd.println(" ");
digitalWrite(49, HIGH);
delay(4000);
digitalWrite(49, LOW);
lcd.clear();
lcd.print("LIMPIEZA ");
lcd.println(" 3/3");
delay(4000);
lcd.clear();
lcd.print("PROCESO C41 ");
lcd.println(" FIN");
delay(4000);
////// LIMPIEZAAAAA //////////
menuSystem.setScreen(0);
menuSystem.setId(0);
menuSystem.show();
}
void action9(byte screen, byte id, byte line, int value)
{
Serial.println(F("action9"));
(void)screen;
(void)id;
(void)line;
(void)value;
lcd.clear();
lcd.print(F("-Executing c41 570ml"));
delay(2500);
lcd.clear();
lcd.print("-Ejecutando C41");
////// C41 /////
delay(1500);
lcd.clear();
lcd.setCursor(3,1);
lcd.print("INGRESANDO C41 240 ");
delay(2000);
//ingresa. agua al tanque interno que calentara el quimico
for(int i = 0; i <= 2;i++ ){
analogRead(A11);
if (analogRead(A11) < 100)
{
digitalWrite(23, LOW);
digitalWrite(33, LOW);
Serial.println("SENSOR ACTIVADO");
delay(500);
}
else if (analogRead(A11) > 100)
{
digitalWrite(23, HIGH);
digitalWrite(33, HIGH);
Serial.println("INGRESANDO QUIMICO");
delay(500);
i=i-1;
}
}
lcd.clear();
lcd.print("CALENTANDO");
lcd.setCursor(2,1);
lcd.print("QUIMICOS");
// esscribir codigo para calentar quimico
for (int i = 10; i >= 0; i--) {
// Lee el valor de resistencia del sensor NTC
int sensorValue = analogRead(NTC_PIN);
//////////////////////////////////////////
float temperature = 1 / (log(1 / (1023. / sensorValue - 1)) / B + 1.0 / 298.15) - 273.15;
// Comprueba si la temperatura es menor de 37,8 grados
if (temperature < TEMPERATURE_ON) {
// Enciende el relay
lcd.setCursor(0,2);
lcd.print(temperature);
digitalWrite(22, HIGH);
lcd.setCursor(6,2);
lcd.print("ENCENDIDO");
i=i+1;
}
// Comprueba si la temperatura es mayor o igual a 38 grados
else if (temperature >= TEMPERATURE_OFF) {
// Apaga el relay
digitalWrite(22, LOW);
lcd.setCursor(0,2);
lcd.print(temperature);
lcd.setCursor(6,2);
lcd.print("ENFRIANDO");
i=i+1;
}
// Si la temperatura está entre 37,8 y 38 grados
else {
lcd.setCursor(0,2);
lcd.print(temperature);
lcd.setCursor(8,3);
lcd.print(i);
// No hace nada, deja el relay en su estado actual
}
// Espera 1 segundo antes de volver a medir
delay(1000);
}
digitalWrite(47, HIGH);
digitalWrite(11, HIGH); //prender bomba pumpfill
delay(500);
lcd.clear();
lcd.setCursor(3,1);
lcd.print("ingresando C41");
lcd.println("al tanque");
delay(5000); //probar con cuanto llena el tanque
digitalWrite(47, LOW);
digitalWrite(11, LOW);
delay (2000);
//codigo motor agregar const duration y numero para que gire el motor durante distintos tiempos
lcd.clear();
lcd.setCursor(0, 0); // Coloca el cursor en la primera columna de la primera fila
lcd.print("Tiempo restante:"); // Imprime el texto "Tiempo restante:" en el LCD)
long startTime = millis(); // Guarda el tiempo actual en milisegundos en la variable startTime
long elapsedTime = 0; // Inicializa la variable elapsedTime en 0
while (elapsedTime < durationC1) { // Mientras elapsedTime sea menor que la duración del programa
myStepper.step(stepsPerRevolution); // Gira el motor 400 pasos a la derecha
Serial.println("clockwise");
delay(1000); // Espera 500 milisegundos
myStepper.step(-stepsPerRevolution); // Gira el motor 400 pasos a la izquierda
Serial.println("counterclockwise");
delay(1000); // Espera 500 milisegundos
elapsedTime = millis() - startTime; // Actualiza elapsedTime con la diferencia entre el tiempo actual y startTime
long remainingTime = durationC1 - elapsedTime; // Calcula el tiempo restante como la diferencia entre la duración del programa y elapsedTime
int minutes = remainingTime / 60000; // Calcula el número de minutos restantes
int seconds = (remainingTime % 60000) / 1000; // Calcula el número de segundos restantes
lcd.setCursor(0, 1); // Coloca el cursor en la primera columna de la segunda fila
lcd.print(minutes); // Imprime el número de minutos restantes en el LCD
lcd.setCursor(1, 1); // Coloca el cursor en la primera columna de la segunda fila
lcd.print(":"); // Imprime el número de minutos restantes en el LCD
// Verifica si el número de segundos es menor que 10
lcd.setCursor(2, 1);
if (seconds < 10) {
lcd.print("0"); // Imprime un cero adicional si el número de segundos es menor que 10
}
lcd.print(seconds); // Imprime el número de segundos restantes en el LCD
}
lcd.clear();
lcd.setCursor(0,1);
lcd.print("vaciando TANQUE");
lcd.println(" ");
digitalWrite(41, HIGH);
delay(4000);
digitalWrite(41, LOW);
lcd.clear();
lcd.print("C41 ");
lcd.println(" 1/3");
////// c41 /////
delay(1000);
////// LImPIEZAAAAAAA /////
lcd.clear();
lcd.print("activando limpieza ");
lcd.println(" 1/3");
for(int i = 0; i <= 2;i++ ){
analogRead(A11);
if (analogRead(A11) < 100)
{
digitalWrite(29, LOW);
digitalWrite(33, LOW);
Serial.println("SENSOR ACTIVADO");
delay(500);
}
else if (analogRead(A11) > 100)
{
digitalWrite(29, HIGH);
digitalWrite(33, HIGH);
Serial.println("INGRESANDO AGUA");
delay(500);
i=i-1;
}
}
digitalWrite(11, HIGH); //prender bomba pumpfill
delay(500);
lcd.clear();
lcd.setCursor(3,1);
lcd.print("ingresando AGUA");
lcd.println("al tanque");
delay(12000); //probar con cuanto llena el tanque 240 APROX 8segundos
digitalWrite(11, LOW);
lcd.clear();
lcd.setCursor(0, 1); // Coloca el cursor en la primera columna de la primera fila
lcd.print("Tiempo restante:"); // Imprime el texto "Tiempo restante:" en el LCD)
while (elapsedTime < durationW) { // Mientras elapsedTime sea menor que la duración del programa
myStepper.step(stepsPerRevolution); // Gira el motor 400 pasos a la derecha
Serial.println("clockwise");
delay(1000); // Espera 500 milisegundos
myStepper.step(-stepsPerRevolution); // Gira el motor 400 pasos a la izquierda
Serial.println("counterclockwise");
delay(1000); // Espera 500 milisegundos
elapsedTime = millis() - startTime; // Actualiza elapsedTime con la diferencia entre el tiempo actual y startTime
long remainingTime = durationW - elapsedTime; // Calcula el tiempo restante como la diferencia entre la duración del programa y elapsedTime
int minutes = remainingTime / 60000; // Calcula el número de minutos restantes
int seconds = (remainingTime % 60000) / 1000; // Calcula el número de segundos restantes
lcd.setCursor(0, 2); // Coloca el cursor en la primera columna de la segunda fila
lcd.print(minutes); // Imprime el número de minutos restantes en el LCD
lcd.setCursor(1, 2); // Coloca el cursor en la primera columna de la segunda fila
lcd.print(":"); // Imprime el número de minutos restantes en el LCD
// Verifica si el número de segundos es menor que 10
lcd.setCursor(2, 2);
if (seconds < 10) {
lcd.print("0"); // Imprime un cero adicional si el número de segundos es menor que 10
}
lcd.print(seconds); // Imprime el número de segundos restantes en el LCD
}
delay(1000);
lcd.print("vaciando TANQUE");
lcd.println(" ");
digitalWrite(49, HIGH);
delay(4000);
digitalWrite(49, LOW);
lcd.clear();
lcd.print("LIMPIEZA ");
lcd.println(" 1/3");
////// LIMPIEZAAAAA //////////
////// bleach /////
delay(1500);
lcd.clear();
lcd.setCursor(3,1);
lcd.print("INGRESADO BLEACH ");
delay(2000);
//ingresa. agua al tanque interno que calentara el quimico
for(int i = 0; i <= 2;i++ ){
analogRead(A11);
if (analogRead(A11) < 100)
{
digitalWrite(25, LOW);
digitalWrite(33, LOW);
Serial.println("SENSOR ACTIVADO");
delay(500);
}
else if (analogRead(A11) > 100)
{
digitalWrite(25, HIGH);
digitalWrite(33, HIGH);
Serial.println("INGRESANDO QUIMICO");
delay(500);
i=i-1;
}
}
lcd.clear();
lcd.print("CALENTANDO");
lcd.setCursor(2,1);
lcd.print("BLEACH");
// esscribir codigo para calentar quimico
for (int i = 10; i >= 0; i--) {
// Lee el valor de resistencia del sensor NTC
int sensorValue = analogRead(NTC_PIN);
//////////////////////////////////////////
float temperature = 1 / (log(1 / (1023. / sensorValue - 1)) / B + 1.0 / 298.15) - 273.15;
// Comprueba si la temperatura es menor de 37,8 grados
if (temperature < TEMPERATURE_ON) {
// Enciende el relay
lcd.setCursor(0,2);
lcd.print(temperature);
digitalWrite(22, HIGH);
lcd.setCursor(6,2);
lcd.print("ENCENDIDO");
i=i+1;
}
// Comprueba si la temperatura es mayor o igual a 38 grados
else if (temperature >= TEMPERATURE_OFF) {
// Apaga el relay
digitalWrite(22, LOW);
lcd.setCursor(0,2);
lcd.print(temperature);
lcd.setCursor(6,2);
lcd.print("ENFRIANDO");
i=i+1;
}
// Si la temperatura está entre 37,8 y 38 grados
else {
lcd.setCursor(0,2);
lcd.print(temperature);
lcd.setCursor(8,3);
lcd.print(i);
// No hace nada, deja el relay en su estado actual
}
// Espera 1 segundo antes de volver a medir
delay(1000);
}
digitalWrite(11, HIGH); //prender bomba pumpfill
delay(500);
lcd.clear();
lcd.setCursor(3,1);
lcd.print("ingresando BLEACH");
lcd.println("al tanque");
delay(5000); //probar con cuanto llena el tanque
digitalWrite(11, LOW);
delay (2000);
//codigo motor agregar const duration y numero para que gire el motor durante distintos tiempos
lcd.clear();
lcd.setCursor(0, 0); // Coloca el cursor en la primera columna de la primera fila
lcd.print("Tiempo restante:"); // Imprime el texto "Tiempo restante:" en el LCD)
while (elapsedTime < durationB) { // Mientras elapsedTime sea menor que la duración del programa
myStepper.step(stepsPerRevolution); // Gira el motor 400 pasos a la derecha
Serial.println("clockwise");
delay(1000); // Espera 500 milisegundos
myStepper.step(-stepsPerRevolution); // Gira el motor 400 pasos a la izquierda
Serial.println("counterclockwise");
delay(1000); // Espera 500 milisegundos
elapsedTime = millis() - startTime; // Actualiza elapsedTime con la diferencia entre el tiempo actual y startTime
long remainingTime = durationB - elapsedTime; // Calcula el tiempo restante como la diferencia entre la duración del programa y elapsedTime
int minutes = remainingTime / 60000; // Calcula el número de minutos restantes
int seconds = (remainingTime % 60000) / 1000; // Calcula el número de segundos restantes
lcd.setCursor(0, 1); // Coloca el cursor en la primera columna de la segunda fila
lcd.print(minutes); // Imprime el número de minutos restantes en el LCD
lcd.setCursor(1, 1); // Coloca el cursor en la primera columna de la segunda fila
lcd.print(":"); // Imprime el número de minutos restantes en el LCD
// Verifica si el número de segundos es menor que 10
lcd.setCursor(2, 1);
if (seconds < 10) {
lcd.print("0"); // Imprime un cero adicional si el número de segundos es menor que 10
}
lcd.print(seconds); // Imprime el número de segundos restantes en el LCD
}
lcd.clear();
lcd.setCursor(0,1);
lcd.print("vaciando TANQUE");
lcd.println(" ");
digitalWrite(43, HIGH);
delay(4000);
digitalWrite(43, LOW);
lcd.clear();
lcd.print("BLEACH ");
lcd.println(" 2/3");
////// BLEACH /////
////// LImPIEZAAAAAAA /////
for(int i = 0; i <= 2;i++ ){
analogRead(A11);
if (analogRead(A11) < 100)
{
digitalWrite(29, LOW);
digitalWrite(33, LOW);
Serial.println("SENSOR ACTIVADO");
delay(500);
}
else if (analogRead(A11) > 100)
{
digitalWrite(29, HIGH);
digitalWrite(33, HIGH);
Serial.println("INGRESANDO AGUA");
delay(500);
i=i-1;
}
}
digitalWrite(11, HIGH); //prender bomba pumpfill
delay(500);
lcd.clear();
lcd.setCursor(3,1);
lcd.print("ingresando AGUA");
lcd.println("al tanque");
delay(12000); //probar con cuanto llena el tanque 240 APROX 8segundos
digitalWrite(11, LOW);
lcd.clear();
lcd.setCursor(0, 1); // Coloca el cursor en la primera columna de la primera fila
lcd.print("Tiempo restante:"); // Imprime el texto "Tiempo restante:" en el LCD)
while (elapsedTime < durationW) { // Mientras elapsedTime sea menor que la duración del programa
myStepper.step(stepsPerRevolution); // Gira el motor 400 pasos a la derecha
Serial.println("clockwise");
delay(1000); // Espera 500 milisegundos
myStepper.step(-stepsPerRevolution); // Gira el motor 400 pasos a la izquierda
Serial.println("counterclockwise");
delay(1000); // Espera 500 milisegundos
elapsedTime = millis() - startTime; // Actualiza elapsedTime con la diferencia entre el tiempo actual y startTime
long remainingTime = durationW - elapsedTime; // Calcula el tiempo restante como la diferencia entre la duración del programa y elapsedTime
int minutes = remainingTime / 60000; // Calcula el número de minutos restantes
int seconds = (remainingTime % 60000) / 1000; // Calcula el número de segundos restantes
lcd.setCursor(0, 2); // Coloca el cursor en la primera columna de la segunda fila
lcd.print(minutes); // Imprime el número de minutos restantes en el LCD
lcd.setCursor(1, 2); // Coloca el cursor en la primera columna de la segunda fila
lcd.print(":"); // Imprime el número de minutos restantes en el LCD
// Verifica si el número de segundos es menor que 10
lcd.setCursor(2, 2);
if (seconds < 10) {
lcd.print("0"); // Imprime un cero adicional si el número de segundos es menor que 10
}
lcd.print(seconds); // Imprime el número de segundos restantes en el LCD
}
delay(1000);
lcd.print("vaciando TANQUE");
lcd.println(" ");
digitalWrite(49, HIGH);
delay(4000);
digitalWrite(49, LOW);
lcd.clear();
lcd.print("LIMPIEZA ");
lcd.println(" 2/3");
////// LIMPIEZAAAAA //////////
////// FIJADOR /////
delay(1500);
lcd.clear();
lcd.setCursor(3,1);
lcd.print("INGRESADO FIX");
delay(2000);
//ingresa. agua al tanque interno que calentara el quimico
for(int i = 0; i <= 2;i++ ){
analogRead(A11);
if (analogRead(A11) < 100)
{
digitalWrite(23, LOW);
digitalWrite(33, LOW);
Serial.println("SENSOR ACTIVADO");
delay(500);
}
else if (analogRead(A11) > 100)
{
digitalWrite(23, HIGH);
digitalWrite(33, HIGH);
Serial.println("INGRESANDO QUIMICO");
delay(500);
i=i-1;
}
}
lcd.clear();
lcd.print("CALENTANDO");
lcd.setCursor(2,1);
lcd.print("FIX");
// esscribir codigo para calentar quimico
for (int i = 10; i >= 0; i--) {
// Lee el valor de resistencia del sensor NTC
int sensorValue = analogRead(NTC_PIN);
//////////////////////////////////////////
float temperature = 1 / (log(1 / (1023. / sensorValue - 1)) / B + 1.0 / 298.15) - 273.15;
// Comprueba si la temperatura es menor de 37,8 grados
if (temperature < TEMPERATURE_ON) {
// Enciende el relay
lcd.setCursor(0,2);
lcd.print(temperature);
digitalWrite(22, HIGH);
lcd.setCursor(6,2);
lcd.print("ENCENDIDO");
i=i+1;
}
// Comprueba si la temperatura es mayor o igual a 38 grados
else if (temperature >= TEMPERATURE_OFF) {
// Apaga el relay
digitalWrite(22, LOW);
lcd.setCursor(0,2);
lcd.print(temperature);
lcd.setCursor(6,2);
lcd.print("ENFRIANDO");
i=i+1;
}
// Si la temperatura está entre 37,8 y 38 grados
else {
lcd.setCursor(0,2);
lcd.print(temperature);
lcd.setCursor(8,3);
lcd.print(i);
// No hace nada, deja el relay en su estado actual
}
// Espera 1 segundo antes de volver a medir
delay(1000);
}
digitalWrite(11, HIGH); //prender bomba pumpfill
delay(500);
lcd.clear();
lcd.setCursor(3,1);
lcd.print("ingresando FIJADOR");
lcd.println("al tanque");
delay(5000); //probar con cuanto llena el tanque
digitalWrite(11, LOW);
delay (2000);
//codigo motor agregar const duration y numero para que gire el motor durante distintos tiempos
lcd.clear();
lcd.setCursor(0, 0); // Coloca el cursor en la primera columna de la primera fila
lcd.print("Tiempo restante:"); // Imprime el texto "Tiempo restante:" en el LCD)
while (elapsedTime < durationF) { // Mientras elapsedTime sea menor que la duración del programa
myStepper.step(stepsPerRevolution); // Gira el motor 400 pasos a la derecha
Serial.println("clockwise");
delay(1000); // Espera 500 milisegundos
myStepper.step(-stepsPerRevolution); // Gira el motor 400 pasos a la izquierda
Serial.println("counterclockwise");
delay(1000); // Espera 500 milisegundos
elapsedTime = millis() - startTime; // Actualiza elapsedTime con la diferencia entre el tiempo actual y startTime
long remainingTime = durationF - elapsedTime; // Calcula el tiempo restante como la diferencia entre la duración del programa y elapsedTime
int minutes = remainingTime / 60000; // Calcula el número de minutos restantes
int seconds = (remainingTime % 60000) / 1000; // Calcula el número de segundos restantes
lcd.setCursor(0, 1); // Coloca el cursor en la primera columna de la segunda fila
lcd.print(minutes); // Imprime el número de minutos restantes en el LCD
lcd.setCursor(1, 1); // Coloca el cursor en la primera columna de la segunda fila
lcd.print(":"); // Imprime el número de minutos restantes en el LCD
// Verifica si el número de segundos es menor que 10
lcd.setCursor(2, 1);
if (seconds < 10) {
lcd.print("0"); // Imprime un cero adicional si el número de segundos es menor que 10
}
lcd.print(seconds); // Imprime el número de segundos restantes en el LCD
}
lcd.clear();
lcd.setCursor(0,1);
lcd.print("vaciando TANQUE");
lcd.println(" ");
digitalWrite(45, HIGH);
delay(4000);
digitalWrite(45, LOW);
lcd.clear();
lcd.print("FIX ");
lcd.println(" 3/3");
////// FIJADOR /////
////// LImPIEZAAAAAAA /////
for(int i = 0; i <= 2;i++ ){
analogRead(A11);
if (analogRead(A11) < 100)
{
digitalWrite(27, LOW);
digitalWrite(33, LOW);
Serial.println("SENSOR ACTIVADO");
delay(500);
}
else if (analogRead(A11) > 100)
{
digitalWrite(27, HIGH);
digitalWrite(33, HIGH);
Serial.println("INGRESANDO AGUA");
delay(500);
i=i-1;
}
}
digitalWrite(11, HIGH); //prender bomba pumpfill
delay(500);
lcd.clear();
lcd.setCursor(3,1);
lcd.print("ingresando AGUA");
lcd.println("al tanque");
delay(12000); //probar con cuanto llena el tanque 240 APROX 8segundos
digitalWrite(11, LOW);
lcd.clear();
lcd.setCursor(0, 1); // Coloca el cursor en la primera columna de la primera fila
lcd.print("Tiempo restante:"); // Imprime el texto "Tiempo restante:" en el LCD)
while (elapsedTime < durationW) { // Mientras elapsedTime sea menor que la duración del programa
myStepper.step(stepsPerRevolution); // Gira el motor 400 pasos a la derecha
Serial.println("clockwise");
delay(1000); // Espera 500 milisegundos
myStepper.step(-stepsPerRevolution); // Gira el motor 400 pasos a la izquierda
Serial.println("counterclockwise");
delay(1000); // Espera 500 milisegundos
elapsedTime = millis() - startTime; // Actualiza elapsedTime con la diferencia entre el tiempo actual y startTime
long remainingTime = durationW - elapsedTime; // Calcula el tiempo restante como la diferencia entre la duración del programa y elapsedTime
int minutes = remainingTime / 60000; // Calcula el número de minutos restantes
int seconds = (remainingTime % 60000) / 1000; // Calcula el número de segundos restantes
lcd.setCursor(0, 2); // Coloca el cursor en la primera columna de la segunda fila
lcd.print(minutes); // Imprime el número de minutos restantes en el LCD
lcd.setCursor(1, 2); // Coloca el cursor en la primera columna de la segunda fila
lcd.print(":"); // Imprime el número de minutos restantes en el LCD
// Verifica si el número de segundos es menor que 10
lcd.setCursor(2, 2);
if (seconds < 10) {
lcd.print("0"); // Imprime un cero adicional si el número de segundos es menor que 10
}
lcd.print(seconds); // Imprime el número de segundos restantes en el LCD
}
delay(1000);
lcd.print("vaciando TANQUE");
lcd.println(" ");
digitalWrite(49, HIGH);
delay(4000);
digitalWrite(49, LOW);
lcd.clear();
lcd.print("LIMPIEZA ");
lcd.println(" 3/3");
delay(4000);
lcd.clear();
lcd.print("PROCESO C41 ");
lcd.println(" FIN");
delay(4000);
////// LIMPIEZAAAAA //////////
menuSystem.setScreen(0);
menuSystem.setId(0);
menuSystem.show();
}
void action10(byte screen, byte id, byte line, int value)
{
Serial.println(F("action10"));
(void)screen;
(void)id;
(void)line;
(void)value;
lcd.clear();
lcd.print(F("-Executing c41 570ml"));
delay(2500);
lcd.clear();
lcd.print("-Ejecutando C41");
menuSystem.setScreen(0);
menuSystem.setId(0);
menuSystem.show();
}
void action11(byte screen, byte id, byte line, int value)
{
Serial.println(F("action11"));
(void)screen;
(void)id;
(void)line;
(void)value;
lcd.clear();
lcd.print(F("-Executing c41 +2 240"));
delay(2500);
lcd.clear();
lcd.print("-Ejecutando C41");
////// C41 /////
delay(1500);
lcd.clear();
lcd.setCursor(3,1);
lcd.print("INGRESANDO C41 +2 240 ");
delay(2000);
//ingresa. agua al tanque interno que calentara el quimico
for(int i = 0; i <= 2;i++ ){
analogRead(A11);
if (analogRead(A11) < 100)
{
digitalWrite(23, LOW);
digitalWrite(33, LOW);
Serial.println("SENSOR ACTIVADO");
delay(500);
}
else if (analogRead(A11) > 100)
{
digitalWrite(23, HIGH);
digitalWrite(33, HIGH);
Serial.println("INGRESANDO QUIMICO");
delay(500);
i=i-1;
}
}
lcd.clear();
lcd.print("CALENTANDO");
lcd.setCursor(2,1);
lcd.print("QUIMICOS");
// esscribir codigo para calentar quimico
for (int i = 10; i >= 0; i--) {
// Lee el valor de resistencia del sensor NTC
int sensorValue = analogRead(NTC_PIN);
//////////////////////////////////////////
float temperature = 1 / (log(1 / (1023. / sensorValue - 1)) / B + 1.0 / 298.15) - 273.15;
// Comprueba si la temperatura es menor de 37,8 grados
if (temperature < TEMPERATURE_ON) {
// Enciende el relay
lcd.setCursor(0,2);
lcd.print(temperature);
digitalWrite(22, HIGH);
lcd.setCursor(6,2);
lcd.print("ENCENDIDO");
i=i+1;
}
// Comprueba si la temperatura es mayor o igual a 38 grados
else if (temperature >= TEMPERATURE_OFF) {
// Apaga el relay
digitalWrite(22, LOW);
lcd.setCursor(0,2);
lcd.print(temperature);
lcd.setCursor(6,2);
lcd.print("ENFRIANDO");
i=i+1;
}
// Si la temperatura está entre 37,8 y 38 grados
else {
lcd.setCursor(0,2);
lcd.print(temperature);
lcd.setCursor(8,3);
lcd.print(i);
// No hace nada, deja el relay en su estado actual
}
// Espera 1 segundo antes de volver a medir
delay(1000);
}
digitalWrite(47, HIGH);
digitalWrite(11, HIGH); //prender bomba pumpfill
delay(500);
lcd.clear();
lcd.setCursor(3,1);
lcd.print("ingresando C41");
lcd.println("al tanque");
delay(5000); //probar con cuanto llena el tanque
digitalWrite(47, LOW);
digitalWrite(11, LOW);
delay (2000);
//codigo motor agregar const duration y numero para que gire el motor durante distintos tiempos
lcd.clear();
lcd.setCursor(0, 0); // Coloca el cursor en la primera columna de la primera fila
lcd.print("Tiempo restante:"); // Imprime el texto "Tiempo restante:" en el LCD)
long startTime = millis(); // Guarda el tiempo actual en milisegundos en la variable startTime
long elapsedTime = 0; // Inicializa la variable elapsedTime en 0
while (elapsedTime < durationC2) { // Mientras elapsedTime sea menor que la duración del programa
myStepper.step(stepsPerRevolution); // Gira el motor 400 pasos a la derecha
Serial.println("clockwise");
delay(1000); // Espera 500 milisegundos
myStepper.step(-stepsPerRevolution); // Gira el motor 400 pasos a la izquierda
Serial.println("counterclockwise");
delay(1000); // Espera 500 milisegundos
elapsedTime = millis() - startTime; // Actualiza elapsedTime con la diferencia entre el tiempo actual y startTime
long remainingTime = durationC2 - elapsedTime; // Calcula el tiempo restante como la diferencia entre la duración del programa y elapsedTime
int minutes = remainingTime / 60000; // Calcula el número de minutos restantes
int seconds = (remainingTime % 60000) / 1000; // Calcula el número de segundos restantes
lcd.setCursor(0, 1); // Coloca el cursor en la primera columna de la segunda fila
lcd.print(minutes); // Imprime el número de minutos restantes en el LCD
lcd.setCursor(1, 1); // Coloca el cursor en la primera columna de la segunda fila
lcd.print(":"); // Imprime el número de minutos restantes en el LCD
// Verifica si el número de segundos es menor que 10
lcd.setCursor(2, 1);
if (seconds < 10) {
lcd.print("0"); // Imprime un cero adicional si el número de segundos es menor que 10
}
lcd.print(seconds); // Imprime el número de segundos restantes en el LCD
}
lcd.clear();
lcd.setCursor(0,1);
lcd.print("vaciando TANQUE");
lcd.println(" ");
digitalWrite(41, HIGH);
delay(4000);
digitalWrite(41, LOW);
lcd.clear();
lcd.print("C41 ");
lcd.println(" 1/3");
////// c41 /////
delay(1000);
////// LImPIEZAAAAAAA /////
lcd.clear();
lcd.print("activando limpieza ");
lcd.println(" 1/3");
for(int i = 0; i <= 2;i++ ){
analogRead(A11);
if (analogRead(A11) < 100)
{
digitalWrite(29, LOW);
digitalWrite(33, LOW);
Serial.println("SENSOR ACTIVADO");
delay(500);
}
else if (analogRead(A11) > 100)
{
digitalWrite(29, HIGH);
digitalWrite(33, HIGH);
Serial.println("INGRESANDO AGUA");
delay(500);
i=i-1;
}
}
digitalWrite(11, HIGH); //prender bomba pumpfill
delay(500);
lcd.clear();
lcd.setCursor(3,1);
lcd.print("ingresando AGUA");
lcd.println("al tanque");
delay(12000); //probar con cuanto llena el tanque 240 APROX 8segundos
digitalWrite(11, LOW);
lcd.clear();
lcd.setCursor(0, 1); // Coloca el cursor en la primera columna de la primera fila
lcd.print("Tiempo restante:"); // Imprime el texto "Tiempo restante:" en el LCD)
while (elapsedTime < durationW) { // Mientras elapsedTime sea menor que la duración del programa
myStepper.step(stepsPerRevolution); // Gira el motor 400 pasos a la derecha
Serial.println("clockwise");
delay(1000); // Espera 500 milisegundos
myStepper.step(-stepsPerRevolution); // Gira el motor 400 pasos a la izquierda
Serial.println("counterclockwise");
delay(1000); // Espera 500 milisegundos
elapsedTime = millis() - startTime; // Actualiza elapsedTime con la diferencia entre el tiempo actual y startTime
long remainingTime = durationW - elapsedTime; // Calcula el tiempo restante como la diferencia entre la duración del programa y elapsedTime
int minutes = remainingTime / 60000; // Calcula el número de minutos restantes
int seconds = (remainingTime % 60000) / 1000; // Calcula el número de segundos restantes
lcd.setCursor(0, 2); // Coloca el cursor en la primera columna de la segunda fila
lcd.print(minutes); // Imprime el número de minutos restantes en el LCD
lcd.setCursor(1, 2); // Coloca el cursor en la primera columna de la segunda fila
lcd.print(":"); // Imprime el número de minutos restantes en el LCD
// Verifica si el número de segundos es menor que 10
lcd.setCursor(2, 2);
if (seconds < 10) {
lcd.print("0"); // Imprime un cero adicional si el número de segundos es menor que 10
}
lcd.print(seconds); // Imprime el número de segundos restantes en el LCD
}
delay(1000);
lcd.print("vaciando TANQUE");
lcd.println(" ");
digitalWrite(49, HIGH);
delay(4000);
digitalWrite(49, LOW);
lcd.clear();
lcd.print("LIMPIEZA ");
lcd.println(" 1/3");
////// LIMPIEZAAAAA //////////
////// bleach /////
delay(1500);
lcd.clear();
lcd.setCursor(3,1);
lcd.print("INGRESADO BLEACH ");
delay(2000);
//ingresa. agua al tanque interno que calentara el quimico
for(int i = 0; i <= 2;i++ ){
analogRead(A11);
if (analogRead(A11) < 100)
{
digitalWrite(25, LOW);
digitalWrite(33, LOW);
Serial.println("SENSOR ACTIVADO");
delay(500);
}
else if (analogRead(A11) > 100)
{
digitalWrite(25, HIGH);
digitalWrite(33, HIGH);
Serial.println("INGRESANDO QUIMICO");
delay(500);
i=i-1;
}
}
lcd.clear();
lcd.print("CALENTANDO");
lcd.setCursor(2,1);
lcd.print("BLEACH");
// esscribir codigo para calentar quimico
for (int i = 10; i >= 0; i--) {
// Lee el valor de resistencia del sensor NTC
int sensorValue = analogRead(NTC_PIN);
//////////////////////////////////////////
float temperature = 1 / (log(1 / (1023. / sensorValue - 1)) / B + 1.0 / 298.15) - 273.15;
// Comprueba si la temperatura es menor de 37,8 grados
if (temperature < TEMPERATURE_ON) {
// Enciende el relay
lcd.setCursor(0,2);
lcd.print(temperature);
digitalWrite(22, HIGH);
lcd.setCursor(6,2);
lcd.print("ENCENDIDO");
i=i+1;
}
// Comprueba si la temperatura es mayor o igual a 38 grados
else if (temperature >= TEMPERATURE_OFF) {
// Apaga el relay
digitalWrite(22, LOW);
lcd.setCursor(0,2);
lcd.print(temperature);
lcd.setCursor(6,2);
lcd.print("ENFRIANDO");
i=i+1;
}
// Si la temperatura está entre 37,8 y 38 grados
else {
lcd.setCursor(0,2);
lcd.print(temperature);
lcd.setCursor(8,3);
lcd.print(i);
// No hace nada, deja el relay en su estado actual
}
// Espera 1 segundo antes de volver a medir
delay(1000);
}
digitalWrite(11, HIGH); //prender bomba pumpfill
delay(500);
lcd.clear();
lcd.setCursor(3,1);
lcd.print("ingresando BLEACH");
lcd.println("al tanque");
delay(5000); //probar con cuanto llena el tanque
digitalWrite(11, LOW);
delay (2000);
//codigo motor agregar const duration y numero para que gire el motor durante distintos tiempos
lcd.clear();
lcd.setCursor(0, 0); // Coloca el cursor en la primera columna de la primera fila
lcd.print("Tiempo restante:"); // Imprime el texto "Tiempo restante:" en el LCD)
while (elapsedTime < durationB) { // Mientras elapsedTime sea menor que la duración del programa
myStepper.step(stepsPerRevolution); // Gira el motor 400 pasos a la derecha
Serial.println("clockwise");
delay(1000); // Espera 500 milisegundos
myStepper.step(-stepsPerRevolution); // Gira el motor 400 pasos a la izquierda
Serial.println("counterclockwise");
delay(1000); // Espera 500 milisegundos
elapsedTime = millis() - startTime; // Actualiza elapsedTime con la diferencia entre el tiempo actual y startTime
long remainingTime = durationB - elapsedTime; // Calcula el tiempo restante como la diferencia entre la duración del programa y elapsedTime
int minutes = remainingTime / 60000; // Calcula el número de minutos restantes
int seconds = (remainingTime % 60000) / 1000; // Calcula el número de segundos restantes
lcd.setCursor(0, 1); // Coloca el cursor en la primera columna de la segunda fila
lcd.print(minutes); // Imprime el número de minutos restantes en el LCD
lcd.setCursor(1, 1); // Coloca el cursor en la primera columna de la segunda fila
lcd.print(":"); // Imprime el número de minutos restantes en el LCD
// Verifica si el número de segundos es menor que 10
lcd.setCursor(2, 1);
if (seconds < 10) {
lcd.print("0"); // Imprime un cero adicional si el número de segundos es menor que 10
}
lcd.print(seconds); // Imprime el número de segundos restantes en el LCD
}
lcd.clear();
lcd.setCursor(0,1);
lcd.print("vaciando TANQUE");
lcd.println(" ");
digitalWrite(43, HIGH);
delay(4000);
digitalWrite(43, LOW);
lcd.clear();
lcd.print("BLEACH ");
lcd.println(" 2/3");
////// BLEACH /////
////// LImPIEZAAAAAAA /////
for(int i = 0; i <= 2;i++ ){
analogRead(A11);
if (analogRead(A11) < 100)
{
digitalWrite(29, LOW);
digitalWrite(33, LOW);
Serial.println("SENSOR ACTIVADO");
delay(500);
}
else if (analogRead(A11) > 100)
{
digitalWrite(29, HIGH);
digitalWrite(33, HIGH);
Serial.println("INGRESANDO AGUA");
delay(500);
i=i-1;
}
}
digitalWrite(11, HIGH); //prender bomba pumpfill
delay(500);
lcd.clear();
lcd.setCursor(3,1);
lcd.print("ingresando AGUA");
lcd.println("al tanque");
delay(12000); //probar con cuanto llena el tanque 240 APROX 8segundos
digitalWrite(11, LOW);
lcd.clear();
lcd.setCursor(0, 1); // Coloca el cursor en la primera columna de la primera fila
lcd.print("Tiempo restante:"); // Imprime el texto "Tiempo restante:" en el LCD)
while (elapsedTime < durationW) { // Mientras elapsedTime sea menor que la duración del programa
myStepper.step(stepsPerRevolution); // Gira el motor 400 pasos a la derecha
Serial.println("clockwise");
delay(1000); // Espera 500 milisegundos
myStepper.step(-stepsPerRevolution); // Gira el motor 400 pasos a la izquierda
Serial.println("counterclockwise");
delay(1000); // Espera 500 milisegundos
elapsedTime = millis() - startTime; // Actualiza elapsedTime con la diferencia entre el tiempo actual y startTime
long remainingTime = durationW - elapsedTime; // Calcula el tiempo restante como la diferencia entre la duración del programa y elapsedTime
int minutes = remainingTime / 60000; // Calcula el número de minutos restantes
int seconds = (remainingTime % 60000) / 1000; // Calcula el número de segundos restantes
lcd.setCursor(0, 2); // Coloca el cursor en la primera columna de la segunda fila
lcd.print(minutes); // Imprime el número de minutos restantes en el LCD
lcd.setCursor(1, 2); // Coloca el cursor en la primera columna de la segunda fila
lcd.print(":"); // Imprime el número de minutos restantes en el LCD
// Verifica si el número de segundos es menor que 10
lcd.setCursor(2, 2);
if (seconds < 10) {
lcd.print("0"); // Imprime un cero adicional si el número de segundos es menor que 10
}
lcd.print(seconds); // Imprime el número de segundos restantes en el LCD
}
delay(1000);
lcd.print("vaciando TANQUE");
lcd.println(" ");
digitalWrite(49, HIGH);
delay(4000);
digitalWrite(49, LOW);
lcd.clear();
lcd.print("LIMPIEZA ");
lcd.println(" 2/3");
////// LIMPIEZAAAAA //////////
////// FIJADOR /////
delay(1500);
lcd.clear();
lcd.setCursor(3,1);
lcd.print("INGRESADO FIX");
delay(2000);
//ingresa. agua al tanque interno que calentara el quimico
for(int i = 0; i <= 2;i++ ){
analogRead(A11);
if (analogRead(A11) < 100)
{
digitalWrite(23, LOW);
digitalWrite(33, LOW);
Serial.println("SENSOR ACTIVADO");
delay(500);
}
else if (analogRead(A11) > 100)
{
digitalWrite(23, HIGH);
digitalWrite(33, HIGH);
Serial.println("INGRESANDO QUIMICO");
delay(500);
i=i-1;
}
}
lcd.clear();
lcd.print("CALENTANDO");
lcd.setCursor(2,1);
lcd.print("FIX");
// esscribir codigo para calentar quimico
for (int i = 10; i >= 0; i--) {
// Lee el valor de resistencia del sensor NTC
int sensorValue = analogRead(NTC_PIN);
//////////////////////////////////////////
float temperature = 1 / (log(1 / (1023. / sensorValue - 1)) / B + 1.0 / 298.15) - 273.15;
// Comprueba si la temperatura es menor de 37,8 grados
if (temperature < TEMPERATURE_ON) {
// Enciende el relay
lcd.setCursor(0,2);
lcd.print(temperature);
digitalWrite(22, HIGH);
lcd.setCursor(6,2);
lcd.print("ENCENDIDO");
i=i+1;
}
// Comprueba si la temperatura es mayor o igual a 38 grados
else if (temperature >= TEMPERATURE_OFF) {
// Apaga el relay
digitalWrite(22, LOW);
lcd.setCursor(0,2);
lcd.print(temperature);
lcd.setCursor(6,2);
lcd.print("ENFRIANDO");
i=i+1;
}
// Si la temperatura está entre 37,8 y 38 grados
else {
lcd.setCursor(0,2);
lcd.print(temperature);
lcd.setCursor(8,3);
lcd.print(i);
// No hace nada, deja el relay en su estado actual
}
// Espera 1 segundo antes de volver a medir
delay(1000);
}
digitalWrite(11, HIGH); //prender bomba pumpfill
delay(500);
lcd.clear();
lcd.setCursor(3,1);
lcd.print("ingresando FIJADOR");
lcd.println("al tanque");
delay(5000); //probar con cuanto llena el tanque
digitalWrite(11, LOW);
delay (2000);
//codigo motor agregar const duration y numero para que gire el motor durante distintos tiempos
lcd.clear();
lcd.setCursor(0, 0); // Coloca el cursor en la primera columna de la primera fila
lcd.print("Tiempo restante:"); // Imprime el texto "Tiempo restante:" en el LCD)
while (elapsedTime < durationF) { // Mientras elapsedTime sea menor que la duración del programa
myStepper.step(stepsPerRevolution); // Gira el motor 400 pasos a la derecha
Serial.println("clockwise");
delay(1000); // Espera 500 milisegundos
myStepper.step(-stepsPerRevolution); // Gira el motor 400 pasos a la izquierda
Serial.println("counterclockwise");
delay(1000); // Espera 500 milisegundos
elapsedTime = millis() - startTime; // Actualiza elapsedTime con la diferencia entre el tiempo actual y startTime
long remainingTime = durationF - elapsedTime; // Calcula el tiempo restante como la diferencia entre la duración del programa y elapsedTime
int minutes = remainingTime / 60000; // Calcula el número de minutos restantes
int seconds = (remainingTime % 60000) / 1000; // Calcula el número de segundos restantes
lcd.setCursor(0, 1); // Coloca el cursor en la primera columna de la segunda fila
lcd.print(minutes); // Imprime el número de minutos restantes en el LCD
lcd.setCursor(1, 1); // Coloca el cursor en la primera columna de la segunda fila
lcd.print(":"); // Imprime el número de minutos restantes en el LCD
// Verifica si el número de segundos es menor que 10
lcd.setCursor(2, 1);
if (seconds < 10) {
lcd.print("0"); // Imprime un cero adicional si el número de segundos es menor que 10
}
lcd.print(seconds); // Imprime el número de segundos restantes en el LCD
}
lcd.clear();
lcd.setCursor(0,1);
lcd.print("vaciando TANQUE");
lcd.println(" ");
digitalWrite(45, HIGH);
delay(4000);
digitalWrite(45, LOW);
lcd.clear();
lcd.print("FIX ");
lcd.println(" 3/3");
////// FIJADOR /////
////// LImPIEZAAAAAAA /////
for(int i = 0; i <= 2;i++ ){
analogRead(A11);
if (analogRead(A11) < 100)
{
digitalWrite(27, LOW);
digitalWrite(33, LOW);
Serial.println("SENSOR ACTIVADO");
delay(500);
}
else if (analogRead(A11) > 100)
{
digitalWrite(27, HIGH);
digitalWrite(33, HIGH);
Serial.println("INGRESANDO AGUA");
delay(500);
i=i-1;
}
}
digitalWrite(11, HIGH); //prender bomba pumpfill
delay(500);
lcd.clear();
lcd.setCursor(3,1);
lcd.print("ingresando AGUA");
lcd.println("al tanque");
delay(12000); //probar con cuanto llena el tanque 240 APROX 8segundos
digitalWrite(11, LOW);
lcd.clear();
lcd.setCursor(0, 1); // Coloca el cursor en la primera columna de la primera fila
lcd.print("Tiempo restante:"); // Imprime el texto "Tiempo restante:" en el LCD)
while (elapsedTime < durationW) { // Mientras elapsedTime sea menor que la duración del programa
myStepper.step(stepsPerRevolution); // Gira el motor 400 pasos a la derecha
Serial.println("clockwise");
delay(1000); // Espera 500 milisegundos
myStepper.step(-stepsPerRevolution); // Gira el motor 400 pasos a la izquierda
Serial.println("counterclockwise");
delay(1000); // Espera 500 milisegundos
elapsedTime = millis() - startTime; // Actualiza elapsedTime con la diferencia entre el tiempo actual y startTime
long remainingTime = durationW - elapsedTime; // Calcula el tiempo restante como la diferencia entre la duración del programa y elapsedTime
int minutes = remainingTime / 60000; // Calcula el número de minutos restantes
int seconds = (remainingTime % 60000) / 1000; // Calcula el número de segundos restantes
lcd.setCursor(0, 2); // Coloca el cursor en la primera columna de la segunda fila
lcd.print(minutes); // Imprime el número de minutos restantes en el LCD
lcd.setCursor(1, 2); // Coloca el cursor en la primera columna de la segunda fila
lcd.print(":"); // Imprime el número de minutos restantes en el LCD
// Verifica si el número de segundos es menor que 10
lcd.setCursor(2, 2);
if (seconds < 10) {
lcd.print("0"); // Imprime un cero adicional si el número de segundos es menor que 10
}
lcd.print(seconds); // Imprime el número de segundos restantes en el LCD
}
delay(1000);
lcd.print("vaciando TANQUE");
lcd.println(" ");
digitalWrite(49, HIGH);
delay(4000);
digitalWrite(49, LOW);
lcd.clear();
lcd.print("LIMPIEZA ");
lcd.println(" 3/3");
delay(4000);
lcd.clear();
lcd.print("PROCESO C41 ");
lcd.println(" FIN");
delay(4000);
////// LIMPIEZAAAAA //////////
menuSystem.setScreen(0);
menuSystem.setId(0);
menuSystem.show();
}
void action12(byte screen, byte id, byte line, int value)
{
Serial.println(F("action12"));
(void)screen;
(void)id;
(void)line;
(void)value;
lcd.clear();
lcd.print(F("-Executing c41 240 +3"));
delay(2500);
lcd.clear();
lcd.print("-Ejecutando C41 +3 240");
////// C41 /////
delay(1500);
lcd.clear();
lcd.setCursor(3,1);
lcd.print("INGRESANDO C41 240 ");
delay(2000);
//ingresa. agua al tanque interno que calentara el quimico
for(int i = 0; i <= 2;i++ ){
analogRead(A11);
if (analogRead(A11) < 100)
{
digitalWrite(23, LOW);
digitalWrite(33, LOW);
Serial.println("SENSOR ACTIVADO");
delay(500);
}
else if (analogRead(A11) > 100)
{
digitalWrite(23, HIGH);
digitalWrite(33, HIGH);
Serial.println("INGRESANDO QUIMICO");
delay(500);
i=i-1;
}
}
lcd.clear();
lcd.print("CALENTANDO");
lcd.setCursor(2,1);
lcd.print("QUIMICOS");
// esscribir codigo para calentar quimico
for (int i = 10; i >= 0; i--) {
// Lee el valor de resistencia del sensor NTC
int sensorValue = analogRead(NTC_PIN);
//////////////////////////////////////////
float temperature = 1 / (log(1 / (1023. / sensorValue - 1)) / B + 1.0 / 298.15) - 273.15;
// Comprueba si la temperatura es menor de 37,8 grados
if (temperature < TEMPERATURE_ON) {
// Enciende el relay
lcd.setCursor(0,2);
lcd.print(temperature);
digitalWrite(22, HIGH);
lcd.setCursor(6,2);
lcd.print("ENCENDIDO");
i=i+1;
}
// Comprueba si la temperatura es mayor o igual a 38 grados
else if (temperature >= TEMPERATURE_OFF) {
// Apaga el relay
digitalWrite(22, LOW);
lcd.setCursor(0,2);
lcd.print(temperature);
lcd.setCursor(6,2);
lcd.print("ENFRIANDO");
i=i+1;
}
// Si la temperatura está entre 37,8 y 38 grados
else {
lcd.setCursor(0,2);
lcd.print(temperature);
lcd.setCursor(8,3);
lcd.print(i);
// No hace nada, deja el relay en su estado actual
}
// Espera 1 segundo antes de volver a medir
delay(1000);
}
digitalWrite(47, HIGH);
digitalWrite(11, HIGH); //prender bomba pumpfill
delay(500);
lcd.clear();
lcd.setCursor(3,1);
lcd.print("ingresando C41");
lcd.println("al tanque");
delay(5000); //probar con cuanto llena el tanque
digitalWrite(47, LOW);
digitalWrite(11, LOW);
delay (2000);
//codigo motor agregar const duration y numero para que gire el motor durante distintos tiempos
lcd.clear();
lcd.setCursor(0, 0); // Coloca el cursor en la primera columna de la primera fila
lcd.print("Tiempo restante:"); // Imprime el texto "Tiempo restante:" en el LCD)
long startTime = millis(); // Guarda el tiempo actual en milisegundos en la variable startTime
long elapsedTime = 0; // Inicializa la variable elapsedTime en 0
while (elapsedTime < durationC3) { // Mientras elapsedTime sea menor que la duración del programa
myStepper.step(stepsPerRevolution); // Gira el motor 400 pasos a la derecha
Serial.println("clockwise");
delay(1000); // Espera 500 milisegundos
myStepper.step(-stepsPerRevolution); // Gira el motor 400 pasos a la izquierda
Serial.println("counterclockwise");
delay(1000); // Espera 500 milisegundos
elapsedTime = millis() - startTime; // Actualiza elapsedTime con la diferencia entre el tiempo actual y startTime
long remainingTime = durationC3 - elapsedTime; // Calcula el tiempo restante como la diferencia entre la duración del programa y elapsedTime
int minutes = remainingTime / 60000; // Calcula el número de minutos restantes
int seconds = (remainingTime % 60000) / 1000; // Calcula el número de segundos restantes
lcd.setCursor(0, 1); // Coloca el cursor en la primera columna de la segunda fila
lcd.print(minutes); // Imprime el número de minutos restantes en el LCD
lcd.setCursor(1, 1); // Coloca el cursor en la primera columna de la segunda fila
lcd.print(":"); // Imprime el número de minutos restantes en el LCD
// Verifica si el número de segundos es menor que 10
lcd.setCursor(2, 1);
if (seconds < 10) {
lcd.print("0"); // Imprime un cero adicional si el número de segundos es menor que 10
}
lcd.print(seconds); // Imprime el número de segundos restantes en el LCD
}
lcd.clear();
lcd.setCursor(0,1);
lcd.print("vaciando TANQUE");
lcd.println(" ");
digitalWrite(41, HIGH);
delay(4000);
digitalWrite(41, LOW);
lcd.clear();
lcd.print("C41 ");
lcd.println(" 1/3");
////// c41 /////
delay(1000);
////// LImPIEZAAAAAAA /////
lcd.clear();
lcd.print("activando limpieza ");
lcd.println(" 1/3");
for(int i = 0; i <= 2;i++ ){
analogRead(A11);
if (analogRead(A11) < 100)
{
digitalWrite(29, LOW);
digitalWrite(33, LOW);
Serial.println("SENSOR ACTIVADO");
delay(500);
}
else if (analogRead(A11) > 100)
{
digitalWrite(29, HIGH);
digitalWrite(33, HIGH);
Serial.println("INGRESANDO AGUA");
delay(500);
i=i-1;
}
}
digitalWrite(11, HIGH); //prender bomba pumpfill
delay(500);
lcd.clear();
lcd.setCursor(3,1);
lcd.print("ingresando AGUA");
lcd.println("al tanque");
delay(12000); //probar con cuanto llena el tanque 240 APROX 8segundos
digitalWrite(11, LOW);
lcd.clear();
lcd.setCursor(0, 1); // Coloca el cursor en la primera columna de la primera fila
lcd.print("Tiempo restante:"); // Imprime el texto "Tiempo restante:" en el LCD)
while (elapsedTime < durationW) { // Mientras elapsedTime sea menor que la duración del programa
myStepper.step(stepsPerRevolution); // Gira el motor 400 pasos a la derecha
Serial.println("clockwise");
delay(1000); // Espera 500 milisegundos
myStepper.step(-stepsPerRevolution); // Gira el motor 400 pasos a la izquierda
Serial.println("counterclockwise");
delay(1000); // Espera 500 milisegundos
elapsedTime = millis() - startTime; // Actualiza elapsedTime con la diferencia entre el tiempo actual y startTime
long remainingTime = durationW - elapsedTime; // Calcula el tiempo restante como la diferencia entre la duración del programa y elapsedTime
int minutes = remainingTime / 60000; // Calcula el número de minutos restantes
int seconds = (remainingTime % 60000) / 1000; // Calcula el número de segundos restantes
lcd.setCursor(0, 2); // Coloca el cursor en la primera columna de la segunda fila
lcd.print(minutes); // Imprime el número de minutos restantes en el LCD
lcd.setCursor(1, 2); // Coloca el cursor en la primera columna de la segunda fila
lcd.print(":"); // Imprime el número de minutos restantes en el LCD
// Verifica si el número de segundos es menor que 10
lcd.setCursor(2, 2);
if (seconds < 10) {
lcd.print("0"); // Imprime un cero adicional si el número de segundos es menor que 10
}
lcd.print(seconds); // Imprime el número de segundos restantes en el LCD
}
delay(1000);
lcd.print("vaciando TANQUE");
lcd.println(" ");
digitalWrite(49, HIGH);
delay(4000);
digitalWrite(49, LOW);
lcd.clear();
lcd.print("LIMPIEZA ");
lcd.println(" 1/3");
////// LIMPIEZAAAAA //////////
////// bleach /////
delay(1500);
lcd.clear();
lcd.setCursor(3,1);
lcd.print("INGRESADO BLEACH ");
delay(2000);
//ingresa. agua al tanque interno que calentara el quimico
for(int i = 0; i <= 2;i++ ){
analogRead(A11);
if (analogRead(A11) < 100)
{
digitalWrite(25, LOW);
digitalWrite(33, LOW);
Serial.println("SENSOR ACTIVADO");
delay(500);
}
else if (analogRead(A11) > 100)
{
digitalWrite(25, HIGH);
digitalWrite(33, HIGH);
Serial.println("INGRESANDO QUIMICO");
delay(500);
i=i-1;
}
}
lcd.clear();
lcd.print("CALENTANDO");
lcd.setCursor(2,1);
lcd.print("BLEACH");
// esscribir codigo para calentar quimico
for (int i = 10; i >= 0; i--) {
// Lee el valor de resistencia del sensor NTC
int sensorValue = analogRead(NTC_PIN);
//////////////////////////////////////////
float temperature = 1 / (log(1 / (1023. / sensorValue - 1)) / B + 1.0 / 298.15) - 273.15;
// Comprueba si la temperatura es menor de 37,8 grados
if (temperature < TEMPERATURE_ON) {
// Enciende el relay
lcd.setCursor(0,2);
lcd.print(temperature);
digitalWrite(22, HIGH);
lcd.setCursor(6,2);
lcd.print("ENCENDIDO");
i=i+1;
}
// Comprueba si la temperatura es mayor o igual a 38 grados
else if (temperature >= TEMPERATURE_OFF) {
// Apaga el relay
digitalWrite(22, LOW);
lcd.setCursor(0,2);
lcd.print(temperature);
lcd.setCursor(6,2);
lcd.print("ENFRIANDO");
i=i+1;
}
// Si la temperatura está entre 37,8 y 38 grados
else {
lcd.setCursor(0,2);
lcd.print(temperature);
lcd.setCursor(8,3);
lcd.print(i);
// No hace nada, deja el relay en su estado actual
}
// Espera 1 segundo antes de volver a medir
delay(1000);
}
digitalWrite(11, HIGH); //prender bomba pumpfill
delay(500);
lcd.clear();
lcd.setCursor(3,1);
lcd.print("ingresando BLEACH");
lcd.println("al tanque");
delay(5000); //probar con cuanto llena el tanque
digitalWrite(11, LOW);
delay (2000);
//codigo motor agregar const duration y numero para que gire el motor durante distintos tiempos
lcd.clear();
lcd.setCursor(0, 0); // Coloca el cursor en la primera columna de la primera fila
lcd.print("Tiempo restante:"); // Imprime el texto "Tiempo restante:" en el LCD)
while (elapsedTime < durationB) { // Mientras elapsedTime sea menor que la duración del programa
myStepper.step(stepsPerRevolution); // Gira el motor 400 pasos a la derecha
Serial.println("clockwise");
delay(1000); // Espera 500 milisegundos
myStepper.step(-stepsPerRevolution); // Gira el motor 400 pasos a la izquierda
Serial.println("counterclockwise");
delay(1000); // Espera 500 milisegundos
elapsedTime = millis() - startTime; // Actualiza elapsedTime con la diferencia entre el tiempo actual y startTime
long remainingTime = durationB - elapsedTime; // Calcula el tiempo restante como la diferencia entre la duración del programa y elapsedTime
int minutes = remainingTime / 60000; // Calcula el número de minutos restantes
int seconds = (remainingTime % 60000) / 1000; // Calcula el número de segundos restantes
lcd.setCursor(0, 1); // Coloca el cursor en la primera columna de la segunda fila
lcd.print(minutes); // Imprime el número de minutos restantes en el LCD
lcd.setCursor(1, 1); // Coloca el cursor en la primera columna de la segunda fila
lcd.print(":"); // Imprime el número de minutos restantes en el LCD
// Verifica si el número de segundos es menor que 10
lcd.setCursor(2, 1);
if (seconds < 10) {
lcd.print("0"); // Imprime un cero adicional si el número de segundos es menor que 10
}
lcd.print(seconds); // Imprime el número de segundos restantes en el LCD
}
lcd.clear();
lcd.setCursor(0,1);
lcd.print("vaciando TANQUE");
lcd.println(" ");
digitalWrite(43, HIGH);
delay(4000);
digitalWrite(43, LOW);
lcd.clear();
lcd.print("BLEACH ");
lcd.println(" 2/3");
////// BLEACH /////
////// LImPIEZAAAAAAA /////
for(int i = 0; i <= 2;i++ ){
analogRead(A11);
if (analogRead(A11) < 100)
{
digitalWrite(29, LOW);
digitalWrite(33, LOW);
Serial.println("SENSOR ACTIVADO");
delay(500);
}
else if (analogRead(A11) > 100)
{
digitalWrite(29, HIGH);
digitalWrite(33, HIGH);
Serial.println("INGRESANDO AGUA");
delay(500);
i=i-1;
}
}
digitalWrite(11, HIGH); //prender bomba pumpfill
delay(500);
lcd.clear();
lcd.setCursor(3,1);
lcd.print("ingresando AGUA");
lcd.println("al tanque");
delay(12000); //probar con cuanto llena el tanque 240 APROX 8segundos
digitalWrite(11, LOW);
lcd.clear();
lcd.setCursor(0, 1); // Coloca el cursor en la primera columna de la primera fila
lcd.print("Tiempo restante:"); // Imprime el texto "Tiempo restante:" en el LCD)
while (elapsedTime < durationW) { // Mientras elapsedTime sea menor que la duración del programa
myStepper.step(stepsPerRevolution); // Gira el motor 400 pasos a la derecha
Serial.println("clockwise");
delay(1000); // Espera 500 milisegundos
myStepper.step(-stepsPerRevolution); // Gira el motor 400 pasos a la izquierda
Serial.println("counterclockwise");
delay(1000); // Espera 500 milisegundos
elapsedTime = millis() - startTime; // Actualiza elapsedTime con la diferencia entre el tiempo actual y startTime
long remainingTime = durationW - elapsedTime; // Calcula el tiempo restante como la diferencia entre la duración del programa y elapsedTime
int minutes = remainingTime / 60000; // Calcula el número de minutos restantes
int seconds = (remainingTime % 60000) / 1000; // Calcula el número de segundos restantes
lcd.setCursor(0, 2); // Coloca el cursor en la primera columna de la segunda fila
lcd.print(minutes); // Imprime el número de minutos restantes en el LCD
lcd.setCursor(1, 2); // Coloca el cursor en la primera columna de la segunda fila
lcd.print(":"); // Imprime el número de minutos restantes en el LCD
// Verifica si el número de segundos es menor que 10
lcd.setCursor(2, 2);
if (seconds < 10) {
lcd.print("0"); // Imprime un cero adicional si el número de segundos es menor que 10
}
lcd.print(seconds); // Imprime el número de segundos restantes en el LCD
}
delay(1000);
lcd.print("vaciando TANQUE");
lcd.println(" ");
digitalWrite(49, HIGH);
delay(4000);
digitalWrite(49, LOW);
lcd.clear();
lcd.print("LIMPIEZA ");
lcd.println(" 2/3");
////// LIMPIEZAAAAA //////////
////// FIJADOR /////
delay(1500);
lcd.clear();
lcd.setCursor(3,1);
lcd.print("INGRESADO FIX");
delay(2000);
//ingresa. agua al tanque interno que calentara el quimico
for(int i = 0; i <= 2;i++ ){
analogRead(A11);
if (analogRead(A11) < 100)
{
digitalWrite(23, LOW);
digitalWrite(33, LOW);
Serial.println("SENSOR ACTIVADO");
delay(500);
}
else if (analogRead(A11) > 100)
{
digitalWrite(23, HIGH);
digitalWrite(33, HIGH);
Serial.println("INGRESANDO QUIMICO");
delay(500);
i=i-1;
}
}
lcd.clear();
lcd.print("CALENTANDO");
lcd.setCursor(2,1);
lcd.print("FIX");
// esscribir codigo para calentar quimico
for (int i = 10; i >= 0; i--) {
// Lee el valor de resistencia del sensor NTC
int sensorValue = analogRead(NTC_PIN);
//////////////////////////////////////////
float temperature = 1 / (log(1 / (1023. / sensorValue - 1)) / B + 1.0 / 298.15) - 273.15;
// Comprueba si la temperatura es menor de 37,8 grados
if (temperature < TEMPERATURE_ON) {
// Enciende el relay
lcd.setCursor(0,2);
lcd.print(temperature);
digitalWrite(22, HIGH);
lcd.setCursor(6,2);
lcd.print("ENCENDIDO");
i=i+1;
}
// Comprueba si la temperatura es mayor o igual a 38 grados
else if (temperature >= TEMPERATURE_OFF) {
// Apaga el relay
digitalWrite(22, LOW);
lcd.setCursor(0,2);
lcd.print(temperature);
lcd.setCursor(6,2);
lcd.print("ENFRIANDO");
i=i+1;
}
// Si la temperatura está entre 37,8 y 38 grados
else {
lcd.setCursor(0,2);
lcd.print(temperature);
lcd.setCursor(8,3);
lcd.print(i);
// No hace nada, deja el relay en su estado actual
}
// Espera 1 segundo antes de volver a medir
delay(1000);
}
digitalWrite(11, HIGH); //prender bomba pumpfill
delay(500);
lcd.clear();
lcd.setCursor(3,1);
lcd.print("ingresando FIJADOR");
lcd.println("al tanque");
delay(5000); //probar con cuanto llena el tanque
digitalWrite(11, LOW);
delay (2000);
//codigo motor agregar const duration y numero para que gire el motor durante distintos tiempos
lcd.clear();
lcd.setCursor(0, 0); // Coloca el cursor en la primera columna de la primera fila
lcd.print("Tiempo restante:"); // Imprime el texto "Tiempo restante:" en el LCD)
while (elapsedTime < durationF) { // Mientras elapsedTime sea menor que la duración del programa
myStepper.step(stepsPerRevolution); // Gira el motor 400 pasos a la derecha
Serial.println("clockwise");
delay(1000); // Espera 500 milisegundos
myStepper.step(-stepsPerRevolution); // Gira el motor 400 pasos a la izquierda
Serial.println("counterclockwise");
delay(1000); // Espera 500 milisegundos
elapsedTime = millis() - startTime; // Actualiza elapsedTime con la diferencia entre el tiempo actual y startTime
long remainingTime = durationF - elapsedTime; // Calcula el tiempo restante como la diferencia entre la duración del programa y elapsedTime
int minutes = remainingTime / 60000; // Calcula el número de minutos restantes
int seconds = (remainingTime % 60000) / 1000; // Calcula el número de segundos restantes
lcd.setCursor(0, 1); // Coloca el cursor en la primera columna de la segunda fila
lcd.print(minutes); // Imprime el número de minutos restantes en el LCD
lcd.setCursor(1, 1); // Coloca el cursor en la primera columna de la segunda fila
lcd.print(":"); // Imprime el número de minutos restantes en el LCD
// Verifica si el número de segundos es menor que 10
lcd.setCursor(2, 1);
if (seconds < 10) {
lcd.print("0"); // Imprime un cero adicional si el número de segundos es menor que 10
}
lcd.print(seconds); // Imprime el número de segundos restantes en el LCD
}
lcd.clear();
lcd.setCursor(0,1);
lcd.print("vaciando TANQUE");
lcd.println(" ");
digitalWrite(45, HIGH);
delay(4000);
digitalWrite(45, LOW);
lcd.clear();
lcd.print("FIX ");
lcd.println(" 3/3");
////// FIJADOR /////
////// LImPIEZAAAAAAA /////
for(int i = 0; i <= 2;i++ ){
analogRead(A11);
if (analogRead(A11) < 100)
{
digitalWrite(27, LOW);
digitalWrite(33, LOW);
Serial.println("SENSOR ACTIVADO");
delay(500);
}
else if (analogRead(A11) > 100)
{
digitalWrite(27, HIGH);
digitalWrite(33, HIGH);
Serial.println("INGRESANDO AGUA");
delay(500);
i=i-1;
}
}
digitalWrite(11, HIGH); //prender bomba pumpfill
delay(500);
lcd.clear();
lcd.setCursor(3,1);
lcd.print("ingresando AGUA");
lcd.println("al tanque");
delay(12000); //probar con cuanto llena el tanque 240 APROX 8segundos
digitalWrite(11, LOW);
lcd.clear();
lcd.setCursor(0, 1); // Coloca el cursor en la primera columna de la primera fila
lcd.print("Tiempo restante:"); // Imprime el texto "Tiempo restante:" en el LCD)
while (elapsedTime < durationW) { // Mientras elapsedTime sea menor que la duración del programa
myStepper.step(stepsPerRevolution); // Gira el motor 400 pasos a la derecha
Serial.println("clockwise");
delay(1000); // Espera 500 milisegundos
myStepper.step(-stepsPerRevolution); // Gira el motor 400 pasos a la izquierda
Serial.println("counterclockwise");
delay(1000); // Espera 500 milisegundos
elapsedTime = millis() - startTime; // Actualiza elapsedTime con la diferencia entre el tiempo actual y startTime
long remainingTime = durationW - elapsedTime; // Calcula el tiempo restante como la diferencia entre la duración del programa y elapsedTime
int minutes = remainingTime / 60000; // Calcula el número de minutos restantes
int seconds = (remainingTime % 60000) / 1000; // Calcula el número de segundos restantes
lcd.setCursor(0, 2); // Coloca el cursor en la primera columna de la segunda fila
lcd.print(minutes); // Imprime el número de minutos restantes en el LCD
lcd.setCursor(1, 2); // Coloca el cursor en la primera columna de la segunda fila
lcd.print(":"); // Imprime el número de minutos restantes en el LCD
// Verifica si el número de segundos es menor que 10
lcd.setCursor(2, 2);
if (seconds < 10) {
lcd.print("0"); // Imprime un cero adicional si el número de segundos es menor que 10
}
lcd.print(seconds); // Imprime el número de segundos restantes en el LCD
}
delay(1000);
lcd.print("vaciando TANQUE");
lcd.println(" ");
digitalWrite(49, HIGH);
delay(4000);
digitalWrite(49, LOW);
lcd.clear();
lcd.print("LIMPIEZA ");
lcd.println(" 3/3");
delay(4000);
lcd.clear();
lcd.print("PROCESO C41 ");
lcd.println(" FIN");
delay(4000);
////// LIMPIEZAAAAA //////////
menuSystem.setScreen(0);
menuSystem.setId(0);
menuSystem.show();
}
void action13(byte screen, byte id, byte line, int value)
{
Serial.println(F("action13"));
(void)screen;
(void)id;
(void)line;
(void)value;
lcd.clear();
lcd.clear();
lcd.print("-Ejecutando BYN 6MIN");
delay(1500);
lcd.clear();
lcd.setCursor(3,1);
lcd.print("INGR QUIMICO BYN ");
delay(2000);
//ingresa. agua al tanque interno que calentara el quimico
digitalWrite(47, HIGH);
digitalWrite(11, HIGH); //prender bomba pumpfill
delay(500);
lcd.clear();
lcd.setCursor(3,1);
lcd.print("ingresando QUIMICO");
lcd.setCursor(3,2);
lcd.println("al tanque");
delay(5000); //probar con cuanto llena el tanque
digitalWrite(47, LOW);
digitalWrite(11, LOW);
delay (2000);
//codigo motor agregar const duration y numero para que gire el motor durante distintos tiempos
lcd.clear();
lcd.setCursor(0, 0); // Coloca el cursor en la primera columna de la primera fila
lcd.print("Tiempo restante:"); // Imprime el texto "Tiempo restante:" en el LCD)
long startTime = millis(); // Guarda el tiempo actual en milisegundos en la variable startTime
long elapsedTime = 0; // Inicializa la variable elapsedTime en 0
while (elapsedTime < duration6) { // Mientras elapsedTime sea menor que la duración del programa
myStepper.step(stepsPerRevolution); // Gira el motor 400 pasos a la derecha
Serial.println("clockwise");
delay(1000); // Espera 500 milisegundos
myStepper.step(-stepsPerRevolution); // Gira el motor 400 pasos a la izquierda
Serial.println("counterclockwise");
delay(1000); // Espera 500 milisegundos
elapsedTime = millis() - startTime; // Actualiza elapsedTime con la diferencia entre el tiempo actual y startTime
long remainingTime = duration6 - elapsedTime; // Calcula el tiempo restante como la diferencia entre la duración del programa y elapsedTime
int minutes = remainingTime / 60000; // Calcula el número de minutos restantes
int seconds = (remainingTime % 60000) / 1000; // Calcula el número de segundos restantes
lcd.setCursor(0, 1); // Coloca el cursor en la primera columna de la segunda fila
lcd.print(minutes); // Imprime el número de minutos restantes en el LCD
lcd.setCursor(1, 1); // Coloca el cursor en la primera columna de la segunda fila
lcd.print(":"); // Imprime el número de minutos restantes en el LCD
// Verifica si el número de segundos es menor que 10
lcd.setCursor(2, 1);
if (seconds < 10) {
lcd.print("0"); // Imprime un cero adicional si el número de segundos es menor que 10
}
lcd.print(seconds); // Imprime el número de segundos restantes en el LCD
}
lcd.clear();
lcd.setCursor(0,1);
lcd.print("vaciando TANQUE");
lcd.println(" ");
digitalWrite(49, HIGH);
delay(4000);
digitalWrite(49, LOW);
lcd.clear();
lcd.print("REVELADO OK ");
lcd.println("CONT FIX");
////// c41 /////
delay(3000);
menuSystem.setScreen(0);
menuSystem.setId(0);
menuSystem.show();
}
void action14(byte screen, byte id, byte line, int value)
{
Serial.println(F("action14"));
(void)screen;
(void)id;
(void)line;
(void)value;
lcd.clear();
lcd.print(F("-Executing BYN 570ml"));
delay(2500);
lcd.print("-Ejecutando BYN 7MIN");
delay(1500);
lcd.clear();
lcd.setCursor(3,1);
lcd.print("INGR QUIMICO BYN 570ML");
delay(2000);
//ingresa. agua al tanque interno que calentara el quimico
digitalWrite(47, HIGH);
digitalWrite(11, HIGH); //prender bomba pumpfill
delay(500);
lcd.clear();
lcd.setCursor(3,1);
lcd.print("ingresando QUIMICO");
lcd.setCursor(3,2);
lcd.println("al tanque");
delay(5000); //probar con cuanto llena el tanque
digitalWrite(47, LOW);
digitalWrite(11, LOW);
delay (2000);
//codigo motor agregar const duration y numero para que gire el motor durante distintos tiempos
lcd.clear();
lcd.setCursor(0, 0); // Coloca el cursor en la primera columna de la primera fila
lcd.print("Tiempo restante:"); // Imprime el texto "Tiempo restante:" en el LCD)
long startTime = millis(); // Guarda el tiempo actual en milisegundos en la variable startTime
long elapsedTime = 0; // Inicializa la variable elapsedTime en 0
while (elapsedTime < duration7) { // Mientras elapsedTime sea menor que la duración del programa
myStepper.step(stepsPerRevolution); // Gira el motor 400 pasos a la derecha
Serial.println("clockwise");
delay(1000); // Espera 500 milisegundos
myStepper.step(-stepsPerRevolution); // Gira el motor 400 pasos a la izquierda
Serial.println("counterclockwise");
delay(1000); // Espera 500 milisegundos
elapsedTime = millis() - startTime; // Actualiza elapsedTime con la diferencia entre el tiempo actual y startTime
long remainingTime = duration7 - elapsedTime; // Calcula el tiempo restante como la diferencia entre la duración del programa y elapsedTime
int minutes = remainingTime / 60000; // Calcula el número de minutos restantes
int seconds = (remainingTime % 60000) / 1000; // Calcula el número de segundos restantes
lcd.setCursor(0, 1); // Coloca el cursor en la primera columna de la segunda fila
lcd.print(minutes); // Imprime el número de minutos restantes en el LCD
lcd.setCursor(1, 1); // Coloca el cursor en la primera columna de la segunda fila
lcd.print(":"); // Imprime el número de minutos restantes en el LCD
// Verifica si el número de segundos es menor que 10
lcd.setCursor(2, 1);
if (seconds < 10) {
lcd.print("0"); // Imprime un cero adicional si el número de segundos es menor que 10
}
lcd.print(seconds); // Imprime el número de segundos restantes en el LCD
}
lcd.clear();
lcd.setCursor(0,1);
lcd.print("vaciando TANQUE");
lcd.println(" ");
digitalWrite(49, HIGH);
delay(4000);
digitalWrite(49, LOW);
lcd.clear();
lcd.print("REVELADO OK ");
lcd.println("CONT FIX");
////// c41 /////
delay(3000);
menuSystem.setScreen(0);
menuSystem.setId(0);
menuSystem.show();
}
void action15(byte screen, byte id, byte line, int value)
{
Serial.println(F("action16"));
(void)screen;
(void)id;
(void)line;
(void)value;
lcd.clear();
lcd.print(F("-Executing c41 570ml"));
delay(2500);
lcd.print("-Ejecutando BYN 8MIN");
delay(1500);
lcd.clear();
lcd.setCursor(3,1);
lcd.print("INGR QUIMICO BYN ");
delay(2000);
//ingresa. agua al tanque interno que calentara el quimico
digitalWrite(47, HIGH);
digitalWrite(11, HIGH); //prender bomba pumpfill
delay(500);
lcd.clear();
lcd.setCursor(3,1);
lcd.print("ingresando QUIMICO");
lcd.setCursor(3,2);
lcd.println("al tanque");
delay(5000); //probar con cuanto llena el tanque
digitalWrite(47, LOW);
digitalWrite(11, LOW);
delay (2000);
//codigo motor agregar const duration y numero para que gire el motor durante distintos tiempos
lcd.clear();
lcd.setCursor(0, 0); // Coloca el cursor en la primera columna de la primera fila
lcd.print("Tiempo restante:"); // Imprime el texto "Tiempo restante:" en el LCD)
long startTime = millis(); // Guarda el tiempo actual en milisegundos en la variable startTime
long elapsedTime = 0; // Inicializa la variable elapsedTime en 0
while (elapsedTime < duration8) { // Mientras elapsedTime sea menor que la duración del programa
myStepper.step(stepsPerRevolution); // Gira el motor 400 pasos a la derecha
Serial.println("clockwise");
delay(1000); // Espera 500 milisegundos
myStepper.step(-stepsPerRevolution); // Gira el motor 400 pasos a la izquierda
Serial.println("counterclockwise");
delay(1000); // Espera 500 milisegundos
elapsedTime = millis() - startTime; // Actualiza elapsedTime con la diferencia entre el tiempo actual y startTime
long remainingTime = duration8 - elapsedTime; // Calcula el tiempo restante como la diferencia entre la duración del programa y elapsedTime
int minutes = remainingTime / 60000; // Calcula el número de minutos restantes
int seconds = (remainingTime % 60000) / 1000; // Calcula el número de segundos restantes
lcd.setCursor(0, 1); // Coloca el cursor en la primera columna de la segunda fila
lcd.print(minutes); // Imprime el número de minutos restantes en el LCD
lcd.setCursor(1, 1); // Coloca el cursor en la primera columna de la segunda fila
lcd.print(":"); // Imprime el número de minutos restantes en el LCD
// Verifica si el número de segundos es menor que 10
lcd.setCursor(2, 1);
if (seconds < 10) {
lcd.print("0"); // Imprime un cero adicional si el número de segundos es menor que 10
}
lcd.print(seconds); // Imprime el número de segundos restantes en el LCD
}
lcd.clear();
lcd.setCursor(0,1);
lcd.print("vaciando TANQUE");
lcd.println(" ");
digitalWrite(49, HIGH);
delay(4000);
digitalWrite(49, LOW);
lcd.clear();
lcd.print("REVELADO OK ");
lcd.println("CONT FIX");
////// c41 /////
delay(3000);
menuSystem.setScreen(0);
menuSystem.setId(0);
menuSystem.show();
}
void action16(byte screen, byte id, byte line, int value)
{
Serial.println(F("action16"));
(void)screen;
(void)id;
(void)line;
(void)value;
lcd.clear();
lcd.print(F("-Executing c41 570ml"));
delay(2500);
lcd.print("-Ejecutando BYN 9MIN");
delay(1500);
lcd.clear();
lcd.setCursor(3,1);
lcd.print("INGR QUIMICO BYN ");
delay(2000);
//ingresa. agua al tanque interno que calentara el quimico
digitalWrite(47, HIGH);
digitalWrite(11, HIGH); //prender bomba pumpfill
delay(500);
lcd.clear();
lcd.setCursor(3,1);
lcd.print("ingresando QUIMICO");
lcd.setCursor(3,2);
lcd.println("al tanque");
delay(5000); //probar con cuanto llena el tanque
digitalWrite(47, LOW);
digitalWrite(11, LOW);
delay (2000);
//codigo motor agregar const duration y numero para que gire el motor durante distintos tiempos
lcd.clear();
lcd.setCursor(0, 0); // Coloca el cursor en la primera columna de la primera fila
lcd.print("Tiempo restante:"); // Imprime el texto "Tiempo restante:" en el LCD)
long startTime = millis(); // Guarda el tiempo actual en milisegundos en la variable startTime
long elapsedTime = 0; // Inicializa la variable elapsedTime en 0
while (elapsedTime < duration9) { // Mientras elapsedTime sea menor que la duración del programa
myStepper.step(stepsPerRevolution); // Gira el motor 400 pasos a la derecha
Serial.println("clockwise");
delay(1000); // Espera 500 milisegundos
myStepper.step(-stepsPerRevolution); // Gira el motor 400 pasos a la izquierda
Serial.println("counterclockwise");
delay(1000); // Espera 500 milisegundos
elapsedTime = millis() - startTime; // Actualiza elapsedTime con la diferencia entre el tiempo actual y startTime
long remainingTime = duration9 - elapsedTime; // Calcula el tiempo restante como la diferencia entre la duración del programa y elapsedTime
int minutes = remainingTime / 60000; // Calcula el número de minutos restantes
int seconds = (remainingTime % 60000) / 1000; // Calcula el número de segundos restantes
lcd.setCursor(0, 1); // Coloca el cursor en la primera columna de la segunda fila
lcd.print(minutes); // Imprime el número de minutos restantes en el LCD
lcd.setCursor(1, 1); // Coloca el cursor en la primera columna de la segunda fila
lcd.print(":"); // Imprime el número de minutos restantes en el LCD
// Verifica si el número de segundos es menor que 10
lcd.setCursor(2, 1);
if (seconds < 10) {
lcd.print("0"); // Imprime un cero adicional si el número de segundos es menor que 10
}
lcd.print(seconds); // Imprime el número de segundos restantes en el LCD
}
lcd.clear();
lcd.setCursor(0,1);
lcd.print("vaciando TANQUE");
lcd.println(" ");
digitalWrite(49, HIGH);
delay(4000);
digitalWrite(49, LOW);
lcd.clear();
lcd.print("REVELADO OK ");
lcd.println("CONT FIX");
////// c41 /////
delay(3000);
menuSystem.setScreen(0);
menuSystem.setId(0);
menuSystem.show();
}
void action17(byte screen, byte id, byte line, int value)
{
Serial.println(F("action16"));
(void)screen;
(void)id;
(void)line;
(void)value;
lcd.clear();
lcd.print(F("-Executing c41 570ml"));
delay(2500);
lcd.print("-Ejecutando BYN 10MIN");
delay(1500);
lcd.clear();
lcd.setCursor(3,1);
lcd.print("INGR QUIMICO BYN ");
delay(2000);
//ingresa. agua al tanque interno que calentara el quimico
digitalWrite(47, HIGH);
digitalWrite(11, HIGH); //prender bomba pumpfill
delay(500);
lcd.clear();
lcd.setCursor(3,1);
lcd.print("ingresando QUIMICO");
lcd.setCursor(3,2);
lcd.println("al tanque");
delay(5000); //probar con cuanto llena el tanque
digitalWrite(47, LOW);
digitalWrite(11, LOW);
delay (2000);
//codigo motor agregar const duration y numero para que gire el motor durante distintos tiempos
lcd.clear();
lcd.setCursor(0, 0); // Coloca el cursor en la primera columna de la primera fila
lcd.print("Tiempo restante:"); // Imprime el texto "Tiempo restante:" en el LCD)
long startTime = millis(); // Guarda el tiempo actual en milisegundos en la variable startTime
long elapsedTime = 0; // Inicializa la variable elapsedTime en 0
while (elapsedTime < duration10) { // Mientras elapsedTime sea menor que la duración del programa
myStepper.step(stepsPerRevolution); // Gira el motor 400 pasos a la derecha
Serial.println("clockwise");
delay(1000); // Espera 500 milisegundos
myStepper.step(-stepsPerRevolution); // Gira el motor 400 pasos a la izquierda
Serial.println("counterclockwise");
delay(1000); // Espera 500 milisegundos
elapsedTime = millis() - startTime; // Actualiza elapsedTime con la diferencia entre el tiempo actual y startTime
long remainingTime = duration10 - elapsedTime; // Calcula el tiempo restante como la diferencia entre la duración del programa y elapsedTime
int minutes = remainingTime / 60000; // Calcula el número de minutos restantes
int seconds = (remainingTime % 60000) / 1000; // Calcula el número de segundos restantes
lcd.setCursor(0, 1); // Coloca el cursor en la primera columna de la segunda fila
lcd.print(minutes); // Imprime el número de minutos restantes en el LCD
lcd.setCursor(1, 1); // Coloca el cursor en la primera columna de la segunda fila
lcd.print(":"); // Imprime el número de minutos restantes en el LCD
// Verifica si el número de segundos es menor que 10
lcd.setCursor(2, 1);
if (seconds < 10) {
lcd.print("0"); // Imprime un cero adicional si el número de segundos es menor que 10
}
lcd.print(seconds); // Imprime el número de segundos restantes en el LCD
}
lcd.clear();
lcd.setCursor(0,1);
lcd.print("vaciando TANQUE");
lcd.println(" ");
digitalWrite(49, HIGH);
delay(4000);
digitalWrite(49, LOW);
lcd.clear();
lcd.print("REVELADO OK ");
lcd.println("CONT FIX");
////// c41 /////
delay(3000);
menuSystem.setScreen(0);
menuSystem.setId(0);
menuSystem.show();
}
void action18(byte screen, byte id, byte line, int value)
{
Serial.println(F("action16"));
(void)screen;
(void)id;
(void)line;
(void)value;
lcd.clear();
lcd.print(F("-Executing FIX NUEVO"));
delay(2500);
lcd.print("-Ejecutando FIX NUEVO");
delay(1500);
delay(1500);
lcd.clear();
lcd.setCursor(3,1);
lcd.print("INGRESADO FIX");
delay(2000);
//ingresa. agua al tanque interno que calentara el quimico
for(int i = 0; i <= 2;i++ ){
analogRead(A10);
if (analogRead(A10) < 100)
{
digitalWrite(23, LOW);
digitalWrite(33, LOW);
Serial.println("SENSOR ACTIVADO");
delay(500);
}
else if (analogRead(A10) > 100)
{
digitalWrite(23, HIGH);
digitalWrite(33, HIGH);
Serial.println("INGRESANDO QUIMICO");
delay(500);
i=i-1;
}
}
digitalWrite(11, HIGH); //prender bomba pumpfill
delay(500);
lcd.clear();
lcd.setCursor(3,1);
lcd.print("ingresando FIJADOR");
lcd.println("al tanque");
delay(5000); //probar con cuanto llena el tanque
digitalWrite(11, LOW);
delay (2000);
//codigo motor agregar const duration y numero para que gire el motor durante distintos tiempos
lcd.clear();
lcd.setCursor(0, 0); // Coloca el cursor en la primera columna de la primera fila
lcd.print("Tiempo restante:"); // Imprime el texto "Tiempo restante:" en el LCD)
long startTime = millis(); // Guarda el tiempo actual en milisegundos en la variable startTime
long elapsedTime = 0; // Inicializa la variable elapsedTime en 0
while (elapsedTime < durationF) { // Mientras elapsedTime sea menor que la duración del programa
myStepper.step(stepsPerRevolution); // Gira el motor 400 pasos a la derecha
Serial.println("clockwise");
delay(1000); // Espera 500 milisegundos
myStepper.step(-stepsPerRevolution); // Gira el motor 400 pasos a la izquierda
Serial.println("counterclockwise");
delay(1000); // Espera 500 milisegundos
elapsedTime = millis() - startTime; // Actualiza elapsedTime con la diferencia entre el tiempo actual y startTime
long remainingTime = durationF - elapsedTime; // Calcula el tiempo restante como la diferencia entre la duración del programa y elapsedTime
int minutes = remainingTime / 60000; // Calcula el número de minutos restantes
int seconds = (remainingTime % 60000) / 1000; // Calcula el número de segundos restantes
lcd.setCursor(0, 1); // Coloca el cursor en la primera columna de la segunda fila
lcd.print(minutes); // Imprime el número de minutos restantes en el LCD
lcd.setCursor(1, 1); // Coloca el cursor en la primera columna de la segunda fila
lcd.print(":"); // Imprime el número de minutos restantes en el LCD
// Verifica si el número de segundos es menor que 10
lcd.setCursor(2, 1);
if (seconds < 10) {
lcd.print("0"); // Imprime un cero adicional si el número de segundos es menor que 10
}
lcd.print(seconds); // Imprime el número de segundos restantes en el LCD
}
lcd.clear();
lcd.setCursor(0,1);
lcd.print("vaciando TANQUE");
lcd.println(" ");
digitalWrite(45, HIGH);
delay(4000);
digitalWrite(45, LOW);
lcd.clear();
lcd.print("FIX BYN OK ");
lcd.println("Cont LAVADO ");
menuSystem.setScreen(0);
menuSystem.setId(0);
menuSystem.show();
}
void action19(byte screen, byte id, byte line, int value)
{
Serial.println(F("LAVADO"));
(void)screen;
(void)id;
(void)line;
(void)value;
lcd.clear();
lcd.print(F("-Executing LAVAD0 30s"));
delay(2500);
lcd.print("-Ejec LAVADO 30S");
delay(1500);
////// LImPIEZAAAAAAA /////
lcd.clear();
lcd.print(" LAVADO ");
lcd.println(" ");
for(int i = 0; i <= 2;i++ ){
analogRead(A10);
if (analogRead(A10) < 100)
{
digitalWrite(29, LOW);
digitalWrite(33, LOW);
Serial.println("SENSOR ACTIVADO");
delay(500);
}
else if (analogRead(A10) > 100)
{
digitalWrite(29, HIGH);
digitalWrite(33, HIGH);
Serial.println("INGRESANDO AGUA");
delay(500);
i=i-1;
}
}
digitalWrite(11, HIGH); //prender bomba pumpfill
delay(500);
lcd.clear();
lcd.setCursor(3,1);
lcd.print("ingresando AGUA");
lcd.println("al tanque");
delay(12000); //probar con cuanto llena el tanque 240 APROX 8segundos
digitalWrite(11, LOW);
lcd.clear();
lcd.setCursor(0, 1); // Coloca el cursor en la primera columna de la primera fila
lcd.print("Tiempo restante:"); // Imprime el texto "Tiempo restante:" en el LCD)
long startTime = millis(); // Guarda el tiempo actual en milisegundos en la variable startTime
long elapsedTime = 0; // Inicializa la variable elapsedTime en 0
while (elapsedTime < durationW) { // Mientras elapsedTime sea menor que la duración del programa
myStepper.step(stepsPerRevolution); // Gira el motor 400 pasos a la derecha
Serial.println("clockwise");
delay(1000); // Espera 500 milisegundos
myStepper.step(-stepsPerRevolution); // Gira el motor 400 pasos a la izquierda
Serial.println("counterclockwise");
delay(1000); // Espera 500 milisegundos
elapsedTime = millis() - startTime; // Actualiza elapsedTime con la diferencia entre el tiempo actual y startTime
long remainingTime = durationW - elapsedTime; // Calcula el tiempo restante como la diferencia entre la duración del programa y elapsedTime
int minutes = remainingTime / 60000; // Calcula el número de minutos restantes
int seconds = (remainingTime % 60000) / 1000; // Calcula el número de segundos restantes
lcd.setCursor(0, 2); // Coloca el cursor en la primera columna de la segunda fila
lcd.print(minutes); // Imprime el número de minutos restantes en el LCD
lcd.setCursor(1, 2); // Coloca el cursor en la primera columna de la segunda fila
lcd.print(":"); // Imprime el número de minutos restantes en el LCD
// Verifica si el número de segundos es menor que 10
lcd.setCursor(2, 2);
if (seconds < 10) {
lcd.print("0"); // Imprime un cero adicional si el número de segundos es menor que 10
}
lcd.print(seconds); // Imprime el número de segundos restantes en el LCD
}
delay(1000);
lcd.print("vaciando TANQUE");
lcd.println(" ");
digitalWrite(49, HIGH);
delay(4000);
digitalWrite(49, LOW);
lcd.clear();
lcd.print("LAVADOOO ");
lcd.println(" ");
delay(5000);
menuSystem.setScreen(0);
menuSystem.setId(0);
menuSystem.show();
}
void action20(byte screen, byte id, byte line, int value)
{
Serial.println(F("action16"));
(void)screen;
(void)id;
(void)line;
(void)value;
lcd.clear();
lcd.print(F("-Executing FIX NUEVO"));
delay(2500);
////// C41 /////
delay(1500);
lcd.clear();
lcd.setCursor(3,1);
lcd.print("INGR REV BYN ");
delay(3000);
//ingresa. agua al tanque interno que calentara el quimico
for(int i = 0; i <= 2;i++ ){
analogRead(A10);
if (analogRead(A10) < 100)
{
digitalWrite(23, LOW);
digitalWrite(33, LOW);
Serial.println("SENSOR ACTIVADO");
delay(500);
}
else if (analogRead(A10) > 100)
{
digitalWrite(23, HIGH);
digitalWrite(33, HIGH);
Serial.println("INGRESANDO QUIMICO");
delay(500);
i=i-1;
}
}
lcd.clear();
lcd.print("REVELADOR LISTO");
lcd.setCursor(2,1);
lcd.print("MEDIR TEMP");
menuSystem.setScreen(0);
menuSystem.setId(0);
menuSystem.show();
}
void action21(byte buttonState, byte buttonChanged, byte encoderState, int encoderChanged) {
// Muestra el título del menú en la primera fila del LCD
lcd.setCursor(0, 0);
lcd.print("Modificar tiempo Bleach");
int getTiempoBleach() {
// Tu código aquí
return tiempoBleach;
}
void setTiempoBleach(int tiempo) {
// Tu código aquí
tiempoBleach = tiempo;
}
// Muestra el tiempo actual en la segunda fila del LCD
lcd.setCursor(0, 1);
lcd.print(tiempoBleach / 60000); // Minutos
lcd.setCursor(1, 1);
lcd.print(":");
lcd.setCursor(2, 1);
lcd.print(tiempoBleach % 60000 / 1000); // Segundos
// Lee el estado del botón de arriba
int tiempoBleachUpButtonState = digitalRead(upButton);
// Si el botón de arriba está presionado
if (tiempoBleachUpButtonState == LOW) {
// Aumenta el tiempo en 1 minuto
tiempoBleach += 60000;
// Muestra el tiempo actualizado en el LCD
lcd.setCursor(0, 1);
lcd.print(tiempoBleach / 60000); // Minutos
lcd.setCursor(1, 1);
lcd.print(":");
lcd.setCursor(2, 1);
lcd.print(tiempoBleach % 60000 / 1000); // Segundos
delay(200); // Espera 200 milisegundos
}
// Lee el estado del botón de abajo
int downButtonState = digitalRead(downButton);
// Si el botón de abajo está presionado
if (downButtonState == LOW) {
// Decrementa el tiempo en 1 segundo
tiempoBleach -= 1000;
// Si el tiempo llega a 0, reinicialo a 59 segundos
if (tiempoBleach < 0) {
tiempoBleach = 59000;
}
// Muestra el tiempo actualizado en el LCD
lcd.setCursor(0, 1);
lcd.print(tiempoBleach / 60000); // Minutos
lcd.setCursor(1, 1);
lcd.print(":");
lcd.setCursor(2, 1);
// Si el número de segundos es menor que 10, imprime un cero adicional
if ((tiempoBleach % 60000) / 1000 < 10) {
lcd.print("0");
}
lcd.print((tiempoBleach % 60000) / 1000); // Segundos
}
// Lee el estado del botón de arriba
int upButtonState = digitalRead(upButton);
// Si el botón de arriba está presionado
if (upButtonState == LOW) {
// Incrementa el tiempo en 1 segundo
tiempoBleach += 1000;
// Si el tiempo llega a 60 segundos, reinicialo a 0
if (tiempoBleach >= 60000) {
tiempoBleach = 0;
}
// Muestra el tiempo actualizado en el LCD
lcd.setCursor(0, 1);
lcd.print(tiempoBleach / 60000); // Minutos
lcd.setCursor(1, 1);
lcd.print(":");
lcd.setCursor(2, 1);
// Si el número de segundos es menor que 10, imprime un cero adicional
if ((tiempoBleach % 60000) / 1000 < 10) {
lcd.print("0");
}
lcd.print((tiempoBleach % 60000) / 1000); // Segundos
}
// Lee el estado del botón de selección
int selectButtonState = digitalRead(selectButton);
// Si el botón de selección está presionado
if (selectButtonState == LOW) {
// Almacena el tiempo seleccionado y vuelve al menú principal
setTiempoBleach(tiempoBleach);
lcd.clear();
lcd.setCursor(0, 0);
lcd.print("Tiempo Bleach:");
lcd.setCursor(0, 1);
lcd.print(getTiempoBleach() / 60000); // Minutos
lcd.setCursor(1, 1);
lcd.print(":");
lcd.setCursor(2, 1);
// Si el número de segundos es menor que 10, imprime un cero adicional
if ((getTiempoBleach() % 60000) / 1000 < 10) {
lcd.print("0");
}
lcd.print((getTiempoBleach() % 60000) / 1000); // Segundos
delay(500);
}
menuSystem.setScreen(0);
menuSystem.setId(0);
menuSystem.show();
}
void setTiempoBleach(int t) {
tiempoBleach = t;
}
void back(byte screen, byte id, byte line, int value)
{
Serial.println(F("back"));
(void)screen;
(void)id;
(void)line;
(void)value;
menuSystem.cursorBack();
}
void readButton()
{
if (digitalRead(downButton) == LOW) {
menuSystem.cursorDown();
delay(100); // dirty delay to debounce button
while (!digitalRead(downButton)); // wait for button release
}
if (digitalRead(upButton) == LOW) {
menuSystem.cursorUp();
delay(200); // dirty delay to debounce button
while (!digitalRead(upButton));
}
if (digitalRead(backButton) == LOW) {
menuSystem.cursorBack();
delay(200); // dirty delay to debounce button
while (!digitalRead(backButton));
}
if (digitalRead(selectButton) == LOW) {
menuSystem.activate(); // activate the current line
delay(200); // dirty delay to debounce button
while (!digitalRead(selectButton));
}
if (digitalRead(encoderButton) == LOW) {
menuSystem.activate(); // activate the current line
delay(200); // dirty delay to debounce button
while (!digitalRead(encoderButton));
}
}
#define ENCODER_CLK 2
#define ENCODER_DT 3
void readEncoder() {
{
int dtValue = digitalRead(ENCODER_DT);
if (dtValue == HIGH) {
Serial.println("up");
menuSystem.cursorUp();
}
if (dtValue == LOW) {
Serial.println("down");
menuSystem.cursorDown();
}
}
menuSystem.setScreen(0);
menuSystem.setId(0);
menuSystem.show();
}
void setup()
{
Serial.begin(115200);
Serial.println(F("Tresquince probando 3 2 1"));
myStepper.setSpeed(60);
Wire.begin(); // start I2C library
lcd.init(); // initialize the LCD
lcd.backlight(); // turn on backlight
lcd.setCursor(3,1);
lcd.print("Hola, USUARIO");
lcd.setCursor(2,2);
lcd.print("INICIANDO JOVITO");
delay(5000);
pinMode(upButton, INPUT_PULLUP);
pinMode(downButton, INPUT_PULLUP);
pinMode(backButton, INPUT_PULLUP);
pinMode(selectButton, INPUT_PULLUP);
pinMode(encoderButton, INPUT_PULLUP);
pinMode(23, OUTPUT); //C41IN
pinMode(22, OUTPUT); //resistencia
pinMode(27, OUTPUT); //FIXIN
pinMode(25, OUTPUT); //BLEACHIN
pinMode(29, OUTPUT); //WATERIN
pinMode(33, OUTPUT); //PUMPIN
pinMode(41, OUTPUT); //C41REC
pinMode(43, OUTPUT); //BLEACHREC
pinMode(45, OUTPUT); //FIX REC
pinMode(47, OUTPUT); //TANQIN
pinMode(49, OUTPUT); //WASTED
pinMode(7, OUTPUT); //vacio // A10 Y A11 SENSOR DE NIVEL
pinMode(11, OUTPUT); //PUMPFILL
digitalWrite(22,LOW);
digitalWrite(23,LOW);
digitalWrite(27,LOW);
digitalWrite(25,LOW);
digitalWrite(29,LOW);
digitalWrite(33,LOW);
digitalWrite(41,LOW);
digitalWrite(43,LOW);
digitalWrite(44,LOW);
digitalWrite(45,LOW);
digitalWrite(47,LOW);
digitalWrite(49,LOW);
digitalWrite(7,LOW);
digitalWrite(11,LOW);
pinMode(A7,INPUT);
pinMode(A5,INPUT);
pinMode(38, INPUT);
pinMode(ENCODER_CLK, INPUT);
pinMode(ENCODER_DT, INPUT);
attachInterrupt(digitalPinToInterrupt(ENCODER_CLK), readEncoder, FALLING);
setTiempoBleach(120000); // Establece el tiempo de bleach a 2 minutos
menuSystem.show();
}
void loop()
{
readButton();
}