viernes, 13 de marzo de 2015

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:
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);       
*/
}

33 comentarios:

  1. Hola:

    Me estoy fijando el esquema que hiciste, precisamente este.
    https://drive.google.com/file/d/0B1RnTBfBuGhiQXJmWVN2UGY3Tk0/view

    No es idéntico a la hoja de datos del TDA1085C.
    https://drive.google.com/file/d/0B1RnTBfBuGhiXzdpNkVmblUwSDQ/view

    Primera pregunta si no es molestia.
    1) ¿Hay alguna diferencia sobre el comportamiento del TDA1085C de tu esquema con el original?

    2) Hay condensadores que no has puesto en la lista sobre los voltajes, por ejemplo:

    C7: 47nF Poliester
    C8, C11: (2) 100nF Poliester
    C9: 680pF Poliester

    3) En cuanto a este de C10, C11: (2) 100nF / 230V ~ Poliester, ¿no es mejor usar 400 V. ya que usa en este caso cargas inductivas como un motor?

    Por lo que he leído arriba, aún no lo has montado. Antes de comprar todos sus componentes del TDA1085C, espero qu elo publiques y nos cuentes tus experiencias.

    Mientras sigo experimentando como regular el motor de forma estable, qu epuedes ver por aquí como curiosidad.
    http://electronica-pic.blogspot.com.es/2015/06/regulador-velocidad-motor-de-lavadora.html

    En cuanto al proyecto, buen trabajo.

    ResponderEliminar
    Respuestas
    1. Hola, disculpa que te conteste varios días después. Intentaré resolver algunas de tus dudas.
      A la primera pregunta: Si hay diferencias de comportamientos.
      A la segunda: Si no se indican los voltajes es que son bajos o desechables, no me acuerdo ahora mismo, pero algunos serán de 1,5v, para resolver esa duda puedes ver los diferentes voltajes de las patillas en el datasheet. Creo recordar que solo dos patillas tenían alto voltaje.
      A la tercera: Si, podrías usar 400v y probablemente sea mejor.

      Tengo varios cambios en le esquema, que intentaré actualizar cuando tenga más tiempo:
      En la patilla 7, el C6 es de 479mF y R7 de 1,5 Megas.
      La patilla 6, a ver como me explico...imagínate que trasladas la lína de la patilla 5 a la seis, y cambias la resistencia por una de valor 68k y el condensador del mismo valor, el similar de R5 no existe en la patilla 6. Esta patilla finaliza en un componente X2-3 y lleva un potenciometro de ajuste entre X2-1 y X2-3.
      Espero haberme expresado correctamente, sin más, recibe un cordial saludo y te agradezco tu comentario.

      Eliminar
  2. Hola:

    No encuentro el X2-3, están todos menos ese. Lo que explicaste arriba.
    https://drive.google.com/file/d/0B1RnTBfBuGhiQXJmWVN2UGY3Tk0/view

    Cuando puedas, si actualizas al final el esquema, avisas por aquí como que has actualizado, así me lleva un mensaje y me entero. Si llegas hacer la placa por ti mismo sobre el TDA1085C, también, para verlo. Así me cuentas tus experiencias, de paso, lo monto.

    Otras personas me han contado que mejor hacerlo con tres optoacopladores, dos de entrada y uno de salida. Estas so nsus palabras.

    Por tanto y partiendo de la necesidad de usar el taco generador puedes optar por hacerlo de dos maneras distintas. - Por hardware. - Por software. Por hardware: Puedes emplear el método que conozcas o prefieras, usar el TDA1085C, operacionales, transistores, etc. Por software: Necesitas un pequeño interfaz que suministre al Arduino la señal del taco generador y una señal del paso por cero de la tensión de la red eléctrica. Ambas señales es IMPRESCINDIBLE que estén optoacopladas a las entradas del Arduino para mantener el aislamiento galvánico de la red. El Arduino deberá calcular un retardo al punto de disparo partiendo de la señal de paso por cero, y teniendo en cuenta la velocidad seleccionada. y la velocidad REAL del motor obtenida de la señal que suministra el taco generador. Las señal (pulso) de disparo al triac de control del motor, debe hacerse por medio de un optoacoplador SIN CIRCUITO INTERNO DE PASO POR CERO, es decir, el triac del optoacoplador debe responder SOLO al pulso de disparo que le suministra el Arduino en el mismo instante que lo recibe. Ésta es la forma en que debe hacerse, eres libre de buscar atajos. La forma más sencilla es la que yo empleo (método hardware), pero la más eficaz, económica, elegante y precisa es por software embebido en algún microcontrolador o Arduino.

    Por ahora parece más recomendable el TDA1085C.

    Sigo experimentado con motores por aquí de mi lavadora.
    http://electronica-pic.blogspot.com.es/2015/06/motor-en-marcha-en-la-lavadora-beko.html


    Gracias por tu tiempo, y de nuevo me sorprende tu trabajo. ;)

    ResponderEliminar
  3. Este comentario ha sido eliminado por el autor.

    ResponderEliminar
  4. Hola
    Estoy muy interesado en saber como has avanzado en este ambicioso proyecto, ya que no veo actualizaciones recientes. Saludos y gracias por publicar tus conocimientos

    ResponderEliminar
  5. Hola, me sumo a estos proyectos pero tengo curiosidad de cómo controlar el giro del motor de forma eficiente.

    ResponderEliminar
  6. Hola:

    Aquí también hay algo de info.
    http://electronica-pic.blogspot.com.es/2014/04/proyecto-disenar-placa-del-frontal-de.html

    Saludos.

    ResponderEliminar
  7. Que sepas que esto es paja, el mio va a estar mejor
    saludos

    ResponderEliminar
    Respuestas
    1. Si es el que compró tu madre, seguro que es mejor.

      Eliminar
    2. Yo tambien ando liao para controlar las rpm aqui en alcala. Dejame tu email si quieres

      Eliminar
    3. Hola Francisco:

      Mi e-mail lo puedes ver encortada o en contacto en este Blog.
      http://electronica-pic.blogspot.com.es/2014/04/proyecto-disenar-placa-del-frontal-de.html

      Sí, un poco tarde me doy cuenta que me haz escrito, aún sigo aquí, muchas gracias.

      Un cordial saludo.

      Eliminar
  8. Estoy intentando hacer el diseño con placa, pero tengo la duda de donde se conecta a 220v (que punto es en la placa) y en la foto de los componentes veo un cable como blanco, eso es para un potenciometro que regulla la velocidad,no? o bien si puedes indicar donde localizar a quien a hecho esa placa. Muchas gracias

    ResponderEliminar
  9. tu esposa te esperó, porque la mia no.

    ResponderEliminar
  10. Hola. Me pregunto si se puede controlar las rpm y el torque del motor con un pwm de ac? Saludos

    ResponderEliminar
    Respuestas
    1. Hola, no, no puedes controlar el Torque con un pwm, por lo tanto limita el uso en proyectos que necesiten alto Torque. Si lees la entrada completa verás que lo solucioné con un IC de Motorola que dedica especialmente a lavadoras.

      Eliminar
  11. Hola. Me pregunto si se puede controlar las rpm y el torque del motor con un pwm de ac? Saludos

    ResponderEliminar
  12. Hola:

    Quiero saber el esquema o circuito del tacómetro para poder hacer pruebas.
    ¿Algún ejemplo?

    He hecho es esquema sobre el cambio de giro del motor de lavadora. Pero no encuentro un buen esquema para montarlo sobre el tacómetro, que luego debo pasar esa información a Arduino.

    Ver esquema:
    http://4.bp.blogspot.com/-haKht4xtXo4/VoeURChORZI/AAAAAAAAA8Y/bHvbAb5ni-I/s1600/Esquema%2BLavadora.gif

    Más información sobre el control del motor de lavadora:
    http://www.forosdeelectronica.com/f21/pwm-motor-lavadora-107649/index17.html

    Saludos.

    ResponderEliminar
    Respuestas
    1. No instalé ningún tacómetro, las rpm fueron medidas con un tacómetro externo.
      En el esquema que adjuntas interpreto que no existe pausa en la inversión del giro del motor, y por la torsión vas a experimentar un desgaste/rotura de ejes, correas, poleas, rodamientos, etc.

      Eliminar
  13. Buenas campeón:

    Parte 1:
    La parte que dices del tacómetro. Con la lavadora normal, has medido las tensiones del tacómetro dependiendo los RPM. ¿O solamente haz cogido la información de las revoluciones (RPM)?

    Muy ingenioso por tu parte, no se me había ocurrido.

    ¿Puedes ser más detallado o qué técnica realmente haz usado?
    La que iba hacer yo es coger los valores directamente del tacómetro guiado por este enlace. Por lo que veo, tu técnica ahorra electrónica.
    https://sites.google.com/site/electronicaanalogicam/2--amplificadores-oper/2-3--comparadores/2-3-1--detectores-de-cruce-por-cero

    Se puede usar:
    http://www.bristolwatch.com/ele2/zc/z2.jpg

    Hoja de datos del optoacoplador H11AA1:
    http://www.vishay.com/docs/83608/h11aa1.pdf

    Parte 2:
    El esquema que adjunto es de pruebas no el proyecto final. Lo comento para que la gente lo sepa.

    Si hay pausa de como mucho 2 segundos, que es lo que le ocurría mi lavadora. Mi lavadora la tuve que tirar porque la puerta se rompió, me pedían 150 € comrparla en desguace, lavadora duró 10 años, porque le hacía manteniento. Dentro de unos día me van a dar otra lavadora con el frontal quemado y no sirve, se reventó muchas cosas incluido su microcontrolador, todo los demás componente funciona.

    El esquema de arriba cuando se detiene el motor, con el tacómetro puedes detectar 0 movimiento o 0 RPM, aplica 1.5 segundos o 2 seg. cambia de relé en pausa y luego otra vez cambio de giro.

    He estado haciendo pruebas con tiempos rápido. Puse una bombilla como si fuera el motor para hacer pruebas.

    Ver vídeo:
    https://www.youtube.com/watch?v=5zZ8jc8QUD0

    No haga caso el tiempo del equema de arriba y del vídeo, son de pruebas. El tiempo real no es como la lavadora real, ya sería otra pruebas.

    El esquema y vídeo se hizo para tener una idea. El comportamiento real es 15 seg. dando un giro, se detiene el motor hasta que el RPM detecte 0 cuenta 1.5 seg. ya detenido completamente y empieza a girar otros 15 seg. en otro sentido. Ya se hará otro esquema real pero con Visual Studio .net com simulación.

    Te presento la simulación a mano con Visual Studio .net a mano. Más adelante se puede pasar los datos al ordenador o PC y se mueve el dibujo a la velocidad real de la lavadora, incluyendo los RPM.

    Ver imagen:
    https://www.subeimagenes.com/img/lavadora-1785513.PNG

    Este está hecho desde el 2014. Voy hacer mejoras automáticas que al usuario pueda elegir la velocidad del motor y la gente vea como se comporta. Simplemente haré un simulador, mucho más adelante, tanto en PC como en Android que se muestre la información de la lavadora pero esto es para lo último y no es como prioridad, más bien como curiosidad, probar tonterías.

    Parte 3:
    Lo que me interesa es como hicieste o que técnica hiciste lo del RPM ya medido y lo escribiste dentro del microcontrolador.

    Un cordial saludos.

    ResponderEliminar
  14. Este comentario ha sido eliminado por el autor.

    ResponderEliminar
  15. Buenas:

    Dejo dos programas simulador de lavadora.
    http://www.cambatronics.com/web/media/kunena/attachments/500/Simulador_motor.zip

    Uno de ellos deja claro en que rango debe ir arduino para controlar el motor de lavadora dependiento del tacómetro, así el tambor tiene una velocidad constante.

    Lo prueban y nos cuenta experiencia sobre estos programas.

    Saludos.

    ResponderEliminar
  16. ¿En qué parte del programa de Arduino, controla la velocidad del motor gracias al tacómetro?

    ResponderEliminar
  17. por que no acoplar un encoder a la flecha del motor para controlar los giros y revoluciones via PWM mediante un pequeño variador de frecuencia.

    ResponderEliminar
  18. Hola. Estoy interesado en realizar un proyecto asi. Alguien quiere ser participe de mi proyecto? Gracias y un saludo

    ResponderEliminar
    Respuestas
    1. Yo encantado, estoy haciendo un simulador de un menú LCD 16x2 con Arduino en PC, si todo va bien, lo apso ha arduino.

      Ejemplo vídeo.
      https://www.youtube.com/watch?v=razkgZR9oY4


      Saludos.

      Eliminar
  19. pero que genios, es un gran trabajo felicitaciones.

    ResponderEliminar
  20. wauuuu, que son inteligentes Usted. Pensé que yo también podía hacerlo, pero si hago esto me demoraré como 2 meses.
    saludos!

    ResponderEliminar
  21. POR CULPA DEL CORONAVIRUS algunos vecinos se han quedado sin poder recibir la visita de un Técnico. Además hay que luchar contra el robo al que llaman OBSOLESCENCIA PROGRAMADA, pero que es un robo más como otro cualquiera.
    Alquien con quien pueda hablar para fabricar el CONTROLADOR DE LA LAVADORA en serie y ponerlo al alcance de todo el mundo?

    ResponderEliminar
    Respuestas
    1. Conmigo puedes contar. Estoy dispuesto a colaborar y aprender todo lo necesario para llevar a cabo éste proyecto.
      Si quieres, nos ponemos en contacto vía correo electrónico.
      Un saludo y ya me dices.

      Eliminar
  22. Con las ganas que tengo de hacer el proyecto.
    Por ahora quiero saber controlar el tacómetro del motor de lavadora y controlar el giro del tambor sin que vaya muy rápido o muy lento.

    ResponderEliminar