Relé con Arduino y ESP8266 para crear una lámpara inteligente

Luis del Valle Hernández

hace 4 años

lámpara inteligente relé con arduino y esp8266

Controla la luz de una estancia con un relé y Arduino MKR1000

Encender la lámpara de mi escritorio es un poco complejo. Bastante. Tiene el interruptor detrás de la mesa.

Eso junto con que soy un perro y no me apetece tener que desmontar el único tornillo que tiene la lámpara y cambiarla de sitio, me ha llevado ha escribir este tutorial de cómo utilizar un relé con Arduino.

Porque sí, en este blog se habla de Arduino. Y sí, sé que hay soluciones en el mercado que ya hacen todo esto y además se conecta con Alexa.

Pero si quieres conocer una tecnología, un componente o una placa, lo que mejor resultado da es aprender cómo funciona con un caso práctico.

A parte de la lámpara inteligente con un relé y Arduino, aprenderás todos los secretos que esconde este componente electromecánico.

Ahora bien, si hasta ahora hemos trabajado con tensiones del orden de 5V y 3,3V inocuas para el ser humano, cuando conectas un relé a la red eléctrica la cosa cambia. Se vuelve muy peligroso.

Extrema la precaución con este tutorial y toma todas las medidas de seguridad necesarias para trabajar con altos voltajes. Avisado quedas :)

Ahora sí, vamos a empezar viendo qué es un relé y por qué debemos utilizarlo con Arduino.

Indice de contenidos

1 ¿Qué es un relé y por qué debemos usarlo con Arduino?
2 ¿Cómo funciona un relé?
3 Módulos relé con Arduino y ESP8266
4 Cómo conectar un relé con Arduino o ESP8266
5 Código de control de un relé con Arduino o ESP8266
6 Cómo conectar un relé con Arduino o ESP8266 a la red eléctrica
7 Lámpara inteligente utilizando un relé con Arduino
8 Ejercicios propuestos de relé con Arduino
9 Conclusiones lámpara inteligente utilizando un relé con Arduino

¿Qué es un relé y por qué debemos usarlo con Arduino?

El relé (en inglés, relay) es un dispositivo que es utilizado para controlar el encendido y apagado de dispositivos que requieren altos voltajes o altas corrientes mediante una señal de corriente continua como las proporcionadas por los pines de un Arduino UNO o ESP8266.

Tal vez estás pensando que eso mismo lo puedes hacer con un transistor BJT o incluso con un transistor MOSFET como ya vimos en algún tutorial anterior.

Sin embargo, esta afirmación es una verdad a medias. Me explico.

Si bien es cierto que con un BJT o un MOSFET puedes controlar grandes cargas, estos solo permiten controlar circuitos de corriente continua. Eso implica que si planeas controlar la típica bombilla del portal o del jardín, no es suficiente con un transistor.

En su lugar debes utilizar un relé con Arduino que permite controlar cualquier tipo de circuito ya sea de corriente alterna o continua.

¿Cómo funciona un relé?

Principalmente existen dos tipos de relés: los electromecánicos y los de estado sólido o SSR (de las siglas en inglés Solid State Relay).

La principal diferencia entre ellos es que los electromecánicos cuentan internamente con partes móviles, de ahí que sean mecánicos. Los de estado sólido por el contrario, están compuestos por dispositivos semiconductores: diodos, transistores, tiristores y triacs.

Aunque el funcionamiento principal de los dos tipos de relés es el mismo, su funcionamiento interno es muy diferente. En este artículo sólo veremos los relés electromecánicos dejando los de estado sólido para otro tutorial.

Tú casa, al igual que la mía, está plagada de interruptores mecánicos como los típicos pulsadores o apliques que utilizas para encender las luces o tocar el timbre de la puerta.

Un interruptor mecánico está formado por dos placas de metal que son unidas o separadas mediante una palanca o pulsador. De ahí que se llame mecánico, ya que se abre o cierra mediante un movimiento que tú realizas.

Un relé no es más que un interruptor como el de tu casa pero con características algo especiales.

Al igual que un interruptor mecánico, un relé cuenta con dos placas de metal que pueden ser unidas o separadas. La diferencia es que en este caso no se utiliza una palanca o un pulsador para unirlas o separarlas.

En su lugar se utiliza una corriente eléctrica, de ahí que se le denomine electromecánico.

Principio de funcionamiento de un relé mecánico

El principio de funcionamiento de un relé es muy sencillo. Imagínate que tienes dos placas una en frente de la otra. Una es la parte móvil y otra la parte fija. En medio se sitúa un resorte o muelle para mantenerlas separadas.

En un momento dado, se acerca un imán a una de las placas y esto hace que las dos se toquen.

Así se consigue poner en contacto dos conductores. Al separar el imán las dos placas también se separan.

El principio de funcionamiento de un relé electromecánico es el mismo sin embargo, en vez de utilizar un imán utiliza una bobina o inductor. Este componente tiene una particularidad que lo hacen realmente extraordinario y muy útil.

