GSM Shield 2 e sensore PIR con Arduino: chiamata al rilevamento

Cosa imparerai

• come leggere un sensore PIR con uscita digitale;
• come gestire una logica di allarme attiva LOW;
• come inizializzare la GSM Shield 2 con la libreria GSM.h;
• come effettuare una chiamata tramite GSMVoiceCall;
• come inserire il numero telefonico nello sketch;
• come evitare chiamate ripetute troppo ravvicinate.

Come funziona il progetto

Arduino Uno R3, GSM Shield 2 e sensore PIR vengono combinati per creare un semplice sistema di rilevazione movimento. Quando il sensore rileva un evento, Arduino effettua una chiamata al numero configurato.

Arduino GSM Shield 2 utilizzata nel progetto.

Sensore PIR utilizzato per il rilevamento del movimento.

Come funziona il sensore PIR usato nel progetto

Il PIR utilizzato viene alimentato tra 7 V e 12 V. Dopo l’accensione impiega circa due secondi per stabilizzarsi sull’ambiente circostante e può rilevare movimento fino a circa 7 metri.

Un dettaglio fondamentale è la logica dell’uscita: quando rileva movimento, il piedino di allarme passa a livello logico LOW.

Materiale necessario

Schema del circuito

Schema di collegamento della GSM Shield 2 con sensore PIR.

Collegamento principale

Inserire il numero telefonico

Prima di caricare lo sketch devi sostituire il testo:

String remoteNumber = "insert-here-your-phone-number";

con il numero che vuoi chiamare. È buona pratica inserire il prefisso internazionale quando richiesto dalla SIM o dalla rete utilizzata.

Codice Arduino commentato

#include <GSM.h>

// ==========================================================
// GSM SHIELD 2 + SENSORE PIR
// Effettua una chiamata quando viene rilevato movimento
// ==========================================================

// Oggetto che gestisce la connessione alla rete GSM
GSM gsmAccess;

// Oggetto dedicato alle chiamate vocali
GSMVoiceCall vcs;

// Numero telefonico da chiamare.
// Sostituisci il segnaposto nella tua copia locale.
String remoteNumber = "insert-here-your-phone-number";

// Buffer di caratteri richiesto dalla funzione voiceCall()
char charBuffer[20];

// Uscita digitale del PIR collegata al pin D4
const int pirPin = 4;

// Variabile che contiene lo stato letto dal sensore.
// Con questo sensore:
// HIGH = nessun movimento
// LOW = movimento rilevato
int statoPir = HIGH;

void setup() {

 // Configura l'uscita del PIR come ingresso
 pinMode(pirPin, INPUT);

 // Converte la String del numero telefonico
 // in un array di char utilizzabile dalla libreria GSM.
 remoteNumber.toCharArray(charBuffer, 20);

 // Monitor Seriale per il debug
 Serial.begin(9600);

 Serial.println();
 Serial.println("- Avvio configurazione GSM -");

 // Finché la shield non è collegata alla rete,
 // continua a tentare l'inizializzazione.
 bool nonConnesso = true;

 while (nonConnesso) {

 if (gsmAccess.begin() == GSM_READY) {

 // Connessione GSM riuscita
 nonConnesso = false;
 }
 else {

 // Nuovo tentativo dopo un secondo
 Serial.println("GSM non connesso. Nuovo tentativo...");
 delay(1000);
 }
 }

 Serial.println("GSM inizializzato.");
 Serial.println("Attesa iniziale di 10 secondi...");

 // Tempo di stabilizzazione prima di iniziare
 // a controllare il sensore.
 delay(10000);
}

void loop() {

 // Legge lo stato dell'uscita digitale del PIR
 statoPir = digitalRead(pirPin);

 // Mostra lo stato sul Monitor Seriale
 Serial.print("PIR: ");
 Serial.println(statoPir);

 // Il sensore del progetto è attivo LOW:
 // quando statoPir è LOW viene rilevato movimento.
 if (statoPir == LOW) {

 Serial.println("Movimento rilevato.");

 // Avvia la chiamata verso il numero configurato
 if (vcs.voiceCall(charBuffer)) {

 Serial.println("Chiamata avviata.");

 // Resta in attesa finché la chiamata
 // risulta nello stato TALKING.
 while (vcs.getvoiceCallStatus() == TALKING) {
 // Nessuna operazione:
 // attendiamo che la chiamata termini.
 }

 // Chiude la chiamata se necessario
 vcs.hangCall();

 Serial.println("Chiamata terminata.");

 delay(1000);
 }

 // Pausa di 30 secondi:
 // evita di effettuare immediatamente
 // una seconda chiamata per lo stesso evento.
 Serial.println("Attesa di 30 secondi...");
 delay(30000);
 }
}

Come funziona il programma

1. Inizializzazione della GSM Shield

Nel setup() Arduino richiama gsmAccess.begin(). Se la shield non è pronta, il programma riprova ogni secondo finché non ottiene lo stato GSM_READY.

2. Lettura del PIR

Il sensore viene letto con digitalRead(4). Poiché il modello usa una logica attiva-bassa, la condizione di allarme è statoPir == LOW.

3. Avvio della chiamata

Quando viene rilevato movimento, vcs.voiceCall(charBuffer) prova a iniziare la chiamata verso il numero configurato.

4. Attesa della fine

Lo sketch controlla lo stato della chiamata con getvoiceCallStatus() e successivamente esegue hangCall().

5. Pausa anti-ripetizione

Dopo l’evento viene applicato un delay(30000), cioè 30 secondi. È una soluzione semplice per evitare una raffica di chiamate se il PIR resta in allarme.

Attivo LOW: cosa significa?

Perché c’è una pausa iniziale di 10 secondi?

Dopo aver inizializzato la shield, il programma aspetta 10 secondi prima di entrare nel funzionamento normale. Questo crea un margine di stabilizzazione prima di iniziare a reagire agli eventi del PIR.

Risultato del progetto

Scarica lo sketch

Debug rapido

• verifica alimentazione e piedinatura del PIR utilizzato;
• controlla che l’uscita di allarme sia realmente collegata a D4;
• osserva sul Monitor Seriale se il PIR passa da HIGH a LOW durante il movimento;
• controlla che la SIM sia correttamente inserita nella shield;
• verifica che il numero telefonico sia stato sostituito nel codice locale;
• se compare continuamente “GSM non connesso”, il problema è nella fase di inizializzazione della shield/rete;
• se il PIR funziona ma non parte la chiamata, verifica separatamente il funzionamento di voiceCall().

Miglioramenti possibili

• aggiungere un LED che indica lo stato armato/allarme;
• aggiungere un pulsante di attivazione e disattivazione;
• inviare anche un SMS oltre alla chiamata;
• evitare delay(30000) usando millis();
• registrare il numero di eventi rilevati;
• aggiungere più sensori PIR in stanze diverse.

Una variante senza delay da 30 secondi

In un progetto più evoluto è preferibile usare un tempo di blocco basato su millis(), così Arduino può continuare a svolgere altre attività mentre attende il prossimo evento valido.

// 30 secondi tra due notifiche
const unsigned long cooldown = 30000;

unsigned long ultimaChiamata = 0;

void loop() {

 int statoPir = digitalRead(pirPin);

 bool movimento = (statoPir == LOW);

 bool cooldownTerminato =
 (millis() - ultimaChiamata >= cooldown);

 if (movimento && cooldownTerminato) {

 // Qui avvieresti la chiamata GSM

 ultimaChiamata = millis();
 }

 // Il resto del programma può continuare
 // a funzionare senza delay(30000).
}

Cosa devi ricordare

Domande frequenti