Arduino. Utilizzare la rete GSM per progetti IoT 

Come utilizzare Arduino e rete gsm per progetti IoT

Sentire parlare di progetti IoT è quasi diventata una moda e nonostante la realizzazione di progetti più o meno interessanti, possiamo confermare che il mercato è in forte espansione e l’industria sta investendo ingenti capitali. Uno degli aspetti chiave dell’internet delle cose è sicuramente la remotizzazione dei dispositivi. Vengono perciò progettate reti dedicate, come la rete Sigfox oppure il sistema LoRa caratterizzate da lunghe distanze operative e bassi consumi.
Un altro canale di comunicazione che sta ritornando in uso è la rete gsm, forte della sua alta percentuale di copertura del territorio nazionale e un uso ormai semplificato grazie a libreria pronte all’uso.
Nonostante i moduli GSM abbiano un consumo energetico maggiore rispetto a quelli SigFox e LoRa, rimane comunque un sistema molto valido soprattutto in attesa che anche nel nostro paese vengano realizzate reti IoT dedicate.

Esistono diverse shield gsm o moduli stand alone che permettono di costruire circuiti capaci di dialogare tra loro a grandi distanze. La shield ufficiale Arduino è da tempo indisponibile, nonostante esiste una seconda versione, viste le diatribe tra le due società Arduino, ho preferito usare un altro prodotto ed in particolare quello sviluppato da Mikroelektronica che si basa sul modulo M95A perché  ha un costo contenuto ed è compatibile con la libreria ufficiale disponibile nell’ide sviluppato da Arduino.cc.

Di seguito potete vedere il modulo e la sua pin function

Mikroelektronica, oltre ha produrre diversi tipi di compilatori, ha un suo sistema di sviluppo hardware composto da delle schede chiamate Click Boards che si collegano tra loro utilizzando il Mikro Bus.

La comunicazione tra la GSM2click ed Arduino avviene tramite UART. Esiste anche la Arduino UNO click shield ma purtroppo non possiamo utilizzarla perché la libreria gsm utilizza la SoftwareSerial sui pin 2 e 3 mentre nella Arduino UNO click shield la seriale è collegata ai pin 0 e 1.
Quindi dovremmo adattare i collegamenti Arduino UNO e la GSM2click seguendo questo semplice schema:

Il modulo GSM2Click utilizza sia l’alimentazione a 3.3Vdc sia quella a 5Vdc. I pin TX e RX del modulo vanno rispettivamente collegati al pin 2 e pin 3 di Arduino (quelli utilizzati dalla SoftwareSerial della libraria GSM). Il pin7 di Arduino va collegato al pin RST che in pratica corrisponde al PowerKey del modulo M95.

Codice di esempio

Prima di caricare il codice dobbiamo inserire nel modulo GSM2Click una SIM attiva con relativo credito telefonico. Nonostante il modulo possa funzionare senza l’ausilio di un’antenna consiglio assolutamente il suo impiego per aumentare il segnale ricevuto e soprattutto evitare disadattamenti di impedenza del trasmettitore RF.

Il codice seguente inizializza il modem del modulo M95 e ne ricava il codice IMEI:

// libraria GSM
#include <GSM.h>

//creo un oggetto modem
GSMModem modem;

String IMEI = "";
float tempo_prec, tempo =0;

void setup()
{
//init seriale
Serial.begin(9600);
delay(100);

Serial.println("Avvio modem...");

//memorizzo il tempo corrente
tempo_prec = millis();

//inizializzo il modem e verifico il suo stato
if (modem.begin())
{
//memorizzo il tempo corrente
tempo= millis();

//calcolo il tempo di avvio del modem
Serial.print("Modem avviato in ");
Serial.print((tempo - tempo_prec)/1000);
Serial.println(" secondi.");

}
else
//avvisami in caso di errore
Serial.println("ERRORE, nussuna risposta dal modem.");

Serial.println("Leggo il codice IMEI");

//ottengo il codice imei
IMEI = modem.getIMEI();

//verifico il codice e lo visualizzo
if (IMEI != NULL)
{
Serial.print("Codice IMEI= " + IMEI);
}
else
{
Serial.println("ERRORE: lettura codice IMEI fallita!");
}
}