Al hacer pasar una corriente a través de una bobina o inductor se consigue generar un campo electromagnético que hace que se comporte como un imán. Si somos capaces de controlar cuándo circula o no la corriente por la bobina, seremos capaces de controlar cuando se juntan o se separan las placas.

Esto nos da la posibilidad de utilizar un relé con Arduino como si fuera un interruptor. Solo hace falta conectarlo a uno de los pines digitales de Arduino.

Por lo tanto, un relé cuenta con dos etapas.

La etapa de control es la encargada de controlar la corriente que circula por la bobina o el inductor.

Aquí es donde entra en juego Arduino o el ESP8266. Trabaja con corriente continua y el voltaje y amperaje de las salidas digitales suele ser suficiente para controlar el relé con Arduino.

La otra etapa funciona como un interruptor de corrientes y voltajes altos. Es donde conectamos la bombilla, un motor o cualquier dispositivo que tengamos por casa y queramos controlar.

Son las dos placas que, mientras estén separadas, no permitirá circular la corriente y mantendrá el dispositivo apagado pero si las juntas, cerrará el circuito y encenderá lo que tengas conectado al relé.

Debe quedar claro que son dos circuitos separados, uno que es donde se conecta la placa de Arduino o ESP8266 (etapa de control) y el otro circuito que se integra en el dispositivo que se quiere controlar (etapa de interruptor).

Tipos de relés: normalmente abierto y normalmente cerrado

La etapa del relé que funciona como interruptor son dos contactos metálicos que se unen o se separan para dejar pasar o no la corriente.

Dependiendo de su estado en reposo es decir, el estado cuando no se aplica ninguna corriente a la bobina, existen dos tipos de relés:

Normalmente cerrado o NC (del inglés Normally Closed)
Normalmente abierto o NO (del inglés Normally Open)

Relé normalmente abierto

Un relé normalmente abierto (NO) es como un circuito abierto, no deja pasar la corriente, cuando no se aplica una corriente a la bobina, en estado de reposo.

Al aplicar la corriente a la bobina el circuito se cierra y permite que fluya la corriente entre los contactos.

Relé normalmente cerrado

Un relé normalmente cerrado (NC) funciona al contrario, en estado de reposo el circuito está cerrado.

Al aplicar una corriente a la bobina abre el circuito e interrumpe el paso de la corriente entre los contactos.

En realidad, los relés que se utilizan con Arduino son módulos que pueden funcionar de las dos formas: normalmente abierto y normalmente cerrado.

Elegir un tipo u otro es cuestión de conectar los cables de forma correcta. Más adelante veremos un ejemplo de todo esto.

Características técnicas de un relé

Lo primero que hay que hacer antes de utilizar un relé es aprender a identificarlos gracias a sus características técnicas.

Las características técnicas de un relé se obtienen de la hoja de características técnicas o en el propio encapsulado.

Los parámetros más importantes en los que te tienes que fijar son:

Voltaje de activación

Este parámetro hace referencia a la etapa de control, a la parte donde el relé se conecta con Arduino. Indica el voltaje necesario para que la bobina sea capaz de generar el campo electromagnético y juntar o separar los contactos.

Este voltaje se conoce como voltaje de activación o de control.

Se trata de un parámetro muy importante a la hora de seleccionar un relé u otro y puede ser tan alto como 48V o tan bajo como 3V, como ocurre en la serie de relés SRD.

A parte de la hoja de características técnicas, es posible determinar el voltaje de control de un relé mirando el encapsulado. En la siguiente imagen puedes ver varios relés con diferentes voltajes de control..

Corriente y voltaje máximo de un relé

Los contactos del interruptor, los que se unen o se separan según la acción de la bobina, determinan la corriente máxima que puede circular a través del relé.

Hay relés que pueden controlar corrientes enormes del orden de cientos de amperios, los utilizados en el sector industrial.

Por otro lado hay otros relés menos potentes, como los que utilizaremos más adelante con Arduino que solo pueden manejar corrientes del orden de 10 o 20 amperios.

Y lo mismo sucede con el voltaje. Hay relés que trabajan con voltajes de hasta 120V y otros hasta 220V.

Estos parámetros se conocen como la corriente y el voltaje máximo que puede soportar un relé.

Sea como sea, te recomiendo que siempre que vayas a trabajar con un relé te asegures del voltaje y la corriente que soporta el relé en cuestión mirando la hoja de características técnicas.

La anterior imagen muestra una tabla perteneciente a la familia de relés G6H donde puedes ver la corriente y el voltaje máximo que soportan este tipo de relés.

Soporta una corriente de hasta 1A y un voltaje de hasta 125V en corriente alterna (VAC) y un voltaje de hasta 120V en corriente continua (VDC)..

Si en tu país la red eléctrica utiliza 220 voltios como en el caso de España, no podrás utilizar este tipo de relés con estas características técnicas.

