Programador electrónico para lavadora con Arduino

Esta historia podría comenzar así: Erase una vez una lavadora con cuatro años de antigüedad a la que se le estropeó el programador digital.

Es una lavadora de la marca Haier, de la gama barata, el motor es universal y absolutamente todo se controlaba a través del programador digital de la lavadora. Estuve barajando la compra del programador, pero no merecía realizar el gasto de 150 euros, cuando por 50 euros más podía adquirir otra, pero la consigna del reciclaje y no sucumbir a la obsolescencia programada, me animaron a realizar un programador para lavadora con Arduino.

Comenzamos:

Primero desmonté completamente la lavadora, dejando unicamente el chasis de acero, con la finalidad de lijarlo y sanar las zonas con corrosión, los cables los etiqueté antes de comenzar a desmontar.

 Etiquetando los cables

Aquí con el chasis de la lavadora, pintando y reparando la corrosión.

 Aquí la electrocerradura, normalmente te la vas a encontrar igual o muy parecida, dispone de un conector con tres conexiones, un cable de fase o linea, un cable neutro y el de salida de alimentación a la máquina, éste cable normalmente de alimentación a la máquina será compartido entre el común de las electroválvulas, bomba de desagüe e interruptor térmico de seguridad del motor. Cuando se cierra la puerta y se le introduce carga entre el L y N, la corriente atraviese una aleación de metal que ofrece una resistencia específica y se calienta, al calentarse se dobla y mueve unos pequeños contactos, que cierran el circuito del interruptor, si tienes avería con la electrocerradura, bien puedes hacer un puente entre L e interruptor, o bien lo desmontas y lijas los contactos desgastados.

Éste es el programador averiado de la lavadora, fotos de la cara anterior y posterior. Del circuito desoldé los componentes que creo reciclaré. Una vez extraídos los componentes dejé limpia la placa y lijada, con el fin de construir sobre la misma placa el nuevo programador.

Aquí la construcción del programador con un LCD de 4 x 20 para visualizar el desarrollo, es más resultón para la realización del proyecto introducir una pantalla de este tipo que una multitud de led y su correspondiente cableado, que al fin y al cabo no ofrecerá tanta información como la pantalla.

Al final, no cabían todos los componentes en la placa antigua, por lo que el frontal de la lavadora, unicamente dispone de los botones y pantalla lcd.

Para el proyecto necesité una placa Arduino UNO, he utilizado una placa compatible de las baratas, eso si,

me ha dado algunos dolores de cabeza, algunos pines en esta placa están cambiados el HIGH con el LOW, por lo tanto mi consejo es que si puedes, te compres una original.

Para quien no conozca arduino, decirle que es un proyecto GNU/GPL, por lo tanto es una placa barata en comparación con otras del mercado, además puedes fabricarte el tuyo propio, ya que todas las fuentes, datasheet, etc están publicados.

Arduino controla puertas analógicas, y digitales, en valores de 0 a 5v, la propia placa de arduino, además de contener "su propio corazón" un circuito integrado de ATMega, dispone de un regulador de tensión, una entrada usb que sirve de alimentación y un ic que "traduce" lo que envía el ordenador al ATMega, también dispone de una entrada de alimentación regulada por lo que podrás alimentar tu arduino desde 3 voltios hasta los 15, aunque lo recomendable es 5, así evitas hacer trabajar al regulador y la correspondiente disipación de calor que generará.

Aquí os dejo la página oficial de Arduino http://www.arduino.cc/

Aquí la página del software para programar el Arduino, el lenguaje de programación más ampliamente utilizado es el Lenguaje C o C++, un lenguaje asequible al aprendizaje. Desde aquí quiero agradecer que muchos de los conocimientos que tengo de este lenguaje son gracias a los magníficos profesores que tuve en el Grado Superior de Informática de Desarrollo de Aplicaciones Informáticas del Instituto Cristobal Monroy de Alcalá de Guadaíra, provincia de Sevilla, Andalucía. http://arduino.cc/en/Main/Software

