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

🔧 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/html\n");
  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