Al igual que ocurre con el voltaje de control también es posible identificar los voltajes y corrientes soportados por el relé mirando el encapsulado.

Los valores que se indican como VAC se refieren a voltaje alterno, mientras que VDC es voltaje directo.

Módulos relé con Arduino y ESP8266

Hay diferentes formas de utilizar un relé con Arduino. La opción más económica y básica consiste en comprar un relé y montar el circuito tú mismo.

El problema con esta variante es que se necesitan otros componentes: resistencias, transistor, diodo, etc… Si no tienes experiencia montando circuitos es un poco complicado.

En este caso, otra opción más fácil es comprar un módulo donde venga toda la electrónica necesaria, listo para conectar el relé con Arduino y empezar a programar.

Esta es la opción más interesante si quieres empezar rápido y seguro.

Los módulos utilizan un transistor bipolar como conmutador para controlar el relé en otras palabras, mediante el transistor se controla cuándo se aplica o no el voltaje en la bobina.

En la siguiente imagen puedes ver el esquema típico de un módulo de un relé.

Cuando a la entrada del transistor (marcada como IN en el esquema) se aplica un estado alto (HIGH), este se comporta como un circuito cerrado. De esta forma la bobina tendrá una tensión igual al voltaje de activación (VCC), es decir que el pin 2 del relé está conectado a tierra provocando que el interruptor conmute.

Si por el contrario se le aplica un estado bajo (LOW), este se comporta como un circuito abierto. Al estar abierto no existe voltaje en la bobina y por lo tanto el interruptor del relé regresa a la posición de reposo.

En paralelo con la bobina se ha conectado el LED (D1) con una resistencia de limitación de corriente. Este LED se ilumina cuando el transistor es activado con un estado alto (HIGH).

El diodo (D2) por su parte actúa como medio de protección para el transistor. Sin el diodo de protección los efectos inductivos de la bobina podrían dañar el transistor dejando el módulo inservible.

En los módulos de más de un relé simplemente se repite el mismo esquema varias veces.

Dentro de los diferentes módulos relé hay varios tipos compatibles con Arduino y ESP8266. Los más populares son:

Módulo relé simple

Como su nombre lo indica es el módulo relé más simple que puedes encontrar para Arduino y ESP8266.

Los partes principales son:

Relé: es donde está el interruptor y la parte de control.
Pines de conexión: sirven para conectar el relé con Arduino o con otro microcontrolador como el ESP8266. Al final no son más que pines y cables que facilitan la conexión con la placa. Es la etapa de control.
Bornes: se utilizan para conectar el dispositivo que se quiere controlar con el relé. Es la parte que va a la red eléctrica de casa por ejemplo y pertenece a la etapa de interruptor.
Diodo, resistencias y transistor: facilitan el uso del relé con Arduino y ESP8266. Pertenece a la etapa de control.
LED verde (activación): se enciende cuando el relé está activo es decir, la bobina está alimentada.
LED rojo (alimentación): se enciende cuando el relé está alimentado.

COMPRAR

Módulo relé doble

Como su nombre indica, este módulo tiene dos relés. Al final es como si tuvieras dos módulos relés simples en la misma placa. El funcionamiento es igual.

Las partes son las mismas que en el módulo relé simple pero multiplicado por dos.

Es un módulo muy compacto y viene muy bien si estás trabajando con placas pequeñas como Arduino Nano o NodeMCU.

Cada relé se controla individualmente, si lo conectas a la misma placa necesitarás dos pines digitales.

COMPRAR

Módulo de 8 relés

Si no tienes claro cuántos equipos vas a controlar y el espacio no es un problema, siempre puedes ir a lo bestia y comprar un módulo de 8 relés.

Es similar, en cuanto a funcionamiento, al de dos relés. El inconveniente que presenta es su mayor tamaño por lo que no es válido para aplicaciones compactas.

COMPRAR

Shield Arduino de 4 relés

Este módulo cuenta con 4 relés y es compatible con Arduino UNO, Arduino MEGA o con cualquier otra placa que tenga la distribución de pines compatible con estas dos placas.

Es una de las opciones más interesantes para trabajar con relés en el caso de tener que controlar hasta cuatro dispositivos ya que el shield de Arduino se acopla perfectamente a la placa.

COMPRAR

Cómo conectar un relé con Arduino o ESP8266

Hemos visto que un relé consta de dos etapas: interruptor y control. En esta parte voy a hablar de cómo conectar la parte de control del relé con Arduino.

Esta etapa es la encargada de controlar la corriente y el voltaje que se aplica a la bobina o inductor para cerrar o abrir el circuito del interruptor.

Es algo muy sencillo, al final es como conectar un LED a un pin digital de Arduino o ESP8266 y controlarlo con la programación.

Bueno, lo que realmente hacemos es controlar el transistor que llevan integrados los módulos relés.

Pero antes de conectar el módulo relé con Arduino es necesario conocer cuál es el voltaje de control que requiere el relé. El que se necesita para alimentar la bobina.

