Módulo Shield de 8 Canales 12V Relé para Arduino ARM PIC AVR DSP SRD-12VDC-SL-C Nuevo

Descripción

🔧 Descripción del Módulo 8 Canales 12V Relé Shield (SRD-12VDC-SL-C)

✅ Características Principales

• Tipo de módulo: Shield de 8 relés
• Número de canales: 8
• Tensión de funcionamiento: 12V DC
• Relés utilizados: SRD-12VDC-SL-C
• Corriente del relé: hasta 10A a 250V AC / 10A a 30V DC
• Interfaz de control: TTL a 5V compatible con microcontroladores (Arduino, PIC, ARM, AVR, DSP)
• Señal activa: generalmente activa LOW (lógica negativa)
• Aislamiento: Aislamiento óptico con optoisoladores para protección contra interferencias
• LED de estado: Un LED para cada canal para indicar el estado del relé (encendido/apagado)
• Tornillos para conectar: para el enlace seguro de cargas externas
• Pines de control: IN1–IN8

---

🔌 Conexiones de Hardware

🛠️ Pines del módulo

• VCC: alimentación 5V para la lógica del relé (conectar al 5V de Arduino)
• GND: masa común
• JD-VCC: alimentación del circuito del relé (12V requeridos)
• IN1-IN8: entradas de control del relé (conectadas a los pines digitales de Arduino)

🔐 Nota importante: para aislar correctamente el módulo de Arduino, puedes eliminar el jumper entre VCC e JD-VCC, y proporcionar 12V por separado en JD-VCC (para los relés) y 5V en VCC (para el optoisolamiento).

---

🖥️ Esquema de Conexión con Arduino UNO

Modulo Relè Arduino UNO
----------- ------------
IN1 → Pin 2
IN2 → Pin 3
IN3 → Pin 4
IN4 → Pin 5
IN5 → Pin 6
IN6 → Pin 7
IN7 → Pin 8
IN8 → Pin 9
GND → GND
VCC → 5V
JD-VCC → +12V (alimentazione esterna per relè)

---

📘 Guía de Programación con Arduino

✅ Código Base para Controlar 8 Relés

// Pin di controllo dei relè
int rele[8] = {2, 3, 4, 5, 6, 7, 8, 9};

void setup() {
 for (int i = 0; i < 8; i++) {
 pinMode(rele[i], OUTPUT);
 digitalWrite(rele[i], HIGH); // Relè disattivi (attivo LOW)
 }
}

void loop() {
 // Accende tutti i relè uno alla volta
 for (int i = 0; i < 8; i++) {
 digitalWrite(rele[i], LOW); // Relè attivo
 delay(500);
 digitalWrite(rele[i], HIGH); // Relè disattivo
 }

 // Aspetta un secondo prima di ricominciare
 delay(1000);
}

---

💡 Ejemplos de Aplicaciones

1. Automatización doméstica: encendido/apagado de luces, ventiladores, bombas.
2. Control de cargas industriales: gestión de válvulas solenoideas o motores.
3. Proyectos IoT: gestión remota de múltiples dispositivos mediante WiFi/Bluetooth.
4. Sistema de riego: encendido de válvulas solenoideas en horarios programados.

---

🔐 Consejos de Seguridad

• No superar los límites de corriente/tensión de los relés.
• Isolar las cargas AC con las protecciones adecuadas (fusibles, varistores, etc.).
• Si controlas cargas de alta tensión (220V AC), actúa con precaución o recibe ayuda de un técnico calificado.

---

🧪 Prueba Rápida de Relés

Para verificar que los relés funcionen correctamente:

1. Conecta los pines INx a GND → el relé correspondiente debería activarse (se escucha el «click»).
2. Usa el código anterior para ejecutar una secuencia.

---

🧰 Alimentación recomendada

• Utiliza una fuente de alimentación externa de 12V 1-2A para JD-VCC.
• Usa el jumper solo si alimentas todo desde Arduino, pero esto no se recomienda si usas más de 2 relés simultáneamente.

---

📦 Contenido del módulo (en venta)

• 1x módulo relé 8 canales 12V (SRD-12VDC-SL-C)
• Terminals de tornillo para cargas
• Pin header para conexión con Arduino

---

🔌 1. Control de Relés a través de Comunicación Serie desde PC

🎯 Objetivo:

Controlar los 8 relés desde un PC a través de la puerta serie de Arduino (mediante comandos como) ON1, OFF2, ALLON, ALLOFF).

📟 Código Arduino (Serial)

int rele[8] = {2, 3, 4, 5, 6, 7, 8, 9};
String inputString = "";

