Ahorrar energía con un enchufe temporizado: Hazlo tú mismo con Arduino

He aprovechado este enchufe Wifi para construir un enchufe con cuenta atrás

Tenía un enchufe wi-fi programable Contros de Broadlink estropeada la tarjeta wifi (ya me habían enviado otro en su lugar):

 y dándole al coco me dí cuenta que podía venir muy bien un enchufe que se activara por un determinado tiempo sólo con pulsar su botón, con incrementos del mismo tiempo a cada pulsación (similar a como trabajan los microondas electrónicos, que con cada pulsación del botón de calentado rápido añade 30 segundos al tiempo). Una imagen vale más que mil palabras:

Podríamos usar este enchufe en muchos casos; yo por ejemplo tengo una cafetera Philips con el botón bastante inaccesible que hay que encender y apagar cada vez que se usa para que no esté consumiendo siempre al mantenerse caliente. En este caso la activaríamos a la mañana con una simple pulsación del botón y la tendríamos preparada por una hora.Otro ejemplo son los enchufes mata-mosquitos (de líquido o pastillas) que muchas veces se olvidan encendidos, contaminando el ambiente con veneno sin necesidad ya que, si os fijáis, todos mueren al de media hora y dos horas, y no es necesario más tiempo a menos que dejemos una ventana abierta. En este caso evitaremos veneno en nuestro organismo que a la larga puede afectar a nuestro sistema nervioso (o puede que no, y los máximos de exposición por los que se regulan estos aparatos sean saludables, pero lo más saludable es evitarlo), además de ahorrar en el consumible.

Actualización: Si queréis prácticamente la misma funcionalidad, con la ventaja de apagarlo también desde el botón, he encontrado a la venta en internet el Ansmann AES 1 Zero después de haber montado el mío (aunque lo aprendido también cuenta ;):

Un enchufe así (que no sé si estarán disponibles a la venta) es muy sencillo de construir con Arduino, y es más útil que uno Wifi en algunos casos. El problema es que si queremos hacerlo lo más compacto posible, debemos usar una placa lo más pequeña posible (más que el Nano). Y más en este caso que la caja del Contros reciclada no es amplia precisamente:

En estos menesteres compactos y sencillos es donde entra en juego las placas Attiny de Digispark, pequeñas pero potentes.

Hasta que no me he dado cuenta de que el número del pin analógico de entrada no corresponde al de la placa (para los digitales sí), me he vuelto loco preguntándome qué es lo que fallaba, pues lo probaba en un Arduino Uno y funcionaba correctamente, pero no al poner el mismo código en el ATtiny85. Cuanto antes os leáis y memoricéis las diferencias, antes podréis sacarle partido a sus cualidades en una placa de tan sólo 20x20mm:

1. El Digispark funciona con un Atmel Attiny85 MCU - presenta algunas diferencias respecto del  ATmega328 y algunas librerías no funcionan correctamente, pero irá mejorando con el tiempo.
2. El Digispark sólo tiene 6 KB de memoria disponible para nuestro código (8 KB si eliminamos el bootloader USB virtual y lo programamos directamente con un Arduino UNO).
3. El Pin 3 y el Pin 4 (P3 y P4) se usan para las comunicaciones y programación USB; aunque sólo interfiere si utilizamos la conexión USB y se pueden utilizar mientras que no usemos la conexión USB en el diseño final, pero hay que tener en cuenta que si el programa actúa dramáticamente sobre el voltaje de los mismos, será mejor desconectarlo una vez que hemos subido el programa por el USB.
4. El Pin 3 (P3) tiene conectada una resistencia de pull-up de 1.5 kΩ que se requiere cuando P3 y P4 se usan para comunicación USB (programación incluída). Tu diseño tendrá que tenerlo en cuenta ya que tendrías que sobrealimentar el pin para ponerlo en LOW.
5. El Digispark no tiene un puerto serie hardware ni un convertidor a USB. Se proporciona una librería de ejemplo (DigiUSB) así como algún código de ejemplo y un programa monitor serie, pero la comunicación con el ordenador no será siempre conectar y listo, especialmente cuando hay otras librerías en uso.
6. Al encenderse no hace nada hasta 4 segundos después, ya que es el tiempo de espera que tiene programado para la programación por USB (ésto creo se puede eliminar programándolo directamente, pero no lo he probado), por lo que hay que tenerlo en cuenta si necesitamos que arranque rápido el programa.
7. Mientras que las conexiones digitales corresponden a los pines (digitalRead(0) donde 0=Pin0), la correspondencia de los pines analógicos cambian:

analogRead(1); //Read P2
analogRead(2); //Read P4
analogRead(3); //Read P3
analogRead(0); //Read P5

Para programar el Digispark

Tenemos que instalar la versión 1.6.6 o superior y seguir las instrucciones de su página. A mí me costó hacerlo funcionar en un Windows 10, pero no desesperéis porque o bien reiniciando o volviendo a instalar los controladores y reiniciando, se arregla.
El procedimiento de programación es diferente al Arduino; el Digispark no hay que tenerlo conectado, sino que primero le damos a volcar programa desde el IDE, y nos indicará que lo conectemos (cuando se conecta por USB está 4 segundos esperando la conexión para la programación), Windows avisará de la conexión y desconexión USB y finalmente el IDE nos avisará en la ventana de estado que se ha programado correctamente.

Necesitaremos el siguiente material

• Un aparato programador o enchufe con derivación para activar o desactivar el conectado; yo he usado un Broadlink Contros estropeado.
• Un transformador de 85/240V AC a 5V DC de al menos 300mA para alimentar el Digispark y el relé.
• Un Digispark (o Arduino Nano si tenéis espacio).
• Un relé de al menos 10A y que se active con 5V digital (alimentado).
• Soldador, estaño, tijeras, cinta aislante, cables finos; lo usual.

Yo intenté usar una fuente de 9V con un regulador de voltaje L7805 pero se calentaba demasiado y no tenía sitio para ponerle disipador; mejor ir a lo óptimo con una fuente ya regulada a 5V eficiente.

Por otro lado intenté aprovechar el relé que tenía el Contros de 16V, pero sobrecargaría el pin del Arduino al activarlo, por su alto consumo (no tenía pines de alimentación independiente); veréis algunas fotos de los diseños preliminares con alguno de estos cambios, pero hablaré siempre del diseño definitivo.

Para aprovechar el Contros debemos averiguar cómo funciona el circuito del botón y led azul y blanco.

A mí sólo me interesaba regular la intensidad del led azul y poner en LOW uno de los pines digitales con el interruptor; al final corté la pista que unía el led y el interruptor a +5V ya que para poner en LOW un pin tenemos que conectarlo a GND (ground, Tierra). Las buena práctica en un aparato que va a estar conectado mucho tiempo es definir los pines de entrada con la resistencia pull-up (pinMode(botonPIN, INPUT); digitalWrite(botonPIN,HIGH);) para evitar posibles cortocircuitos causados por error o fluctuaciones por situación indefinida del pin que puedan darnos problemas.

Éste sería el esquema Fritzing; el relé no está bien indicado pues no he encontrado uno igual, pero creo que se entiende:

Podéis descargarlo aquí, y aquí el Digispark para incluírlo en tus propios proyectos

Conectamos todo según el esquema (el regulador en la imagen siguiente sólo es necesario si la fuente es de más de 5V DC):

He soldado y reforzado las pistas de la conexión al relé, soldándolo directamente en vez de usar los tornillos incluídos; éste es el polo que se conecta o desconecta para cerrar el circuito con el aparato que conectemos. El otro polo va conectado directamente y sólo he sacado el cable de alimentación del transformador:

Meter todo en su sitio es complicado, los que tenéis impresora 3D podréis fabricaros una cajita a la medida; tenemos que asegurarnos de aislar todo bien para que no haya ningún corto. En la siguiente imágenes, la versión anterior donde aprovechaba el relé del Contros:

Que luego cambié por un relé alimentado para evitar problemas de desgaste del chip Atmel:

El código para el enchufe sería como sigue:

 /* ==================================================================  
   
  Sketch control relé temporizado por horas; cada vez que se pulsa el botón añade una tiempo predefinido de funcionamiento.  
    
  Autor: David Losada.  
  Version: 0.1  
  Fecha: 13 de julio de 2016  
   
   
   ==================================================================  */  
   
 //#include <LiquidCrystal.h> //He utilizado primero un MEGA 2560 con pantalla LCD Keypad Shield para probar el código antes de pasarlo  
   
 // select the pins used on the LCD panel  
 //LiquidCrystal lcd(8, 9, 4, 5, 6, 7);+  
   
 //Definición pines digitales para activar relés  
   
 //PINES USADOS; no uso el 3 ni el 5 porque ambos me daban problemas mientras tenía el USB conectado  
 long timeBoton=3600; //Tiempo en segundos que añade por cada pulsación al temporizador  
 int botonPIN=0; //3 Pin de botón configuración  
 int relePIN=2; //4 Pin activación relé  
 int luzPIN=4; //Pin de luz indicadora  
 int ledPIN=1; //Led del aTTiny85 ver. B está en 1  
   
 //Variables programa  
 long timeLED=0; //Para encender el LED cada segundo  
 long tiempoRele=0; //Tiempo total al que configuramos para activarlo  
 long tPrevRele=0; //Momento en que ha empezado a funcionar el rele  
 boolean boton=false; //Botón ha sido pulsado  
 boolean luzON=false; //Si la luz azul está encendida  
   
 void setup()  {   
    
  //Definir pines  
 pinMode(botonPIN, INPUT);  
 pinMode(relePIN, OUTPUT);  
 pinMode(luzPIN,OUTPUT);  
 pinMode(ledPIN,OUTPUT);  
 digitalWrite(botonPIN,HIGH); //Evitamos fluctuaciones activando con LOW  
   
 //lcd.begin(16,2); //pantalla de 16 caracteres y 2 filas  
 }  
   
 void loop()   
 {  
   
 //Comprobamos si se pulsa el botón  
  if (digitalRead(botonPIN)==LOW && boton==false) {  
   boton=true;  
   luzON=false; //apagamos momentáneamente la luz como indicador de pulsación  
  }  
   
 //Si el botón se suelta añadimos hora al tiempo  
  if (digitalRead(botonPIN)==HIGH && boton==true) {  
   boton=false;  
   tiempoRele=tiempoRele+(timeBoton * 1000);  
   luzON=true;  
    }  
      
 //Se acaba de activar el tiempo; marcamos inicio  
 if (tPrevRele==0 && tiempoRele>0) {  
  tPrevRele=millis();  
 }  
   
 //Cuando pasan 50 días millis se resetea  
 if (tPrevRele>millis()) {  
  tPrevRele=0;  
 }  
   
 //Mientras no haya pasado el tiempo establecido, activar Relé  
 if (tiempoRele>0 && (millis()-tPrevRele)<tiempoRele) {  
   digitalWrite(relePIN,HIGH);   
 }  
  else {  
   digitalWrite(relePIN,LOW);  
   luzON=false;  
   tiempoRele=0;  
   tPrevRele=0;   
  }  
    
     
  //lcd.setCursor(0,0);  
  //lcd.print("Temp: ");  
  //lcd.setCursor(7,0);  
  //lcd.print(Temp);  
  //lcd.setCursor(0,1);   
  //lcd.print(fanSpeed);   
   
 //Si la luz es ON, encendemos Luz  
 if (luzON==true) {  
  analogWrite(luzPIN,255); //Encendido total, relé activado  
 }  
  else {  
   analogWrite(luzPIN,10); //Encendido levemente; está funcionando  
  }  
   
 //Hacemos parpadear al LED comprobando el tiempo desde la última activación  
  if (timeLED>millis()) { //Cuando pasen 50 dias resetear  
   timeLED=millis();  
  }  
  if ((millis()-timeLED)>1000) {  
    analogWrite(ledPIN,100); //enciende LED indicando funcioanmiento  
    timeLED=millis();  
  }  
   if ((millis()-timeLED)>500) {  
    analogWrite(ledPIN,0); //apaga led  
   }  
  delay(100); //Más de este tiempo no es recomendable o el botón no responderá bien  
 }  

Este es sólo un ejemplo del mundo de posibilidades que se abren con estas económicas y pequeñas placas programables Digispark. ¡Felices proyectos!

Más información y enlaces:

Digispark tutorial conexión

Digispark Attiny85 diferencias con Arduino