Instrucciones para módulo de relé con Arduino.

¿Alguna vez has querido controlar dispositivos eléctricos con tu Arduino? ¡Ahora es posible con un módulo de relé! En este artículo te presentamos instrucciones detalladas para conectar y utilizar un módulo de relé con tu Arduino. ¡Sigue leyendo para aprender cómo puedes automatizar tus proyectos y hacer que tu Arduino sea aún más versátil!

Este artículo muestra cómo utilizar Arduino para controlar el voltaje de la red mediante un módulo de relé. Damos una breve introducción al módulo de relé y creamos un ejemplo de proyecto simple usando Arduino. El ejemplo que creamos muestra cómo controlar un módulo de relé usando un Arduino y un sensor de movimiento PIR.

Al final de este tutorial, debería poder utilizar su Arduino para controlar cualquier dispositivo electrónico a través de un módulo de relé.

Presentación del módulo de relé

Un relé es un interruptor operado eléctricamente que se puede encender o apagar, pasar corriente o no, y se puede controlar con voltajes bajos, como los 5 V que proporcionan los pines Arduino.

Como veremos más adelante, controlar un módulo de relé con Arduino es tan fácil como controlar cualquier otra salida.

Este módulo de relé tiene dos canales (esos cubos azules). Existen otros modelos de uno, cuatro y ocho canales. Este módulo debe funcionar con 5 V, lo que es adecuado para usar con un Arduino. Hay otros módulos de relé que funcionan a 3,3 V, lo que es ideal para ESP32, ESP8266 y otros microcontroladores.

Obtenga un módulo de relé:

• Módulo de relé de 2 canales de 5 V
• Módulo de relé de 1 canal de 5 V
• Módulo de relé de 5 V y 8 canales.
• Módulo de relé de 1 canal de 3,3 V.

Distribución de pines del relé

La siguiente figura muestra la asignación de pines del módulo de relé.

Los seis pines del lado izquierdo del módulo de relé conectan alto voltaje y los pines de la derecha conectan el componente que requiere bajo voltaje: los pines Arduino.

Conexiones de tensión de red

El lado de alta tensión tiene dos conectores, cada uno con tres tomas: común (COM), normalmente cerrado (NC) y normalmente abierto (NO).

• COM: pin compartido
• NC (normalmente cerrado): La configuración normalmente cerrada se utiliza cuando se desea que el relé esté cerrado de forma predeterminada. Esto significa que la corriente fluirá hasta que envíes una señal desde el Arduino al módulo de relé para abrir el circuito y detener la corriente.
• NO (Normalmente abierto): La configuración normalmente abierta funciona a la inversa: el relé siempre está abierto, por lo que el circuito está abierto hasta que envías una señal desde el Arduino para cerrar el circuito.

Si solo desea encender una lámpara ocasionalmente, es mejor utilizar una configuración de circuito normalmente abierto.

Configuración de pines

El lado de bajo voltaje tiene un juego de cuatro pines y un juego de tres pines.

El conjunto de la derecha consta de VCC Y Dimensiones para encender el módulo e ingrese 1 (EN 1) y entrada 2 (EN 2) para controlar el relé inferior o superior.

El segundo conjunto de pines consta de Dimensiones, VCCY JD-VCC Patas. El pin JD-VCC suministra energía al solenoide del relé.

Nota: tenga en cuenta que el módulo tiene una tapa de puente que conecta los pines VCC y JD-VCC; El que se muestra aquí es azul, pero el tuyo puede ser de un color diferente. La tapa del puente te permite elegir si el circuito está conectado físicamente al circuito Arduino o no, y puedes elegir si quieres que la tapa esté encendida o no. Con la tapa del puente puesta, los pines VCC y JD-VCC están conectados. Esto significa que el solenoide del relé se alimenta directamente desde el pin de alimentación del Arduino, por lo que el módulo de relé y los circuitos del Arduino no están físicamente aislados entre sí (esta es la configuración que usaremos). Sin la tapa del puente, debe proporcionar una fuente de alimentación independiente para alimentar el solenoide del relé a través del pin JD-VCC. Esta configuración aísla físicamente los relés del Arduino utilizando el optoacoplador incorporado del módulo.

Las conexiones entre el módulo de relé y el Arduino son muy sencillas:

• Dimensiones: cae al piso
• EN 1: controla el primer relé (está conectado a un pin digital Arduino)
• EN 2: controla el segundo relé (debe estar conectado a un pin digital Arduino si usas este segundo relé. De lo contrario, no es necesario conectarlo)
• VCC: va a 5V

Ejemplo: Controlar una lámpara con un módulo de relé y un sensor de movimiento PIR

En este ejemplo crearemos una lámpara sensible al movimiento. Cada vez que se detecta movimiento, la lámpara se enciende durante 10 segundos.