Arduino puede controlar o interactuar a través de sus pines (y sus 5v), con una amplia gama de sensores y dispositivos. Por ejemplo unos relés alimentados con 5v, con la finalidad de controlar las electroválvulas, bomba de desagüe, electrocerradura y resistencia que calienta el agua de lavado.

Es más cómodo y barato comprar estos módulos que fabricarlos uno mismo, cada entrada dispone un optoacoplador que aísla totalmente la tensión de 220v de carga de los relés con la circuitería de 5v de Arduino.

Durante el proceso de fabricación

 Tenemos que seguir controlando el resto de la lavadora, por ejemplo el motor, normalmente te vas a encontrar este tipo de motor en la mayoría de las lavadoras, es un motor universal o motor de escobillas de entre 200 a 400 watios aproximadamente. También existen lavadoras con motores Direct Drive y las más antiguas con un motor de inducción.

En este caso solo hablaremos del motor universal, para controlar la velocidad del motor me dispongo a realizar un dimmer que soporte dicha carga, y para que funcione durante el lavado el giro intermitente entre el sentido de las agujas de reloj y al contrario, utilizar un relé.

Disolviendo el cobre

Aquí tenéis el proceso de fabricación de la placa, en la red encontrarás mucha información de como fabricarte tu propia placa, si bien te resumo brevemente como lo hice, impresión en papel blanco normal con impresora de toner del circuito, se coloca contra la placa de cobre, con una plancha caliente transfieres el toner al cobre, dejas unos minutos el circuito con le papel en remojo con agua para que se ablande y desprenda, vas retirando el papel con cuidado y un cepillo de dientes hasta eliminar el papel, en una cubeta mezclar agua oxigenada y agua fuerte (ácido clohídrico) al 50%, introduces la placa y mueves lentamente la cubeta hasta que desaparezca el cobre visible, sacas la placa y la dejas en agua, secas y retiras el toner con una lija muy fina, y voilá!!! ya tienes tu circuito. 

Placa finalizada

OJO, no me hago responsable de los daños que puedas ocasionar durante el manejo de productos, si lo haces es bajo tu responsabilidad.

Tampoco me hago responsable de las averías que pudieras ocasionar a tu lavadora durante cualquier proceso que puedas llevar a cabo sobre ella, si no sabes lo que haces, no lo hagas, además existe riesgo de electrocución si no tienes las precauciones necesarias.

Una vez terminada la placa, nos disponemos a taladrar los puntos por donde soldaremos los componentes electrónicos.

Aquí la adquisición de los componentes electrónicos y dispuesto al montaje del dimmer.
La idea sobre el Dimmer la tomé de Txapuzas electrónicas, me gustó la idea de tener un dimmer con optoacopladores (aisladores) y un Triac de gran amperaje que soportaría la carga del motor.