void setup() {
 Serial.begin(9600);
 for (int i = 0; i < 8; i++) {
 pinMode(rele[i], OUTPUT);
 digitalWrite(rele[i], HIGH);
 }
 Serial.println("Sistema pronto. Comandi: ONx / OFFx / ALLON / ALLOFF");
}

void loop() {
 if (Serial.available()) {
 char inChar = (char)Serial.read();
 if (inChar == 'n') {
 inputString.trim();
 processCommand(inputString);
 inputString = "";
 } else {
 inputString += inChar;
 }
 }
}

void processCommand(String cmd) {
 cmd.toUpperCase();

 if (cmd == "ALLON") {
 for (int i = 0; i < 8; i++) digitalWrite(rele[i], LOW);
 Serial.println("Tutti i relè ACCESI");
 } else if (cmd == "ALLOFF") {
 for (int i = 0; i < 8; i++) digitalWrite(rele[i], HIGH);
 Serial.println("Tutti i relè SPENTI");
 } else if (cmd.startsWith("ON")) {
 int ch = cmd.substring(2).toInt();
 if (ch >= 1 && ch <= 8) {
 digitalWrite(rele[ch - 1], LOW);
 Serial.println("Relè " + String(ch) + " acceso");
 }
 } else if (cmd.startsWith("OFF")) {
 int ch = cmd.substring(3).toInt();
 if (ch >= 1 && ch <= 8) {
 digitalWrite(rele[ch - 1], HIGH);
 Serial.println("Relè " + String(ch) + " spento");
 }
 } else {
 Serial.println("Comando non valido");
 }
}

🖥️ Cómo usarlo

Abre el Monitor Serial de Arduino en 9600 baudios, envía:

• ON1 → enciende el relé 1
• OFF1 → apaga el relé 1
• ALLON → enciende todos
• ALLOFF → apaga todos

---

🌐 2. Control de Relés a través de WiFi con ESP8266/ESP32 (Web Server)

🎯 Objetivo:

Controlar los relés desde una página web local hospedada por el módulo WiFi (ESP8266 o ESP32).

🧠 Requisitos

• ESP8266 (por ejemplo, NodeMCU) o ESP32
• 12V al módulo relé, 5V lógico (los pines INx del módulo deben aceptar 3.3V si usas ESP8266)
• Red WiFi

📟 Código del Servidor Web (ESP8266)

#include <ESP8266WiFi.h>
const char* ssid = "TUO_SSID";
const char* password = "TUA_PASSWORD";

WiFiServer server(80);
int relePin[8] = {5, 4, 14, 12, 13, 15, 3, 1}; // D1-D8

void setup() {
 Serial.begin(115200);
 WiFi.begin(ssid, password);
 while (WiFi.status() != WL_CONNECTED) delay(1000);
 server.begin();

 for (int i = 0; i < 8; i++) {
 pinMode(relePin[i], OUTPUT);
 digitalWrite(relePin[i], HIGH); // Relè spenti
 }
 Serial.println(WiFi.localIP());
}

void loop() {
 WiFiClient client = server.available();
 if (!client) return;

 while (!client.available()) delay(1);
 String request = client.readStringUntil('r');
 client.flush();

 int ch = -1;
 if (request.indexOf("/on") != -1) ch = request.charAt(4) - '1';
 if (request.indexOf("/off") != -1) ch = request.charAt(5) - '1';

 if (ch >= 0 && ch < 8) {
 if (request.indexOf("/on") != -1) digitalWrite(relePin[ch], LOW);
 if (request.indexOf("/off") != -1) digitalWrite(relePin[ch], HIGH);
 }

 client.println("HTTP/1.1 200 OK");
 client.println("Content-Type: text/htmln");
 client.println("<html><body><h1>Relè ESP8266</h1>");
 for (int i = 0; i < 8; i++) {
 client.print("Relè ");
 client.print(i + 1);
 client.print(": <a href='/on");
 client.print(i + 1);
 client.print("'>ON</a> <a href='/off");
 client.print(i + 1);
 client.print("'>OFF</a>");
 }
 client.println("</body></html>");
}

🌍 Acceso

• Después de cargar, abre el Monitor Serial para ver la IP.
• Ve al navegador: http://<IP> → encontrarás los botones para cada relé.

---

🏠 3. Integración con Home Assistant / Blynk

🏡 Home Assistant a través de ESPHome

Requisitos:

• Módulo ESP8266 o ESP32
• Home Assistant instalado en Raspberry Pi o PC
• ESPHome integrado

📄 esphome.yaml

esphome:
 name: rele_esp
 platform: ESP8266
 board: nodemcuv2