La detección de movimiento se realiza mediante un Sensor de movimiento PIRSi no estás familiarizado con el sensor de movimiento PIR, puedes leer el siguiente post:

• Arduino con sensor de movimiento PIR

Usamos uno para controlar la lámpara con voltaje de red. módulo de relé en configuración normalmente abierta.

Advertencia de seguridad

Antes de continuar con este proyecto, quiero señalar que estás trabajando con tensión de red. Lea atentamente la advertencia de seguridad a continuación.

Advertencia: Al realizar proyectos que están conectados a la red eléctrica, realmente necesita saber lo que está haciendo o podría electrocutarse. Este es un problema grave y queremos que esté a salvo. Si no estás 100% seguro de lo que estás haciendo, hazte un favor y no toques nada. ¡Pregúntale a alguien que sepa!

Piezas requeridas

Aquí están las piezas necesarias para este ejemplo:

• módulo de relé
• Arduino UNO – leer Los mejores kits de inicio de Arduino
• Sensor de movimiento PIR
• Juego de cables para lámpara (ver en eBay)

Puedes utilizar los enlaces anteriores o ir directamente MakerAdvisor.com/tools ¡Para encontrar todas las piezas para tus proyectos al mejor precio!

código

Copie el siguiente código en su IDE de Arduino y cárguelo en su placa Arduino.

Advertencia: No debes cargar código nuevo mientras tu Arduino esté conectado al relé.

/*********
  Rui Santos
  Complete project details at https://randomnerdtutorials.com  
*********/

// Relay pin is controlled with D8. The active wire is connected to Normally Closed and common
int relay = 8;
volatile byte relayState = LOW;

// PIR Motion Sensor is connected to D2.
int PIRInterrupt = 2;

// Timer Variables
long lastDebounceTime = 0;  
long debounceDelay = 10000;

void setup() {
  // Pin for relay module set as output
  pinMode(relay, OUTPUT);
  digitalWrite(relay, HIGH);
  // PIR motion sensor set as an input
  pinMode(PIRInterrupt, INPUT);
  // Triggers detectMotion function on rising mode to turn the relay on, if the condition is met
  attachInterrupt(digitalPinToInterrupt(PIRInterrupt), detectMotion, RISING);
  // Serial communication for debugging purposes
  Serial.begin(9600);
}

void loop() {
  // If 10 seconds have passed, the relay is turned off
  if((millis() - lastDebounceTime) > debounceDelay && relayState == HIGH){
    digitalWrite(relay, HIGH);
    relayState = LOW;
    Serial.println("OFF");
  }
  delay(50);
}

void detectMotion() {
  Serial.println("Motion");
  if(relayState == LOW){
    digitalWrite(relay, LOW);
  }
  relayState = HIGH;  
  Serial.println("ON");
  lastDebounceTime = millis();
}

Ver código sin formato

Así es como funciona el código

Primero creamos variables para sujetar el pin al que está conectado el pin del relé IN1 y para almacenar el estado del relé:

int relay = 8;
volatile byte relayState = LOW;

El sensor de movimiento PIR está conectado a Pluma 2:

int PIRInterrupt = 2;

Necesitamos crear algunas variables auxiliares para gestionar temporizadores con sensor de movimiento PIR. El último tiempo de rebote La variable almacena la hora de la última detección de movimiento. Retraso de rebote almacena cuánto tiempo debe permanecer encendida la lámpara después de que se detecta movimiento (aquí configuramos 10 segundos = 10000 milisegundos)

long lastDebounceTime = 0;
long debounceDelay = 10000;

En el configuración()Configuramos el relé como SALIDA y lo apagamos por defecto:

pinMode(relay, OUTPUT);
digitalWrite(relay, HIGH);

Dado que utilizamos una configuración normalmente abierta, no hay contacto entre los conectores COM y NO a menos que active el relé. El relé se activa cuando la entrada cae por debajo de aproximadamente 2 V. Es decir, cuando envías una señal BAJA desde el Arduino, el relé se enciende, y cuando envías una señal ALTA, el relé se apaga; Funciona con lógica invertida.

Configure el sensor de movimiento PIR como interrupción:

pinMode(PIRInterrupt, INPUT);
// Triggers detectMotion function on rising mode to turn the relay on, if the condition is met
attachInterrupt(digitalPinToInterrupt(PIRInterrupt), detectMotion, RISING);

Cada vez que se activa el sensor de movimiento PIR, llama al detección de movimiento() Función declarada al final del código para encender el relé:

void detectMotion() {
    Serial.println("Motion");
    if(relayState == LOW){
        digitalWrite(relay, LOW);
    }
    relayState = HIGH;
    Serial.println("ON");
    lastDebounceTime = millis();
}

En el Cinta()Comprobemos si han pasado 10 segundos desde que se encendió el relé. Si se cumple esta condición, podemos apagar el relé.

