📲 Arduino • GSM Shield 2 • 8 Relè

Controllare 8 relè con Arduino GSM Shield 2 tramite SMS

Realizziamo un sistema di controllo remoto con Arduino Uno e GSM Shield 2 capace di accendere e spegnere fino a otto relè inviando semplici comandi SMS.

ControlloSMS
Uscite8 relè
Comandion1…on8 / off1…off8
In poche parole: ogni relè viene associato a un numero da 1 a 8. Inviando alla SIM dello Shield un SMS come on1 si attiva il relè 1; con off1 lo si disattiva. Lo stesso principio vale per tutte le altre uscite.

Come funziona il controllo tramite SMS

Arduino GSM Shield 2 riceve i messaggi inviati al numero della SIM installata sul modulo. Lo sketch legge il contenuto dell’SMS e lo confronta con una serie di comandi prestabiliti.

Quando viene riconosciuto un comando valido, Arduino modifica lo stato del pin associato al relè. Il sistema permette quindi di controllare a distanza luci, piccoli automatismi o altri circuiti collegati ai contatti del modulo relè.

Con Arduino Uno vengono utilizzate otto uscite digitali: D4, D5, D6, D8, D9, D10, D11 e D12. Il pin D13 viene invece usato per un LED verde che segnala quando la connessione GSM è pronta.

Materiale necessario

🔌 Arduino Uno
📡 Arduino GSM Shield 2
⚡ Modulo relè 8 canali
🟢 1 LED verde
Ω 1 resistenza da 220 Ω
📱 SIM compatibile con il modulo
🔗 Cavetti di collegamento
🧩 Breadboard

🧰 Kit Arduino consigliato

Un kit completo è utile per avere breadboard, cavetti, resistenze, LED e molti componenti di base per sperimentare con Arduino.

👉 Guarda il kit Arduino consigliato

Link di affiliazione Amazon: in qualità di Affiliato Amazon ricevo un guadagno dagli acquisti idonei, senza alcun costo aggiuntivo per te.

📘 Vuoi imparare Arduino passo dopo passo?

Se vuoi approfondire e realizzare progetti più completi, puoi dare un’occhiata anche ai miei libri dedicati ad Arduino. All’interno troverai spiegazioni semplici, schemi chiari e molti progetti pratici pensati per chi parte da zero.

👉 Scopri i miei libri su Arduino

Link di affiliazione Amazon: in qualità di Affiliato Amazon ricevo un guadagno dagli acquisti idonei, senza alcun costo aggiuntivo per te.

Schema di collegamento

Schema Arduino GSM Shield 2 con modulo 8 relè

Schema del controllo di otto relè con Arduino Uno e GSM Shield 2.

Pin utilizzati

UscitaPin ArduinoComandi SMS
Relè 1D4on1 / off1
Relè 2D5on2 / off2
Relè 3D6on3 / off3
Relè 4D8on4 / off4
Relè 5D9on5 / off5
Relè 6D10on6 / off6
Relè 7D11on7 / off7
Relè 8D12on8 / off8
LED stato GSMD13—
Perché manca D7? Arduino GSM Shield 2 utilizza il pin 7 per la gestione dell’accensione del modem. Per questo motivo le otto uscite del modulo relè vengono distribuite sugli altri pin disponibili.

Preparare la SIM

Inserisci la SIM nello Shield e assicurati che la configurazione richiesta dal modulo sia corretta. Se lo sketch utilizza gsmAccess.begin() senza specificare un PIN, la SIM deve poter essere utilizzata senza richiesta del codice PIN all’avvio.

Prima prova: è meglio verificare prima la registrazione GSM e la ricezione di un singolo SMS, poi collegare il modulo a otto relè. In questo modo eventuali problemi di rete, SIM o alimentazione sono più semplici da individuare.

Codice Arduino commentato