Este parámetro se puede obtener de la hoja de características técnicas o en el encapsulado del relé.

Para el uso con Arduino y el ESP8266 se necesita un relé que funcione con 5V.

En la etapa de control, donde se conecta el relé con Arduino o ESP8266, hay 3 pines:

VCC: por donde conectamos el voltaje de control. En este caso son 5V y se obtendrán de la placa de Arduino o ESP8266.
GND: toma de tierra.
IN: aquí conectamos el pin digital y permite controlar el transistor para alimentar o no la bobina del relé.

Los siguientes esquemas muestran un ejemplo típico de conexión con un Arduino y con un ESP8266.

¿Qué pasa si conecto el pin VCC al pin de 3V3?

En principio no pasaría nada. Es posible que algunos relés de 5V se activen con 3,3V, pero esto no quiere decir que todos funcionen así. Eso dependerá de la bobina y de la estructura interna de los contactos.

Además, es posible que con el tiempo el relé deje de funcionar con un voltaje tan bajo debido a su propio envejecimiento.

Si en vez de quedarnos cortos superamos ese voltaje, por ejemplo con 9V, también funcionará, pero la vida útil del relé se reducirá drásticamente. Esto se debe a que un voltaje superior al recomendado acaba dañando la bobina y dejando el relé inservible.

Otro aspecto importante a tener en cuenta es la señal de control. Esta es la señal que se le aplica al pin IN del módulo relé mediante un pin digital de la placa Arduino o ESP.

Existen placas que operan a distintos niveles lógicos:

Las placas basadas en ESP8266 funcionan 3,3 voltios. Un ejemplo es NodeMCU.
Otras como la Arduino UNO, Arduino MEGA o Nano funcionan a 5 voltios

Sin embargo, esto no debe preocuparte ya que el circuito presente en los módulos relés admite que se utilicen ambos niveles lógicos sin problemas. Es decir que los módulos de relé funcionan tanto con un Arduino UNO como con un NodeMCU.

Esto se debe a que se emplea un transistor de alta ganancia y una resistencia de base pequeña. Esto permite que el transistor se pueda activar con una señal de bajo voltaje, incluso algunos módulos pueden ser activados con voltajes tan bajos como 2,7 voltios.

Aclarado esto veamos el código necesario para utilizar el relé.

Código de control de un relé con Arduino o ESP8266

Controlar el relé es muy fácil, de hecho es tan simple como encender un LED. Para que compruebes esto por ti mismo te propongo utilizar el ejemplo blink del IDE de Arduino.

Haz las siguientes modificaciones y súbelo a la placa de Arduino o ESP8266.


//byte rele = D1; // Si utilizas un ESP8266 NodeMCU Wemos D1 mini
byte rele = 2; // Si utilizas un Arduino UNO Arduino MEGA

// the setup routine runs once when you press reset:
void setup() {
  // initialize el pin del rele como salida
  pinMode(rele, OUTPUT);
}

// the loop routine runs over and over again forever:
void loop() {
  digitalWrite(rele, HIGH);   // activar el rele'
  delay(1000);               // esperar un segundo
  digitalWrite(rele, LOW);    // apagar el rele'
  delay(1000);               // esperar un segundo
}

//byte rele = D1; // Si utilizas un ESP8266 NodeMCU Wemos D1 mini

byte rele = 2; // Si utilizas un Arduino UNO Arduino MEGA

// the setup routine runs once when you press reset:

void setup() {

// initialize el pin del rele como salida

pinMode(rele, OUTPUT);

}

// the loop routine runs over and over again forever:

void loop() {

digitalWrite(rele, HIGH); // activar el rele'

delay(1000); // esperar un segundo

digitalWrite(rele, LOW); // apagar el rele'

delay(1000); // esperar un segundo

}

* Este código es compatible con Arduino y ESP8266

En el caso de que utilices otro pin diferente cambia el valor de la variable rele y pon el pin correspondiente.

Si todo funciona correctamente, el LED verde empezará a parpadear y sentirás el sonido típico del relé (tac) activándose y apagándose. Ese es el interruptor mecánico.

Para activar el relé simplemente es necesario poner el pin digital en estado alto (HIGH). Para desactivarlo es necesario ponerlo en estado bajo (LOW).

Dependiendo de si el relé es normalmente abierto o normalmente cerrado, al poner un estado HIGH el circuito se abrirá o se cerrará.

Cómo conectar un relé con Arduino o ESP8266 a la red eléctrica

Hasta aquí lo que hemos visto es la etapa de control, la parte donde se conecta el relé con Arduino o ESP8266. Ahora viene la etapa del interruptor.

El objetivo es conectar una bombilla, un motor, un ventilador o cualquier otra cosa al relé. Esto se hace a través de los bornes que tiene el relé.

Para cada relé vas a encontrar 3 bornes o conectores. Si es el módulo de 2 relés, de 4 o de 8, tendrás tres bornes para cada relé.