void loop()
{

}

La classe GSM permette di semplificare la comunicazione col modulo utilizzando una sintassi molto elementare. Abbiamo comunque la possibilità di scendere nel dettaglio utilizzando i comandi AT. La Quectel fornisce dettagliate documentazioni relative a tutti i sui moduli, in questo modo possiamo ottimizzare il nostro codice accedendo solo alle funzioni specifiche del modulo.

Per provare ad utilizzare i comandi AT, ho modificato il circuito elettrico prelevando il segnale sul pin STA del modulo GSM2Click, questo perchè prima di inviare un comando devo assicurarmi che il modulo sia attivo e funzionante.

Questo il codice che testa la comunicazione tramite comandi AT:

#include <SoftwareSerial.h>

#define rxPin 2
#define txPin 3

SoftwareSerial mySerial =  SoftwareSerial(rxPin, txPin);

String risp_at = "";
char message[50];

void setup() {
// put your setup code here, to run once:
mySerial.begin(9600);
Serial.begin(9600);

pinMode(6, INPUT);
pinMode(7, OUTPUT);

//verifico se il modulo è attivo
if(digitalRead(6) == LOW)
{
//attivo il moduloinviando un livello
//logico alto al pin PWK (Power Key)
digitalWrite(7, HIGH);
delay(1000);
digitalWrite(7, LOW);
}

//attendi l'avvio del modulo
while(digitalRead(6) == LOW)
{
delay(100);
Serial.print(".");
}

//Invio il comando 'AT' per verificare la
//risposta del modulo
mySerial.write("AT");
mySerial.write(10);
mySerial.write(13);

delay(500);

//attendo finchè non ricevo dati dal modulo
while(mySerial.available())
{
risp_at += (char)mySerial.read();
}

if(risp_at.length() > 0)
{
risp_at.toCharArray(message, risp_at.length());
Serial.println(risp_at);
}
}

void loop()
{
delay(10);
}

Volendo possiamo utilizzare direttamente il Serial Monitor per inviare comandi AT al modulo. In pratica invio il comando ad Arduino UNO che lo rigira al modulo M95 e viceversa, i dati inviati dal modulo M95 vengono spediti al serial monitor tramite Arduino UNO. Questo è un ottimo metodo per testare comandi At e capirne il funzionamento.

#include <SoftwareSerial.h>

#define rxPin 2
#define txPin 3

SoftwareSerial mySerial(rxPin,txPin); // RX, TX

void setup(){

Serial.begin(9600);
Serial.println("Arduino serial initialized!");
delay(10);

mySerial.begin(9600);
Serial.println("Software serial initialized!");
delay(10);

pinMode(6, INPUT);
pinMode(7, OUTPUT);

//verifico se il modulo è attivo
if(digitalRead(6) == LOW)
{
//attivo il moduloinviando un livello
//logico alto al pin PWK (Power Key)
digitalWrite(7, HIGH);
delay(1000);
digitalWrite(7, LOW);
}

}

void loop()
{
if(Serial.available())
{
mySerial.write(Serial.read());
}

if(mySerial.available())
{
Serial.write(mySerial.read());
}
}

Ora possiamo usare il Serial Monitor come se fosse collegato direttamente al modulo M95.
Lanciamo il Serial Monitor ed assicuriamoci di avere impostata la velocità di comunicazione a 9600bps e di selezionare il ritorno carrello e la nuova linea (NL & CR).

Proviamo a scrivere sul serial monitor il comando AT e clicchiamo sul pulsante invia. Il modulo risponderà con questa stringa:

OK //comando eseguito correttamente

La risposta OK informa che il comando AT è stato eseguito correttamente.
Possiamo verificare ed esempio quale sia il livello del segnale della rete GSM inviando al modulo questi caratteri AT+CSQ
il risultato, nel mio caso è il seguente:

+CSQ: 26,0

OK

il comando CSQ è riconosciuto valido e il suo valore è 26,0. Questi dati possono essere interpretati utilizzando il manuale del modulo M95.

Le istruzioni AT sono molto semplici e permettono di eseguire sia comandi sia settaggi di impostazioni. Per ulteriori esempi non dovete fare altro che leggerli dal manuale!