GSM Shield 2 – controllo di 8 relè via SMS
/*
  ARDUINO GSM SHIELD 2 - CONTROLLO DI 8 RELÈ TRAMITE SMS

  Comandi:
  on1 / off1  -> relè 1
  on2 / off2  -> relè 2
  on3 / off3  -> relè 3
  on4 / off4  -> relè 4
  on5 / off5  -> relè 5
  on6 / off6  -> relè 6
  on7 / off7  -> relè 7
  on8 / off8  -> relè 8

  Pin usati:
  Relè 1 -> D4
  Relè 2 -> D5
  Relè 3 -> D6
  Relè 4 -> D8
  Relè 5 -> D9
  Relè 6 -> D10
  Relè 7 -> D11
  Relè 8 -> D12
  LED stato GSM -> D13

  Nota:
  il pin D7 viene lasciato libero perché Arduino GSM Shield 2
  lo utilizza per la gestione dell'accensione del modem.
*/

#include <GSM.h>

// Oggetti della libreria GSM
GSM gsmAccess;
GSM_SMS sms;

// Pin degli 8 relè
const byte relayPins[8] = {
  4, 5, 6, 8, 9, 10, 11, 12
};

// LED che segnala la connessione GSM pronta
const byte ledVerde = 13;

// Se il tuo modulo relè è active LOW,
// inverti questi due valori.
const byte RELAY_ON  = HIGH;
const byte RELAY_OFF = LOW;

void setup() {

  Serial.begin(9600);

  // Configura le 8 uscite relè.
  for (byte i = 0; i < 8; i++) {
    pinMode(relayPins[i], OUTPUT);

    // All'avvio tutti i relè vengono lasciati spenti.
    digitalWrite(relayPins[i], RELAY_OFF);
  }

  pinMode(ledVerde, OUTPUT);
  digitalWrite(ledVerde, LOW);

  // Avvia la connessione GSM.
  // Con SIM senza PIN è sufficiente begin().
  while (gsmAccess.begin() != GSM_READY) {
    delay(1000);
  }

  // Connessione GSM pronta.
  digitalWrite(ledVerde, HIGH);
}

void loop() {

  // Controlla se è arrivato un SMS.
  if (sms.available()) {

    String messaggio;
    messaggio.reserve(16);

    // Legge tutti i caratteri contenuti nel messaggio.
    char c;

    while ((c = sms.read()) != -1) {
      messaggio += c;
    }

    // Rende il comando più tollerante:
    // elimina spazi e ritorni a capo e converte in minuscolo.
    messaggio.trim();
    messaggio.toLowerCase();

    Serial.print("SMS ricevuto: ");
    Serial.println(messaggio);

    // Cerca uno dei comandi on1...on8 oppure off1...off8.
    bool comandoValido = false;

    for (byte i = 0; i < 8; i++) {

      String comandoOn  = "on"  + String(i + 1);
      String comandoOff = "off" + String(i + 1);

      if (messaggio == comandoOn) {
        digitalWrite(relayPins[i], RELAY_ON);
        comandoValido = true;
        break;
      }

      if (messaggio == comandoOff) {
        digitalWrite(relayPins[i], RELAY_OFF);
        comandoValido = true;
        break;
      }
    }

    if (!comandoValido) {
      Serial.println("Comando SMS non riconosciuto.");
    }

    // Elimina l'SMS dalla memoria della SIM/modem.
    sms.flush();
  }
}

Come funziona lo sketch

1. Avvio della rete GSM

Nel setup() Arduino configura tutte le uscite e avvia il modem con gsmAccess.begin(). Quando la registrazione è completata viene acceso il LED verde sul pin D13.

2. Lettura dell’SMS

La funzione sms.available() controlla se è presente un messaggio. Il testo viene letto carattere per carattere e raccolto nella variabile messaggio.

3. Normalizzazione del comando

Con trim() vengono eliminati eventuali spazi e ritorni a capo, mentre toLowerCase() converte il testo in minuscolo. In questo modo anche un messaggio scritto come ON1 viene interpretato correttamente.

4. Scelta del relè

Un ciclo confronta il messaggio ricevuto con i comandi da on1 a on8 e da off1 a off8. Quando trova una corrispondenza modifica soltanto l’uscita associata.

5. Eliminazione del messaggio

Dopo l’elaborazione viene eseguito sms.flush() per rimuovere il messaggio dalla memoria e lasciare il sistema pronto per il comando successivo.