Normalmente están marcados como:

NC: normalmente cerrado
C: común
NO: normalmente abierto

Como ya he comentado el módulo relé con Arduino puede funcionar de dos formas: normalmente cerrado y normalmente abierto. Dependiendo de donde conectes los cables funcionará de un modo u otro.

Antes de seguir es necesario que comprendas que trabajar con la red eléctrica es peligroso. Estamos acostumbrados a trabajar con voltajes bajos 3,3V o 5V. Voltajes típicos en Arduino y ESP8266. Ahora estamos hablando de 220V o 120V dependiendo del país donde vivas. Es importante que comprendas que un voltaje tan elevado puede darte algo más que un susto o un calambre. PUEDE LLEGAR A MATARTE. Por eso es necesario que extremes las medidas de seguridad antes de ponerte a trabajar con esta parte.

En el caso de que en tu relé no vengan marcados los bornes como NC, C y NO, hay un método para identificar cada uno de ellos.

Lo normal es que el borne del centro sea el común (C).

Para identificar el borne NC y NO hay que utilizar un multímetro en modo continuidad. Selecciona esta opción en tu multímetro.

Conecta una de las puntas a uno de los bornes de los lados y la otra punta al borne del centro, el común (C).

Si el multímetro reproduce un sonido con el zumbador o buzzer es que ese es el borne de normalmente cerrado (NC).

Ahora haz lo mismo pero con el otro borne, el que está al otro lado.

Si no pita el multímetro es que ese es el borne de normalmente abierto (NO).

Una vez localizados los bornes, hay que preparar el cable que conectará el relé con Arduino o ESP8266 y la red eléctrica de tu casa.

Cable conexión relé con Arduino y red eléctrica

Lo mismo se te ha pasado por la cabeza abrir un enchufe de tu casa y conectar directamente el relé a la red eléctrica de tu casa. Aunque puede ser una solución, es totalmente desaconsejable.

Una opción para controlar una lámpara o cualquier otro dispositivo con un relé con Arduino o ESP8266 es utilizar un cable alargador, de esos que tienes por casa. Puedes comprar uno por muy poco.

Un extremo del cable irá conectado a un enchufe y el otro extremo al dispositivo que quieras controlar.

La idea es en el centro (o por donde quieras) cortar la funda del cable y dejar al descubierto los tres cables que suelen llevar por dentro este tipo de alargadores.

Los puedes distinguir por sus colores aunque dependerá del país o región donde vivas. En españa se sigue el estándar europeo:

Fase: negro, marrón o gris
Neutro: azul
Tierra: verde y amarillo

A continuación te dejo una tabla con los estándar de colores de diferentes países.

País/región	Fase	Neutro	Tierra
Argentina	Negro, marrón o gris	Azul	Verde y amarillo
Europa	Negro, marrón o gris	Azul	Verde y amarillo
Chile	Rojo, azul o negro	Blanco o marrón	Verde o verde amarillo
China	Negro, marrón o gris	Azul	Verde y amarillo
Panamá	Rojo o negro	Blanco	Verde

El cable de fase es el cable peligroso ya que es por donde entra la corriente al dispositivo. En él está presente un voltaje de 220V (110V en algunos países) con respecto al neutro.

El cable de neutro es el que cierra el circuito y hace circular la corriente para que los equipos funcionen. En cierto modo funciona como el terminal negativo de la red. Digo en cierto modo ya que en una red de corriente alterna no existe un terminal negativo como tal. Este cable no presenta ninguna corriente mientras el circuito está abierto.

El cable de tierra es utilizado solo como medida de protección para casos de descargas eléctricas debidas a algún mal funcionamiento en los equipos. Eso significa que por él no circula corriente alguna, por lo tanto no es peligroso.

El proceso para preparar el cable es el siguiente.

Lo primero es pelar el cable alargador, corta solo la funda y lleva cuidado de no cortar ningún cable.

Cuando tengas al descubierto los tres cables, cortas el marrón, la fase. Este será el que vaya conectado al relé con Arduino.

Para conectar el cable alargador al relé con Arduino, el extremo que va conectado al enchufe de tu instalación eléctrica se conecta al pin de COM y el otro extremo, donde se conecta el dispositivo para controlar, va conectado al normalmente abierto (NO) o al normalmente cerrado (NC).

Esto es suficiente para que el relé con Arduino ya estaría integrado a la red eléctrica de tu casa. Ahora sólo haría falta conectar un extremo a un enchufe y en el otro extremo podemos conectar una lámpara por ejemplo.

Sin embargo, hay que tener ciertas precauciones a la hora de hacer la conexión para que todo coincida.

Precauciones conexión relé con Arduino y red eléctrica

Hasta ahora hemos tenido mucho cuidado para que el cable de la fase entre por el pin COM y salga por el pin NO o NC. Elegir uno u otro pin dependerá de si quieres que funcione como normalmente abierto (NO) o normalmente cerrado (NC).