if((millis() - lastDebounceTime) > debounceDelay && relayState == HIGH){
    digitalWrite(relay, HIGH);
    relayState = LOW;
    Serial.println("OFF");
}

Esquema

Ensamble todas las piezas como se muestra en el diagrama esquemático.

Advertencia: No toque ningún cable que esté bajo tensión de red. También asegúrese de que todos los tornillos del módulo de relé estén apretados.

La lámpara está conectada al relé en una configuración normalmente abierta. El Arduino sobrecontrola el relé. Pluma 8 (Pluma 8 está conectado al pin del relé IN1). Finalmente, el sensor de movimiento PIR se conecta a Pluma 2.

demostración

Después de cargar el código y cablear el circuito, puedes probar tu configuración.

Cuando se detecta movimiento, la lámpara se enciende. Si no hay movimiento durante 10 segundos, la lámpara se apagará.

Envolver

Controlar un módulo de relé con Arduino es tan fácil como controlar una salida: todo lo que necesita hacer es enviar señales ALTAS o BAJAS a través de un pin digital Arduino. Con el módulo de relé puedes controlar casi todos los dispositivos electrónicos de CA (no sólo las lámparas).

Esperamos que esta guía te haya resultado útil. Si te gusta este proyecto, es posible que también te guste nuestro curso premium de Arduino:

• Proyectos Arduino paso a paso: Crea 25 proyectos

Disponemos de más de 60 tutoriales y proyectos gratuitos utilizando Arduino. Si está buscando una guía para un módulo específico, probablemente tengamos lo que busca.

• Más de 60 proyectos y tutoriales de Arduino

Finalmente, también puedes acceder a nuestros recursos GRATUITOS aquí.

Gracias por leer.

15 de enero de 2019

Instrucciones para módulo de relé con Arduino

Este artículo muestra cómo controlar voltaje de red con Arduino utilizando un módulo de relé. Haremos una breve introducción al módulo de relé y construiremos un ejemplo de proyecto simple con Arduino. El ejemplo que construiremos muestra cómo controlar un módulo de relé con Arduino y un sensor de movimiento PIR.

Introducción al Módulo de Relé

Un relé es un interruptor operado eléctricamente que puede encenderse o apagarse, permitiendo que la corriente pase o no pase, y puede ser controlado con voltajes bajos, como los 5V proporcionados por los pines de Arduino.

Controlar un módulo de relé con Arduino es tan sencillo como controlar cualquier otra salida, como veremos más adelante.

Este módulo de relé tiene dos canales (esas cajas azules). Hay otros modelos con uno, cuatro y ocho canales. Este módulo debe ser alimentado con 5V, lo cual es adecuado para usar con Arduino. Hay otros módulos de relé que son alimentados con 3.3V, lo cual es ideal para ESP32, ESP8266 y otros microcontroladores.

Conexiones de voltaje de red

El lado de alto voltaje tiene dos conectores, cada uno con tres tomas: común (COM), normalmente cerrado (NC) y normalmente abierto (NO).

COM: pin común
NC (Normalmente Cerrado): la configuración normalmente cerrada se usa cuando desea que el relé esté cerrado por defecto, lo que significa que la corriente está fluyendo a menos que envíe una señal desde Arduino al módulo de relé para abrir el circuito y detener la corriente.
NO (Normalmente Abierto): la configuración normalmente abierta funciona de la manera opuesta: el relé siempre está abierto, por lo que el circuito está roto a menos que envíe una señal desde Arduino para cerrar el circuito.

Las conexiones entre el módulo de relé y Arduino son muy simples:

GND: va a tierra
IN1: controla el primer relé (debe estar conectado a un pin digital de Arduino)
IN2: controla el segundo relé (debe estar conectado a un pin digital de Arduino si estás usando este segundo relé. De lo contrario, no es necesario conectarlo)
VCC: va a 5V

Preguntas frecuentes

1. ¿Cómo se puede controlar un módulo de relé con Arduino?

Se puede controlar un módulo de relé con Arduino enviando señales HIGH o LOW a través de un pin digital de Arduino.

2. ¿Qué se puede controlar con un módulo de relé?

Con un módulo de relé se pueden controlar casi cualquier electrodoméstico de corriente alterna (no solo lámparas).

3. ¿Para qué se utiliza la configuración normalmente abierto y normalmente cerrado en un módulo de relé?

La configuración normalmente abierto se utiliza cuando se desea que el circuito esté apagado por defecto, y la configuración normalmente cerrado se utiliza cuando se desea que el circuito esté encendido por defecto.

4. ¿Qué precauciones de seguridad se deben tomar al trabajar con un módulo de relé conectado a voltaje de red?

Es importante tener cuidado al trabajar con voltajes de red para evitar accidentes. Si no se está seguro de lo que se está haciendo, es mejor no tocar nada y buscar ayuda de alguien que tenga experiencia.