Esempi di SMS

SMSEffetto
on1Attiva il relè 1
off1Disattiva il relè 1
on4Attiva il relè 4
off4Disattiva il relè 4
on8Attiva il relè 8
off8Disattiva il relè 8
Comandi SMS on1 off1 Arduino GSM relè

Esempio dei comandi utilizzati per attivare e disattivare un relè.

Personalizzare i comandi SMS

Non sei obbligato a utilizzare le stringhe on1 e off1. Puoi sostituirle con parole più descrittive, per esempio luceon, luceoff, pompaon o altri comandi adatti all’applicazione.

Personalizzare comando SMS Arduino GSM Shield 2

Esempio di personalizzazione delle stringhe di comando.

Moduli relè active LOW

Molti moduli a 8 relè si attivano portando l’ingresso a LOW invece che a HIGH. Se il tuo modulo funziona al contrario, non modificare tutte le istruzioni una per una: cambia semplicemente queste due costanti:

Configurazione active LOW
const byte RELAY_ON  = LOW;
const byte RELAY_OFF = HIGH;

Alimentazione del modulo a 8 relè

Otto bobine di relè possono richiedere una corrente significativa. Verifica il consumo del modulo e non dare per scontato che il pin 5 V di Arduino sia sempre sufficiente ad alimentare contemporaneamente tutti i canali.

Se utilizzi un’alimentazione esterna per il modulo relè, segui lo schema elettrico previsto dal modello utilizzato e assicurati che i riferimenti di massa necessari siano collegati correttamente.

Sicurezza: i contatti dei relè possono essere usati per comandare carichi separati da Arduino, ma lavorare con tensioni di rete richiede isolamento, contenitori e cablaggi adeguati. Per prove didattiche è preferibile iniziare con carichi a bassa tensione.

Scarica lo sketch

⬇️ Scarica arduino_gsm_shield_2__8rel_.zip

Debug rapido

  • verifica che la SIM venga riconosciuta e che il modem completi la registrazione;
  • controlla che il LED verde su D13 si accenda quando GSM è pronto;
  • invia un solo comando semplice, per esempio on1;
  • verifica che il modulo relè non sia active LOW;
  • controlla i pin D4, D5, D6, D8, D9, D10, D11 e D12;
  • se Arduino si riavvia quando si attivano più relè, verifica l’alimentazione;
  • usa il Monitor Seriale a 9600 baud per leggere il testo ricevuto.

Varianti del progetto

  • utilizzare meno di otto relè;
  • passare ad Arduino Mega per aggiungere più uscite;
  • inviare un SMS di conferma dopo ogni comando;
  • autorizzare soltanto determinati numeri telefonici;
  • aggiungere comandi per spegnere o accendere tutti i relè insieme;
  • aggiungere sensori e richiedere lo stato tramite SMS;
  • salvare lo stato delle uscite in EEPROM.

Cosa devi ricordare

  • Arduino Uno controlla otto relè tramite SMS.
  • Le uscite utilizzate sono D4, D5, D6, D8, D9, D10, D11 e D12.
  • D13 segnala quando la connessione GSM è pronta.
  • I comandi standard sono on1…on8 e off1…off8.
  • I moduli relè possono essere active HIGH oppure active LOW.
  • L’alimentazione deve essere dimensionata anche per il modulo a 8 relè.

Domande frequenti

Posso controllare meno di otto relè?

Sì. Puoi utilizzare soltanto le uscite necessarie lasciando scollegati gli altri canali.

Posso controllare più di otto dispositivi?

Sì. Una scheda con più I/O, come Arduino Mega, permette di ampliare il numero di uscite, adattando opportunamente lo sketch.

Perché il mio relè si attiva con OFF e si spegne con ON?

Probabilmente il modulo è active LOW. Inverti i valori di RELAY_ON e RELAY_OFF nello sketch.

Posso cambiare le parole on1 e off1?

Sì. Puoi sostituire i comandi con stringhe personalizzate, purché il testo inviato via SMS corrisponda a quello previsto dal programma.