Sin embargo, esto no tiene mucho sentido si al enchufar el cable alargador al enchufe de tu casa no haces coincidir la fase de la red eléctrica con la fase del cable alargador.

El conector macho tiene dos conectores o bornes que corresponden con la fase y el neutro.

Para saber cuál es cual, al estar cortado el cable de fase (cable marrón) para conectarlo al relé con Arduino, puedes utilizar la continuidad del multímetro para saber cuál de los dos bornes o conectores corresponde a la fase.

Con un cable del multímetro tocas un borne y con el otro tocas el cable cortado el pin común (C) del relé, el del medio. Si pita es que ese es el borne de fase.

El otro borne será el común. La tierra no tiene ningún borne visible.

Una vez identificado hay que hacer coincidir con la fase y el neutro del enchufe.

Y, ¿cómo sé cuál es la fase y el neutro de un enchufe? Esto se puede saber utilizando un buscapolos o un multímetro.

Mucho ojo porque vamos a medir un alto voltaje y puede ser muy peligroso.

Con un buscapolos solo tienes que introducirlo en cada agujero y el que se ilumine es que es la fase. El otro será el neutro.

Con un multímetro tienes que medir el voltaje. Asegúrate que tu multímetro puede medir corriente alterna y el voltaje de tu país. En España son 220V-230V.

Introducir el cable rojo en el agujero y el cable negro en la pestaña que hay justo debajo del enchufe.

Si al medir obtienes un voltaje de unos 230V (España) esa es la fase. En el otro agujero tendrás unos pocos voltios pero no llegará al voltaje de la red eléctrica. Es el neutro.

Todo esto se hace para que el dispositivo que se quiere controlar a través de un relé con Arduino, no esté energizado cuando el relé esté abierto es decir, cuando no deje pasar la corriente.

Si conectas el neutro en vez de la fase, el dispositivo está energizado es decir, llega la energía hasta él y esto puede ser peligroso ya que cualquier corto activaría el dispositivo.

Aunque conectes las fase al dispositivo y el neutro al dispositivo, el relé con Arduino seguirá funcionando igual y actuará como un interruptor.

Lámpara inteligente utilizando un relé con Arduino

¿Alguna vez has pensado en dotar de cierta inteligencia a tus objetos de uso cotidiano?

A continuación te propongo hacer un simple proyecto que te permitirá que tu lámpara de escritorio se encienda sola cuando te acerques para trabajar con tus proyectos.

Este proyecto está basado en un relé con Arduino.

El material que vas a necesitar es el siguiente

Arduino UNO *
Módulo relé simple
Sensor de ultrasonidos
Cable alargador **
Lámpara de mesa

* Un Arduino Nano, Arduino Mega o cualquier otro también te vale, incluso una placa ESP8266.

** Si no quieres utilizar un cable alargador tendrás que cortar el cable de la lámpara.

El sensor de ultrasonidos se utiliza como detector de presencia. Gracias a este sensor se puede medir la distancia con Arduino y así ser capaz de detectar si hay alguien o algo delante del sensor.

Ojo, el sensor de ultrasonidos tiene que estar apuntando hacia el lugar donde sueles sentarte. De lo contrario no funcionará.

Puedes utilizar otro sensor para la detección de presencia como un PIR o un sensor láser.

En la siguiente imagen puedes ver el circuito que debes montar.

El relé se conecta al pin digital 2 de Arduino y la lámpara se conecta a los pines COM y NO como hemos visto anteriormente.

Con esta configuración, cuando en el pin 2 haya un estado LOW el relé estará abierto (normalmente abierto) y la lámpara estará apagada. Cuando cambies a un estado HIGH se cerrará el interruptor del relé y encenderá la lámpara.

Los pines Trigger y Echo del sensor de ultrasonidos se conectan a los pines 5 y 6 del Arduino respectivamente.

Es un circuito muy sencillo que no sirve de nada si no lo programamos. Para dotar a la lámpara de inteligencia utilizando el relé con Arduino, he utilizado el siguiente algoritmo:

Obtener distancia con el sensor de ultrasonidos
¿La distancia es menor de 35 cm?
1. Si
  1. Encender lámpara.
  2. Establecer tiempo de apagado
2. No
  1. No hacer nada.
¿Es tiempo de apagar la lámpara?
1. Si
  1. Apagar lámpara
2. No
  1. No hacer nada

Comenzamos el código declarando las constantes y variables.


#define RELE_PIN      2
#define TRIGGER_PIN   5
#define ECHO_PIN      6

#define SOUND_SPEED   34300.0 // velocidad del sonido en cm/s
#define TIME_TO_WHAIT 3000  // en milisegundos

unsigned long time_for_off; // valor de millis en el que se debe apagar la lampara
float distance;

#define RELE_PIN 2

#define TRIGGER_PIN 5

#define ECHO_PIN 6

#define SOUND_SPEED 34300.0 // velocidad del sonido en cm/s