wifi:
 ssid: "TUO_SSID"
 password: "TUA_PASSWORD"

api:
 password: "opzionale"

ota:
 password: "opzionale"

switch:
 - platform: gpio
 name: "Relè 1"
 pin: D1
 inverted: true
 - platform: gpio
 name: "Relè 2"
 pin: D2
 inverted: true
 - platform: gpio
 name: "Relè 3"
 pin: D3
 inverted: true
 # ... Aggiungi fino a Relè 8

Cárgalo a través del Dashboard de ESPHome o a través de USB → los relés aparecerán en Home Assistant como entidades switch!

---

📱 Control vía Blynk (app móvil)

Requisitos:

• App Blynk IoT (nueva versión)
• Consola Blynk: https://blynk.cloud
• ESP8266/ESP32

📟 Código base para ESP8266 + Blynk

#define BLYNK_TEMPLATE_ID "XXXX"
#define BLYNK_TEMPLATE_NAME "Modulo Relè"
#define BLYNK_AUTH_TOKEN "YYYY"

#include <ESP8266WiFi.h>
#include <BlynkSimpleEsp8266.h>

char ssid[] = "TUO_SSID";
char pass[] = "TUA_PASSWORD";

int relePin[] = {5, 4, 14, 12, 13, 15, 3, 1}; // Relè su D1-D8

void setup() {
 Blynk.begin(BLYNK_AUTH_TOKEN, ssid, pass);
 for (int i = 0; i < 8; i++) {
 pinMode(relePin[i], OUTPUT);
 digitalWrite(relePin[i], HIGH);
 }
}

BLYNK_WRITE(V1) { digitalWrite(relePin[0], !param.asInt()); }
BLYNK_WRITE(V2) { digitalWrite(relePin[1], !param.asInt()); }
// ... fino a V8

📲 Configura la aplicación Blynk

• Agrega 8 pulsadores virtuales (V1–V8)
• Asocia cada pulsador a un pin virtual

---

Tutorial: Cómo usar el módulo Relè Shield 8 canales 12V para Arduino

El módulo relè shield es un componente esencial para quien quiera controlar dispositivos eléctricos a bajo nivel con Arduino. Ideal tanto para principiantes como para makers más experimentados, permite gestionar hasta 8 circuitos independientes.

Qué necesitas

• Arduino uno o compatible
• módulo relè shield
• fuente de alimentación externa (12V)
• conectores jumpers

Pasos

1. Conecta el módulo relè shield al Arduino utilizando la conexión ICSP o inserta directamente en un breadboard.
2. Verifica que la alimentación del módulo sea de 12V, de lo contrario conecta una fuente externa adecuada.
3. Conecta los pines de los relés a los pines digitales del Arduino (D0-D7).
4. Carga el sketch siguiente en el Arduino.
5. Verifica que las salidas de salida del módulo no estén en uso por otros componentes.
6. Verifica la resistencia eléctrica entre los contactos NO, NC y COM del relé para asegurarte de que el circuito esté cerrado cuando lo desees.
7. Prueba cada canal del módulo por separado para identificar posibles problemas de funcionamiento.
8. Si es necesario, ajusta los conectores o la configuración del sketch.

Código de ejemplo

const int relayPin[8] = {2, 3, 4, 5, 6, 7, 8, 9};

void setup() {
 for (int i = 0; i < 8; i++) {
 pinMode(relayPin[i], OUTPUT);
 }
}

void loop() {
 digitalWrite(relayPin[0], HIGH); // Attiva il primo relè
 delay(1000);
 digitalWrite(relayPin[0], LOW); // Disattiva il primo relè
}

Miniproyecto

Crea un sistema de iluminación inteligente con los relés. Conecta varios lámparas a los canales del módulo y usa Arduino para controlarlos según la hora o comandos del teléfono.

Errores comunes

• Uso de tensión incorrecta (no 12V)
• Configuración de pinMode incorrecta
• Conectores faltantes o inestables
• Uso de relés demasiado grandes para el módulo

Accesorios recomendados

• Arduino Uno R3
• Fuente de alimentación 12V
• Jumpers variados
• Protoboard

Preguntas frecuentes

Mi relé no se activa.
Verifica que la tensión de alimentación sea correcta y que los pines estén configurados como salida.

¿Puedo usar este módulo con Raspberry Pi?
Sí, pero podría ser necesario un convertidor lógico para adaptarlo a la tensión del Raspberry Pi.

¿Cuántos dispositivos puedo conectar a cada relé?
Consulta el datasheet del dispositivo que estás intentando conectar al relé.