8 Canali 12V Relè Shield Modulo per Arduino ARM PIC AVR DSP SRD-12VDC-SL-C New

Descrizione

🔧 Descrizione del Modulo 8 Canali 12V Relè Shield (SRD-12VDC-SL-C)

✅ Caratteristiche Principali

• Tipo di modulo: Shield a 8 relè
• Numero di canali: 8
• Tensione di funzionamento: 12V DC
• Relè utilizzati: SRD-12VDC-SL-C
• Corrente del relè: fino a 10A a 250V AC / 10A a 30V DC
• Interfaccia di controllo: TTL a 5V compatibile con microcontrollori (Arduino, PIC, ARM, AVR, DSP)
• Segnale attivo: generalmente attivo LOW (logica negativa)
• Isolamento: Ottico isolato con optoisolatori per protezione da interferenze
• LED di stato: Un LED per ogni canale per indicare lo stato del relè (acceso/spento)
• Morsetti a vite: per il collegamento sicuro di carichi esterni
• Pin di controllo: IN1–IN8

---

🔌 Collegamenti Hardware

🛠️ Pin del modulo

• VCC: alimentazione 5V per la logica dei relè (collegare al 5V di Arduino)
• GND: massa comune
• JD-VCC: alimentazione del circuito dei relè (12V richiesti)
• IN1-IN8: ingressi di controllo dei relè (collegati ai pin digitali di Arduino)

🔐 Nota importante: per isolare correttamente il modulo da Arduino, puoi rimuovere il jumper tra VCC e JD-VCC, e fornire separatamente 12V su JD-VCC (per i relè) e 5V su VCC (per l’optoisolamento).

---

🖥️ Schema di Collegamento 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è)

---

📘 Guida alla Programmazione con Arduino

✅ Codice Base per Controllare 8 Relè

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

---

💡 Esempi di Applicazioni

1. Automazione domestica: accensione/spegnimento di luci, ventilatori, pompe.
2. Controllo carichi industriali: gestione di elettrovalvole o motori.
3. Progetti IoT: gestione remota di più dispositivi tramite WiFi/Bluetooth.
4. Sistema di irrigazione: accensione di elettrovalvole a orari programmati.

---

🔐 Consigli di Sicurezza

• Non superare i limiti di corrente/tensione dei relè.
• Isolare i carichi AC con opportune protezioni (fusibili, varistori, ecc.).
• Se controlli carichi ad alta tensione (220V AC), agisci con prudenza o fatti aiutare da un tecnico qualificato.

---

🧪 Test Rapido dei Relè

Per verificare che i relè funzionino correttamente:

1. Collega i pin INx a GND → il relè corrispondente dovrebbe attivarsi (scatta il “clic”).
2. Usa il codice sopra per eseguire una sequenza.

---

🧰 Alimentazione consigliata

• Utilizza un alimentatore esterno da 12V 1-2A per JD-VCC.
• Usa il jumper solo se alimenti tutto da Arduino, ma questo non è consigliato se usi più di 2 relè contemporaneamente.

---

📦 Contenuto del modulo (in vendita)

• 1x modulo relè 8 canali 12V (SRD-12VDC-SL-C)
• Terminali a vite per carichi
• Pin header per connessione con Arduino

---

🔌 1. Controllo Relè via Comunicazione Seriale da PC

🎯 Obiettivo:

Controllare gli 8 relè da un PC tramite la porta seriale di Arduino (tramite comandi come ON1, OFF2, ALLON, ALLOFF).

📟 Codice Arduino (Seriale)

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");
  }
}

🖥️ Come usarlo

Apri il Monitor Seriale di Arduino a 9600 baud, invia:

• ON1 → accende relè 1
• OFF1 → spegne relè 1
• ALLON → accende tutti
• ALLOFF → spegne tutti

---

🌐 2. Controllo Relè via WiFi con ESP8266/ESP32 (Web Server)

🎯 Obiettivo:

Controllare i relè da una pagina web locale ospitata dal modulo WiFi (ESP8266 o ESP32).

🧠 Requisiti

• ESP8266 (es. NodeMCU) o ESP32
• 12V al modulo relè, 5V logico (i pin INx del modulo devono accettare 3.3V se usi ESP8266)
• Rete WiFi

📟 Codice Web Server (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><br>");
  }
  client.println("</body></html>");
}

🌍 Accesso

• Dopo il caricamento, apri il Monitor Seriale per vedere l’IP.
• Vai nel browser: http://<IP> → troverai i pulsanti per ogni relè.

---

🏠 3. Integrazione con Home Assistant / Blynk

🏡 Home Assistant via ESPHome

Requisiti:

• Modulo ESP8266 o ESP32
• Home Assistant installato su Raspberry Pi o PC
• ESPHome integrato

📄 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

Caricalo tramite ESPHome Dashboard o via USB → i relè compariranno su Home Assistant come entità switch!

---

📱 Controllo via Blynk (app mobile)

Requisiti:

• App Blynk IoT (nuova versione)
• Blynk Console: https://blynk.cloud
• ESP8266/ESP32

📟 Codice base per 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 l’app Blynk

• Aggiungi 8 pulsanti virtuali (V1–V8)
• Associa ogni pulsante a un pin virtuale

---

Tutorial: Come usare il modulo Relè Shield 8 canali 12V per Arduino

Il modulo relè shield è un componente essenziale per chiunque voglia controllare dispositivi elettrici da basso livello con Arduino. Ideale sia per principianti che per maker più esperti, permette di gestire fino a 8 circuiti indipendenti.

Cosa serve

• Arduino uno o compatibile
• modulo relè shield
• alimentazione esterna (12V)
• connettori jumpers

Passi

1. Collega il modulo relè shield all’Arduino utilizzando la connessione ICSP o inseriscilo direttamente su un breadboard.
2. Verifica che l’alimentazione del modulo sia di 12V, altrimenti collega una fonte esterna adeguata.
3. Collega i pin dei relè ai pin digitali dell’Arduino (D0-D7).
4. Carica lo sketch sottostante nell’Arduino.
5. Verifica che le porte di output del modulo non siano già in uso da altri componenti.
6. Controlla la resistenza elettrica tra i contatti NO, NC e COM dei relè per assicurarti che il circuito sia chiuso quando lo si desidera.
7. Testa ogni singolo canale del modulo separatamente per identificare eventuali problemi di funzionamento.
8. Se necessario, aggiusta i collegamenti o la configurazione dello sketch.

Codice di esempio

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è
}

Mini-progetto

Crea un sistema di illuminazione intelligente con i relè. Collega diversi lampadari ai canali del modulo e usa Arduino per controllarli in base all’ora o a comandi dal telefono.

Errori comuni

• Utilizzo della tensione errata (non 12V)
• Impostazioni di pinMode non corrette
• Collegamenti saltati o non stabili
• Uso di relè troppo grandi per il modulo

Accessori consigliati

• Arduino Uno R3
• Fonte alimentazione 12V
• Jumpers vari
• Breadboard

Domande frequenti

Il mio relè non si attiva.
Verifica che la tensione di alimentazione sia corretta e che i pin siano configurati come output.

Posso usare questo modulo con Raspberry Pi?
Sì, ma potrebbe essere necessario un convertitore logico per adattarlo alla tensione del Raspberry Pi.

Quanti dispositivi posso collegare a ciascun relè?
Verifica sul datasheet del dispositivo che stai cercando di connettere al relè.