#define TIME_TO_WHAIT 3000 // en milisegundos

unsigned long time_for_off; // valor de millis en el que se debe apagar la lampara

float distance;

Las tres primeras variables constantes, RELE_PIN, TRIGGER_PIN y ECHO_PIN almacenan los pines donde se conecta el sensor de ultrasonidos y el relé.

También se ha declarado las constantes:

SOUND_SPEED: que es igual a la velocidad del sonido expresada en cm/s. Esta se utiliza en el cálculo de la distancia con el sensor ultrasónico.
TIME_TO_WHAIT: que expresa el tiempo en milisegundos que se mantendrá la lámpara encendida después de detectar presencia.

La variable time_for_off se utiliza para indicar en que momento se debe apagar la lámpara.

Por otra parte, la variable distance es utilizada para almacenar la distancia obtenida con el sensor ultrasónico.

En la función setup() se configuran los pines digitales correspondientes al relé y a los pines trigger y echo del sensor.

void setup() {
  // Configurar pines
  pinMode( RELE_PIN, OUTPUT );
  pinMode( TRIGGER_PIN, OUTPUT );
  pinMode( ECHO_PIN, INPUT );

  digitalWrite(RELE_PIN, LOW); // apagar lampara

  digitalWrite(TRIGGER_PIN, LOW);
  
}

void setup() {

// Configurar pines

pinMode( RELE_PIN, OUTPUT );

pinMode( TRIGGER_PIN, OUTPUT );

pinMode( ECHO_PIN, INPUT );

digitalWrite(RELE_PIN, LOW); // apagar lampara

digitalWrite(TRIGGER_PIN, LOW);

}

En la función loop() se ejecuta el algoritmo anteriormente planteado.

void loop() {
  // put your main code here, to run repeatedly:

  distance = obtenerDistancia();

  if( distance < 35 ){
    digitalWrite(RELE_PIN, HIGH);
    time_for_off = millis() + TIME_TO_WHAIT;
  }
  
  if( time_for_off <= millis() )
    digitalWrite(RELE_PIN, LOW);
}

void loop() {

// put your main code here, to run repeatedly:

distance = obtenerDistancia();

if( distance < 35 ){

digitalWrite(RELE_PIN, HIGH);

time_for_off = millis() + TIME_TO_WHAIT;

}

if( time_for_off <= millis() )

digitalWrite(RELE_PIN, LOW);

}

Inicialmente se obtiene la distancia en centímetros y se almacena en la variable distance.

Luego se comprueba que la distancia sea menor de 35 cm. En caso afirmativo, se enciende la lámpara y se actualiza el valor de time_for_off con el valor de la función millis() más el tiempo que se desea mantener encendida la lámpara.

Finalmente se comprueba si el valor de time_for_off es menor que el valor actual de millis(). Si es así la lámpara es apagada.

Por último te comento la función obtenerDistancia().

float obtenerDistancia(){

  // Poner Triger en estado bajo y esperar 2 ms
  digitalWrite(TRIGGER_PIN, LOW);
  delayMicroseconds(2);

  // Poner Trigger en alto y esperamos 10 ms
  digitalWrite(TRIGGER_PIN, HIGH);
  delayMicroseconds(10);

  // Comienza poniendo el pin Trigger en estado bajo nuevamente
  digitalWrite(TRIGGER_PIN, LOW);
  
  // tiempo de ida y vuelta de la sennal.
  unsigned long travel_time = pulseIn(ECHO_PIN, HIGH);

  float distancia = travel_time * 0.000001 * SOUND_SPEED / 2.0;

  return distancia;  
}

float obtenerDistancia(){

// Poner Triger en estado bajo y esperar 2 ms

digitalWrite(TRIGGER_PIN, LOW);

delayMicroseconds(2);

// Poner Trigger en alto y esperamos 10 ms

digitalWrite(TRIGGER_PIN, HIGH);

delayMicroseconds(10);

// Comienza poniendo el pin Trigger en estado bajo nuevamente

digitalWrite(TRIGGER_PIN, LOW);

// tiempo de ida y vuelta de la sennal.

unsigned long travel_time = pulseIn(ECHO_PIN, HIGH);

float distancia = travel_time * 0.000001 * SOUND_SPEED / 2.0;

return distancia;

}

Esta función provoca un pulso en alto de 10 us en el pin trigger. Este pulso pone en funcionamiento el sensor de ultrasonidos.

Seguidamente se utiliza la función pulseIn() para obtener el tiempo que tarda la onda de sonido en ir al objeto (tú serías el objeto en este caso) y regresar al sensor.

Finalmente, se obtiene la distancia multiplicando el tiempo por la velocidad del sonido. Como la función pulseIn() devuelve el tiempo en microsegundos es necesario multiplicar el valor por 0,000001.

También es necesario dividir entre 2.0, ya que el tiempo obtenido es el tiempo que tarda en ir y volver.

Aquí tienes el código completo para que hagas con él lo que quieras.