Bien, pues después del montaje y prueba sobre el motor sobre una bancada, iba de lujo, el problema (que ya me imaginaba) es el torque del motor, que se reduce drasticamente y aunque controlas la velocidad pierdes practicamente el 95% de la potencia, con el fin de mejorarlo hice la siguiente prueba, alimentar el motor con DC en vez de AC, para ello puse un puente diodo e incluso con un condensador para mejorar el arranque, y realmente mejoró en aproximadamente un 30%, no obstante, no es suficiente, me vi resignado a buscar otra alternativa.

 Aquí una fotografía con el diagrama de conexiones del motor universal, éste en concreto dispone de tres conexiones al estator (bobinado fijo), dos a las escobillas (roto), dos del interruptor térmico de seguridad y dos del tacómetro (este dispositivo está colocado al final del eje, y es un pequeño alternador que ofrece de 0 a 30 voltios dependiendo de las RPM.

En este pequeño diagrama puedes observar como se conecta un motor universal.

Definitivamente y por la falta de espacio, decidí colocar una caja en el lateral de la lavadora para albergar los componentes del programador.

Para la alimentación de Arduino he utilizado un cargador de los nokia antiguos, pero cuando tuve que utilizar dos placas de relés, no disponía de suficientes amperaje, y tuve que meter otro cargador nokia, los puedes observar (sin la carcasa) en el lateral izquierdo de la fotografía.
En la parte central superior dos modulos de 4 reles, debajo el dimmer (que no sirvió), en el inferior derecho la placa Arduino Uno compatible, y arriba una pequeña placa que tiene las resistencias Pull-Down y conexiones al sensor de tempratura, hidronivel, alimentaciones 5v y GND´s, también un buzzer para reproducir una musiquilla cuando la lavadora ha terminado la colada.

Ahora seguiremos con el control de motor:
Googleando encontré un IC, el TDA1085C, de Motorola, que especialmente está diseñado para

controlar este tipo de motores. Información referente este componente:

• Aquí el Datasheet
• Un diagrama para fabricar la pcb.
• Lista de componentes para la pcb
• Cara inferior de la pcb, al imprimirlo debe tener un tamaño de 100 mm x 50 mm
• Cara superior de distribución de componentes

Las resistencias de 0,1 y 5w normalmente se emplean como fusibles, una idea por si te resulta difícil adquirirla.

También he encontrado que algunas personas se lo han fabricado en una placa perforada, aquí tenéis las fotos del montaje y de las conexiones:

Ahora mismo me encuentro en la fabricación del regulador y a la espera de que lleguen algunos componentes .
La idea es sustituir el potenciometro lineal por un potenciometro digital para controlarlo a través del arduino.
Seguiré actualizando la información de este post.
Aquí el código en el que estoy trabajando:

// Código C para Arduino, PROGRAMA UNIVERSAL DE LAVADORA
// Licencia Creative Commons
// Este código se ejecuta a través de mi lavadora, y pretende controlar los siguientes instrucciones:
// Control de electrovalvula de prelavado/suavizante
// Control de electrovalvula de lavado
// Supervisa el sensor de temperatura del agua termistor NTC, y por lo tanto control de su temperatura.
// Controlar la velocidad (rpm) del motor universal (de escobillas) con un PWM, y siete posibles velocidades
// Control de inversión de giro en lavado lento de ropa
// ¿Control de velocidad a través de tacometro de lavadora?
// Control de la bomba de vaciado
// Control del hidronivel
// Control de resistencia calentadora de agua
// Control de una pantalla de cristal liquido de 4 filas por 20 columnas, con control I2C
// Control de botonera: selector de temperatura, selector centrifugado(lento,rápido),selector tipo de ropa(tiempo de lavado)
// Futuras mejoras ====> inclusión de reloj para programar la hora de lavado (mejora de gasto energético)
// Esta es la revisión de código 1.0

#include <math.h>  // Se necesita para el sensor de temperatura de termistor NTC logarítmica
#include <LiquidCrystal_I2C.h>
#include "pitches.h"

#include <Wire.h>  // Usado por el chip I2C RTC, es el reloj
#include "Chronodot.h"  // Se utiliza para traer y decodificar los datos de RTC

Chronodot RTC; // Creando el objeto RTC 
LiquidCrystal_I2C lcd(0x27,21,22);
unsigned long cycleStart;  // Se utiliza para hacer el seguimiento de cuánto tiempo ha estado lavando.
// notas melodía:
int melody[] = {
NOTE_C3, NOTE_C3, NOTE_C3, NOTE_GS2, NOTE_DS3, NOTE_C3, NOTE_GS2, NOTE_DS3, NOTE_C3, NOTE_G4, NOTE_G4, NOTE_G4, NOTE_GS4, NOTE_DS4, NOTE_C4, NOTE_GS2, NOTE_DS3, NOTE_C3 };
// notas duración: 4 = quarter note, 8 = eighth note, etc.:
int noteDurations[] = {
4,4,4,4,8,4,4,8,4,4,4,4,4,8,4,4,8,4};

//Designando pines
#define OFF HIGH //no encuentro explicación porque me funcionan al contrario (·@####@@#@#@#¬€€¬€aaaaaarrrrrrgggggggg)
#define ON LOW
#define PinSinUtilizar0 0 //PIN SIN UTILIZAR
#define MotorVelocidad1 1 //pin lavado lento
#define MotorVelocidad2 2 //pin centrifugado lento
#define MotorVelocidad3 3 //pin centrifugado rapido
// BOTONES
#define BotonTemperatura 4 //pin boton de temperatura
#define BotonCentrifugado 5 // pin boton de selección velocidad centrifugado
#define BotonInicio  6 //pin boton de inicio
//#define PinBuzzer  7 //BUZZER MUSICA FINAL
#define CalentadorAgua 8 // pin enciende resistencia
#define VaciadoPin 9 //pin bomba desague
#define AguaIn1 11 //pin electrovalcula prelavado o suavizante
#define AguaIn2 10 //pin electrovalcula lavado o jabón
#define Hidronivel 12 // pin hidronivel
//#define PinPuerta  13 //PIN PUERTA
// Analógicos
#define tempSensor A4 //pin thermistor
//#define botonGO   A1
//#define botonStop A2
//#define PinSinUtilizarA3  A3 //PIN SIN UTILIZAR
//#define PinSinUtilizarA4  A4 //PIN SIN UTILIZAR
//#define PinPuerta  A5 //PIN PUERTA

void setup () {
  Wire.begin();   // Usado por el RTC
  RTC.begin();    // Igualmente
  lcd.begin(20,4);  // 20x4 LCD Panel

//declarando posición de las entradas de los pines  
  pinMode(Hidronivel, INPUT);
  pinMode(tempSensor, INPUT);
  pinMode(AguaIn1, OUTPUT);
  pinMode(AguaIn2, OUTPUT);
  pinMode(VaciadoPin, OUTPUT);
  pinMode(CalentadorAgua, OUTPUT);
  pinMode(MotorVelocidad1, OUTPUT);
  pinMode(MotorVelocidad2, OUTPUT);
  pinMode(MotorVelocidad3, OUTPUT);
  //pinMode(MotorReverse, OUTPUT);
 // pinMode(PinPuerta, OUTPUT);
 //pinMode(botonGO, INPUT);
 //digitalWrite(botonGO, ON);  // activar resistencia de actuación interna para este pin de entrada
 //pinMode(botonStop, INPUT);
 
  //INICIALIZO LOS PINES A OFF O LOW
  digitalWrite(AguaIn1, OFF);
  digitalWrite(AguaIn2, OFF);
  digitalWrite(VaciadoPin, OFF);
  digitalWrite(CalentadorAgua, OFF);
  digitalWrite(MotorVelocidad1, LOW);
  digitalWrite(MotorVelocidad2, LOW);
  digitalWrite(MotorVelocidad3, LOW);
  //digitalWrite(MotorReverse, OFF);
  //===========================esto estaba en el loop===============================================//
  lcd.backlight();
  lcd.setCursor(0,0);  
  lcd.print(F("Iniciando..."));
  //digitalWrite(PinPuerta, ON); //cierra la puerta
  //delay (3000);
  // Ir botón fue presionado, ejecute a través de los ciclos
  //OJO CONTROLAR CUANDO PASA DE UNA FUNCIÓN A OTRA
  cycleStart = millis();
  //VaciandoLavadora(15000,0);//un poco de vaciado antes de comenzar 15 sec
  delay(100);
  //llenarAgua(120000,1);//CUBETA PRELAVADO: valvula prelavado/suavizante 1, valvula jabon 2
  delay(100);
  MotorLavado(600000, 4, 40);//PRELAVADO 10 MINUTOS(600000) parametro1= tiempo de lavado, parametro2= pantalla "Lavando/Prelavado", parametro3= temperatura
  delay(100);
  VaciandoLavadora(120000,2);
  delay(100);
  //llenarAgua(120000,2);//JABÓN: valvula prelavado/suavizante 1, valvula jabon 2
  delay(100);
  //MotorLavado(1200000, 3, 10);//LAVADO parametro1= tiempo de lavado, parametro2= pantalla "Lavando", parametro3= temperatura 
  delay(100);
  //VaciandoLavadora(120000,2);//VACIA PARA COGER SUAVIZANTE
  delay(100);
  //llenarAgua(120000,1);//SUAVIZANTE: valvula prelavado/suavizante 1, valvula jabon 2
  delay(100);
  //MotorLavado(300000,5,0);//SUAVIZANTE parametro1= tiempo, parametro2= pantalla "Suavizante", parametro3= temperatura
  delay(100);
  //VaciandoLavadora(120000,2);
  delay(1000);
  //CentrifugadoSuave(120000);//SUAVE parametro1 = tiempo 1,5 minutos = 90000 ms
  //CentrifugadoFuerte(60000);//FUERTE parametro1 = tiempo
  delay(1000);
  lcd.clear();
  lcd.setCursor(0,3);
  lcd.print(F("Lavado finalizado"));
  //digitalWrite(PinPuerta, LOW);
  delay(10000);
  musica();
  musica();
  lcd.clear();
  //lcd.noBacklight();

//===========================fin esto estaba en el loop===============================================//
}
//==================================================================================================
//==================================COMIENZO FUNCIONES DEPURADAS======================================
//==================================================================================================
double Termistor(int RawADC) {
const float resistor = 9800; //El valor en ohmnios de la resistencia del termistor a 25ºC
const float voltage = 4.76; // El voltaje real en el punto 5Vcc de tu placa Arduino
//Para ahorrar cálculos lo definimos como constante en esta parte del programa
const float K= 273.15; //Para pasar a grados Kelvin
const float e = 2.718281828459045; //Constante matemática 
const float B = 3760; //Valor Beta de tu termistor, lo consegui en esta pagina, sino tendras que calcularlo http://www.amwei.com/views.asp?hw_id=61
const float unodivr = 1/(resistor * pow(e,(-B/298.15))); //Con pow elevamos e al resultado
float T = 0; //Declaramos la variable Temperatura
float tmedia; //Variable para calcular media
int cnt; //temperatura media y contador
int grados, decimas; //Para ponerle coma al resultado (en español)
int sensorPin = A4; // Selecciona la entrada para el termistor
int sensorValue = 0; // Aquí almacenamos el valor del sensor
  // Parte 1:  Leemos el puerto analógico 0 y convertimos el valor en voltios.
     sensorValue = analogRead(sensorPin); //Leemos analógico 0 
     float v2 = (voltage*float(sensorValue))/1024.0f; 
   // Parte 2: Calcular la resistencia con el valor de los voltios mediante la ecuación del divisor de voltaje
      //voltage = 4.83
      //R2 = 10000
      //R1 = Thermistor resistance
      //V2= v2
      //so V2=(R2*V)/(R1+R2)
      //and r1=((r2*v)/v2)-r2 <--final
      float r1a = (voltage*float(resistor))/v2;  
      float r1 =r1a - resistor;
   //Parte 3: Calcular la temperatura basandose en la ecuación Steinhart-Hart y la ecuación del valor Beta.
      // T=B/ln(r1/rinfinit)
       T = B/log(r1*unodivr);
       T=T-273.15; //Convertimos de Kelvin a ºC y ya tenemos la temperatura
       // ahora obtenemos la parte entera
       grados=(int)T;
       grados=(grados-24);//chapuza mia
       return grados;
}
void llenarAgua(unsigned long tiempo,int valvula) { //DOBLE SISTEMA DE SEGURIDAD, POR TIEMPO Y POR HIDRONIVEL
  lcd.begin(20,4);
  lcd.clear();
  muestraPantalla(1);
 unsigned long tiempollenado = millis();
 int hidronivelestado = 0;
 hidronivelestado = digitalRead(Hidronivel); //lectura del pin hidronivel
  //while (((millis() - tiempollenado) < tiempo) && (hidronivelestado == 0))  {
    while (((millis() - tiempollenado) < tiempo))  {
    //while (hidronivelestado == HIGH)  {
            if(valvula == 1){digitalWrite(AguaIn1, ON);}else{digitalWrite(AguaIn2, ON);}
            hidronivelestado = digitalRead(Hidronivel);
      }     
      digitalWrite(AguaIn1, OFF);
      digitalWrite(AguaIn2, OFF);
  delay(100);
  lcd.begin(20,4);
  lcd.clear();
}
void VaciandoLavadora(unsigned long tiempo,int pantalla) {//argumento1=tiempo, argumento2=1(iniciando) 2(vaciando)
  unsigned long vaciadoTiempo = millis();                      
  muestraPantalla(pantalla);
  while ((millis() - vaciadoTiempo) < tiempo) {  
    digitalWrite(VaciadoPin, ON);
    delay(100);
  }
  digitalWrite(VaciadoPin, OFF);
  delay(100);
  lcd.begin(20,4);
  lcd.clear();
}
void MotorLavado(unsigned long tiempo, int pantalla, int temperatura) { //argumento1=tiempo, argumento2=indicación pantalla, argument3=temperatura
  lcd.begin(20,4);  // La pantalla aparece cuando el motor entra en acción
  muestraPantalla(pantalla);
  unsigned long tmpmotorgiro = millis(); 
      //temperatura variables y lecturas
      int val;//Crea una variable entera                
      int temp;//Variable de temperatura = temp            
      val=analogRead(A4);//Lee el valor del pin analogo 2 y lo mantiene como val      
      temp=Termistor(val);//Realiza la conversión del valor analogo a grados Celsius
      while (temp < temperatura) {//mientras no alcance la temperatura esta activado la resistencia calentadora de agua
          digitalWrite(CalentadorAgua, ON);
          delay(100);
          temp=Termistor(val);//devuelve la temperatura
          } 
          digitalWrite(CalentadorAgua, OFF);
      //fin temperatura variables y lecturas
    while ((millis() - tmpmotorgiro) < tiempo) { //mientras lavado, gira en motor en ambos sentidos
          muestraPantalla(pantalla);
          while (temp < temperatura) {//mientras no alcance la temperatura esta activado la resistencia calentadora de agua
          digitalWrite(CalentadorAgua, ON);
          delay(100);
          temp=Termistor(val);//devuelve la temperatura
          } 
          digitalWrite(CalentadorAgua, OFF);
      //fin temperatura variables y lecturas
              //GIRA A DERECHA
              digitalWrite(MotorVelocidad1, HIGH);
              delay(3000);            
              digitalWrite(MotorVelocidad1, LOW);
              delay(6000);
                
    }
  digitalWrite(CalentadorAgua, OFF);
  delay(100);
  digitalWrite(MotorVelocidad1, LOW);
  delay(100);
  lcd.begin(20,4);
  lcd.clear();
}
void CentrifugadoSuave(unsigned long tiempo) {
  lcd.begin(20,4);  // La pantalla aparece cuando el motor entra en acción
  digitalWrite(VaciadoPin, ON);
  unsigned long tmpmotorgiro = millis(); 
    while ((millis() - tmpmotorgiro) < tiempo) { //mientras lavado, gira en motor en ambos sentidos
              //digitalWrite(MotorVelocidad1, HIGH);
              //digitalWrite(MotorVelocidad2, HIGH);
              digitalWrite(MotorVelocidad3, HIGH); //solo el 3 500 rpm
          delay(100);
      muestraPantalla(6);
    }
    digitalWrite(MotorVelocidad1, LOW);
  digitalWrite(MotorVelocidad2, LOW);
  digitalWrite(MotorVelocidad3, LOW);
  delay(10000);
  digitalWrite(VaciadoPin, OFF);
  lcd.begin(20,4);
  lcd.clear();
}
void CentrifugadoFuerte(unsigned long tiempo) {
  lcd.begin(20,4);  // La pantalla aparece cuando el motor entra en acción
  unsigned long tmpmotorgiro = millis(); 
    while ((millis() - tmpmotorgiro) < tiempo) { //mientras lavado, gira en motor en ambos sentidos
              // 1500 rpm
              digitalWrite(MotorVelocidad1, HIGH);
              digitalWrite(MotorVelocidad2, HIGH);
              digitalWrite(MotorVelocidad3, HIGH);
          digitalWrite(VaciadoPin, ON);
          delay(100);
      muestraPantalla(7);
    }
  delay(10000);
  digitalWrite(VaciadoPin, OFF);
  delay(100);
  digitalWrite(MotorVelocidad1, LOW);
  digitalWrite(MotorVelocidad2, LOW);
  digitalWrite(MotorVelocidad3, LOW);
  delay(100);
  lcd.begin(20,4);
  lcd.clear();
}
void musica(){
    for (int thisNote = 0; thisNote < 18; thisNote++) {
    int noteDuration = 1000/noteDurations[thisNote];
    tone(7, melody[thisNote],noteDuration); //conecta el pin 7
    int pauseBetweenNotes = noteDuration * 1.30;
    delay(pauseBetweenNotes);
    noTone(7); //desconecta el pin 7
  }
}
//==================================================================================================
//==================================================================================================
//==================================================================================================

void muestraPantalla(byte currentMode) {  // No estoy contento con esta rutina. Necesita trabajarla
  unsigned long elapsedSeconds = ((millis() - cycleStart) / 1000); // Vamos con el número de segundos transcurridos
  unsigned long elapsedMinutes = (elapsedSeconds / 60);
  unsigned long elapsedHours = (elapsedMinutes / 60);
  lcd.setCursor(0,0);
  lcd.print(F("Tiempo lavado: "));
  if (elapsedHours > 0) { // No mostrar las horas transcurridas si ha transcurrido menos de una hora.
    lcd.print(elapsedHours);
    lcd.print(':');
    if (elapsedHours == 1) elapsedMinutes -= 60;
    if (elapsedHours == 2) elapsedMinutes -= 120;
  }
  if (elapsedMinutes < 10) { // Sólo muestra un solo dígito, por lo que necesita un cero de más.
    lcd.print('0');
  }
      //temperatura
    int val;//Crea una variable entera                
    int temp;//Variable de temperatura = temp            
    val=analogRead(A4);//Lee el valor del pin analogo 2 y lo mantiene como val      
    temp=Termistor(val);//Realiza la conversión del valor analogico a grados Celsius 
    //temperatura
  lcd.print(elapsedMinutes);
  lcd.setCursor(0,1);
  lcd.print(F("Temp Agua: "));  
  lcd.print(temp);
  delay (1000);
  lcd.print('C');
  lcd.setCursor(0,3);
  switch (currentMode) {
  case 0:
    lcd.print(F("Iniciando"));
    break;
    case 1:
    lcd.print(F("Llenando"));
    break;
  case 2:
    lcd.print(F("Vaciando"));
    break;
  case 3:
    lcd.print(F("Lavando ropa"));
    break;
  case 4:
    lcd.print(F("10 minutos Prelavado"));
    break;
  case 5:
    lcd.print(F("Suavizante"));
    break;
  case 6:
    lcd.print(F("Centrifugado suave"));
    break;
  case 7:
    lcd.print(F("Centrifugado fuerte"));
    break;
  }  
}

void loop() {/*
    int val=analogRead(A4);//Lee el valor del pin analogico y lo mantiene como val      
    int temp=Termistor(val);//Realiza la conversión del valor analogico a grados Celsius 
    
  lcd.clear(); 
  lcd.setCursor(0,1);
  lcd.print(F("Temp Agua: "));  
  lcd.print(temp);
  delay (1000);
  lcd.print('C');  
 
  while (temp < 65) {//mientras no alcance la temperatura esta activado la resistencia calentadora de agua
          digitalWrite(CalentadorAgua, ON);
          delay(100);
          temp=Termistor(val);//devuelve la temperatura
              lcd.clear(); 
              lcd.setCursor(0,1);
              lcd.print(F("Temp Agua: ")); 
            lcd.print(temp);
            delay (1000);
            lcd.print('C');
          } 
          digitalWrite(CalentadorAgua, OFF);       
*/
}