#define RELE_PIN      2
#define TRIGGER_PIN   5
#define ECHO_PIN      6

#define SOUND_SPEED   34300.0 // velocidad del sonido en cm/s
#define TIME_TO_WHAIT 3000  // en milisegundos

unsigned long time_for_off; // valor de millis en el que se debe apagar la lampara
float distance;

void setup() {
  // Configurar pines
  pinMode( RELE_PIN, OUTPUT );
  pinMode( TRIGGER_PIN, OUTPUT );
  pinMode( ECHO_PIN, INPUT );

  digitalWrite(RELE_PIN, LOW); // apagar lampara

  digitalWrite(TRIGGER_PIN, LOW);
  
}

void loop() {
  // put your main code here, to run repeatedly:

  distance = obtenerDistancia();

  if( distance < 35 ){
    digitalWrite(RELE_PIN, HIGH);
    time_for_off = millis() + TIME_TO_WHAIT;
  }
  
  if( time_for_off <= millis() )
    digitalWrite(RELE_PIN, LOW);
}


float obtenerDistancia(){

  // Poner Triger en estado bajo y esperar 2 ms
  digitalWrite(TRIGGER_PIN, LOW);
  delayMicroseconds(2);

  // Poner Trigger en alto y esperamos 10 ms
  digitalWrite(TRIGGER_PIN, HIGH);
  delayMicroseconds(10);

  // Comienza poniendo el pin Trigger en estado bajo nuevamente
  digitalWrite(TRIGGER_PIN, LOW);
  
  // tiempo de ida y vuelta de la sennal.
  unsigned long travel_time = pulseIn(ECHO_PIN, HIGH);

  float distancia = travel_time * 0.000001 * SOUND_SPEED / 2.0;

  return distancia;  
}

#define RELE_PIN 2

#define TRIGGER_PIN 5

#define ECHO_PIN 6

#define SOUND_SPEED 34300.0 // velocidad del sonido en cm/s

#define TIME_TO_WHAIT 3000 // en milisegundos

unsigned long time_for_off; // valor de millis en el que se debe apagar la lampara

float distance;

void setup() {

// Configurar pines

pinMode( RELE_PIN, OUTPUT );

pinMode( TRIGGER_PIN, OUTPUT );

pinMode( ECHO_PIN, INPUT );

digitalWrite(RELE_PIN, LOW); // apagar lampara

digitalWrite(TRIGGER_PIN, LOW);

}

void loop() {

// put your main code here, to run repeatedly:

distance = obtenerDistancia();

if( distance < 35 ){

digitalWrite(RELE_PIN, HIGH);

time_for_off = millis() + TIME_TO_WHAIT;

}

if( time_for_off <= millis() )

digitalWrite(RELE_PIN, LOW);

}

float obtenerDistancia(){

// Poner Triger en estado bajo y esperar 2 ms

digitalWrite(TRIGGER_PIN, LOW);

delayMicroseconds(2);

// Poner Trigger en alto y esperamos 10 ms

digitalWrite(TRIGGER_PIN, HIGH);

delayMicroseconds(10);

// Comienza poniendo el pin Trigger en estado bajo nuevamente

digitalWrite(TRIGGER_PIN, LOW);

// tiempo de ida y vuelta de la sennal.

unsigned long travel_time = pulseIn(ECHO_PIN, HIGH);

float distancia = travel_time * 0.000001 * SOUND_SPEED / 2.0;

return distancia;

}

Ejercicios propuestos de relé con Arduino

Por último, este proyecto admite varias mejoras. Te dejo unos ejercicios propuestos para que intentes mejorar el proyecto:

Añade una LDR. Si la LDR supera un umbral, que no encienda la lámpara porque hay mucha luz.
Haz que la lámpara se apague cuando te levantes. Controla si hay algo delante del sensor y cuando no esté, que apague la luz. Utiliza la media o mediana para calcular la distancia.

Conclusiones lámpara inteligente utilizando un relé con Arduino

A lo largo de este tutorial hemos visto cómo utilizar un relé con Arduino para poder dotar a una lámpara de inteligencia. Entiéndase por inteligencia que sea capaz de encenderse o apagarse de forma automática.

Lo más importante a la hora de utilizar un relé con Arduino es trabajar con seguridad.

Siempre debes extremar las precauciones ya que trabajar con la red eléctrica puede ser mortal.

Un relé con Arduino puede funcionar normalmente abierto o normalmente cerrado.
Hay varios módulos que sirven para trabajar con un relé con Arduino. Simples, dobles, de 8 o shield.
Identifica correctamente la fase y el neutro de tu red eléctrica.
Cuando utilices un relé con Arduino conecta siempre la fase al común (C) y el dispositivo al NC o NO.
Ten la máxima precaución al trabajar con un relé con Arduino.

Cualquier duda o sugerencia en los comentarios de aquí abajo.

Gracias a Shutterstock por ceder los derechos de las imágenes.