Nello scorso articolo abbiamo capito come attivare la Arduino sim e come configurare l’Arduino MKR GSM 1400. Inoltre abbiamo visto come sia possibile inviare dati alla scheda utilizzando il Network Monitor.

In questo articolo andremmo a creare un elemento Thing utilizzando l’Arduino Cloud e a scrivere il codice per la MKR GSM 1400 in modo da poter inviare dei dati sul cloud.

Seguiamo questo indirizzo https://create.arduino.cc/iot/. Nella home dell’Arduino Cloud (al momento ancora in versione beta) possiamo creare un nuovo Thing, ovvero un contenitore di oggetti grafici che hanno il compito di visualizzare dati provenienti dalla scheda oppure di inviarli.

Cliccando sul bottone Add New Thing verrà caricata una pagina in cui inserire il nome del Thing e la scheda da associare nostro progetto IoT.

Nel combobox Select Board selezioneremmo la scheda GSM 1400 che abbiamo configurato nel precedente articolo. Clicchiamo ora sul pulsante CREATE.

Ci ritroveremo nella pagina principale del Thing che abbiamo appena creato.

Attualmente sono disponibili 4 Tab. Nel tab Properties verranno elencate tutte le variabili del Thing. Queste variabili potranno essere richiamate nello sketch. Nal tab Dashboard verranno rappresentate le variabili sotto forma di oggetti grafici, pulsanti e indicatori. Nel tab Webhooks possiamo scambiare dati con altri servizi. Nel tab Board sarà possibile associare una scheda al Thing, questa associazione è molto importante perchè va a mettere in relazione la scheda selezionata con la chiave memorizzata nel crypto chip della GSM 1400. Se la chiave del crypto chip non coincide con la chiave della scheda che abbiamo caricato nel Device Manager, la comunicazione non potrà avvenire.

Creare delle proprietà

Torniamo nel tab Properties e clicchiamo sul bottone ADD PROPERTY. Verrà caricata una nuova pagina contenente un form come quello in figura:

Nel campo Name inseriamo un nome identificativo per la proprietà, questo nome sarà copiato anche sul campo Variable Name. Se lo riteniamo opportuno possiamo cambiare il Variable Name. Il nome inserito nel campo Variable Name, sarà utilizzato all‘interno del codice dello sketch.

Inseriamo per esempio il nome “temperatura”.

Nella combobox Type selezioniamo la voce Temperature sensor (Celsius). Vengono visualizzati due nuovi campi dove inserire il valore minimo e massimo che la variabile temperatura dovrà avere. Inseriamo come valore minimo 0°C e come valore massimo 100°C.

Compiliamo anche la sezione Permission, Update  e History.

Nella sezione Permission possiamo scegliere Read Only se il dato viene inviato dal dispositivo al cloud Arduino, mentre sceglieremo Read & Write se abbiamo la necessita di aggiornare la variabile temperature dall’Arduino cloud.

La sezione Update ci permette di ricevere i dati a tempi prestabiliti (utilizzando la textbox per indicare un tempo) oppure riceverli quando il dato ha una variazione rispetto al dato precedentemente inviato.

La sezione history crea un grafico utilizzando uno storico dei dati inviati dalla scheda.

Ora non ci resta che cliccare sul bottone ADD PROPERTY per confermare la nostra proprietà.

Andiamo nel tab Dashboard è osserviamo la presenza di un elemento che visualizzerà il dato proveniente dalla scheda.

Per il momento non aggiungiamo nessun’altra proprietà e dedichiamoci alla scrittura del codice.

Installazione delle librerie

Apriamo l’Arduino IDE e creiamo un nuovo sketch. Importiamo tutte le librerie per lavorare con l’Arduino cloud. Da Gestore Librerie (combinazione di tasti Ctrl+Maiusc+i) cerchiamo la libreria ArduinoIotCloud:

procediamo con l’installazione cliccando sul pulsante Installa. Il gestore delle librerie indicherà che sono indispensabili delle librerie aggiuntive:

Installiamole tutte come richiesto.

Scrivere il codice per la scheda MKR GSM 1400

Il codice seguente mostra come collegarsi all’Arduino Cloud e come aggiornare la variabile temperatura definita precedentemente nel Thing:

//Includo le librerie seguenti
#include <ArduinoIoTCloud.h>
#include <Arduino_ConnectionHandler.h>

//creo una costante dove contenere il think_id
//questo dato possiamo ottenerlo andando nel pannello di controllo
//dell'arduino cloud
const char THING_ID[]      = "a42be6ce-3158-4843-a29b-a36e1c90256f";

//in queste costanti inserisco i dati relativi alla sim arduino
const char GPRS_APN[]      = "prepay.pelion";
const char PINNUMBER[]     = "0000";
const char GPRS_LOGIN[]    = "arduino";
const char GPRS_PASSWORD[] = "arduino";

//questa è la variabile temperatura che abbiamo definito nelle proprietà del Thing
CloudTemperature temperatura;

//creo la connessione all'arduino cloud usando la rete gsm
GSMConnectionHandler ArduinoIoTPreferredConnection(PINNUMBER, GPRS_APN, GPRS_LOGIN, GPRS_PASSWORD);

void setup() {
  // inizializzo la seriale
  Serial.begin(9600);
  //attendo che tutto sia pronto
  delay(1500);
  
  //inizializzo con l'id del clous
  ArduinoCloud.setThingId(THING_ID);
  //specifico la variabile che ho inserito nel thing e le sue caratteristiche
  ArduinoCloud.addProperty(temperatura, READ, ON_CHANGE, NULL);

  //inizializzo la connessione con la'rduino cloud
  //specificando il canale di comunicazione
  ArduinoCloud.begin(ArduinoIoTPreferredConnection);
  
  //attivo i messaggi di debug
  setDebugMessageLevel(2);
  ArduinoCloud.printDebugInfo();
}

void loop() {
  //trigghero l'arduino cloud
  ArduinoCloud.update();

  //genero dei valori casuali per la variabile temperatura
  temperatura = random(0, 100);
  //visualiazzo sul serial monitor il valore della variabile
  Serial.print("send data ");
  Serial.println(temperatura);
  attendo 10 s tra gli aggiornamenti
  delay(10000);

}

I commenti che ho inserito nel codice descrivono il lavoro svolto dalle istruzioni.

Compiliamo e carichiamo il codice sulla Arduino GSM 1400. Terminato il caricamento apriamo il Serial monitor e osserviamo le fasi che portano a stabilire la connessione con l’Arduino Cloud.

Sul serial monitor osserviamo la stringa Device ID, questo valore deve essere identico a quello riportato nel tab Board. La stringa Thing ID invece deve essere identica a quella che viene indicata sulla pagina del Thing che abbiamo creato.

Apriamo una finestra del browser e colleghiamoci all’Arduino Cloud andando sulla dashboard del Thing. Osservando l’elemento grafico temperatura, dovremmo riscontrare gli stessi valori che la scheda sta trasmettendo.

In questo articolo abbiamo visto come configurare l’Arduino cloud e come trasmettere dei dati usando la MKR GSM 1400. Vedremo prossimamente anche come inviare dati dall’Arduino cloud alla scheda.

The post Configura con successo l’Arduino cloud appeared first on Esperimenti con logiche programmabili.

Un dispositivo IoT, tipicamente, ha bisogno di avere un circuito elettronico in grado di acquisire ed elabora dati (provenienti da sensori o da comandi esterni), un mezzo di trasmissione (molto spesso basato su un segnale  a radio frequenza) e un sistema remoto capace di memorizzare, elaborare e gestire i dati.

Le caratteristiche del microcontrollore sono scelte in base alla potenza di calcolo e alla sua capacità di risparmiare energia. Molte applicazioni IoT sono spesso installate in luoghi remoti dove non è possibile avere una alimentazione stabile e duratura, quindi l’unica fonte di energia è demandata all’uso di una batteria.

I mezzi di comunicazione più diffusi che vengono utilizzati in ambito IoT sono, LoRa, Sigfox, NB e rete cellulare(2G/3G/4G). La scelta tra questi sistemi avviene principalmente in base alla copertura, alla posizione geografica del dispositivo IoT e ai costi di gestione.

Questo articolo si basa sull’utilizzo di una Arduino Sim e una scheda Arduino MKR GSM 1400.

La Arduino SIM può essere utilizzata solamente con Arduino Cloud.

Come attivare la Sim Arduino

Quando riceviamo la sim Arduino, prima di poterla utilizzare, dobbiamo procedere alla sua attivazione. Sulla custodia della sim viene riportato un link (https://store.arduino.cc/digital/sim/activation) che porta ad una pagina web in cui è possibile inserire il codice ICCID presente sulla sim:

Dopo aver inserito il codice clicchiamo sul pulsante NEXT. Nella pagina successiva, andremmo a leggere e accettare i termini di utilizzo (ARDUINO SIM TERMS AND CONDITIONS). Clicchiamo nuovamente sul pulsante NEXT per confermare.

Nella pagina successiva ci sarà un riepilogo sulle informazioni del nostro account e sul costo del servizio. Continuiamo cliccando sul pulsante NEXT. Nella pagina successiva dovremmo inserire i dati di pagamento per poi procedere cliccando sul pulsante Complete Payment.

La sim a questo punto è in fase di attivazione e prima di utilizzarla dovremmo attendere una mail di conferma.

Come gestire la Arduino SIM

Per verificare le impostazioni e il traffico dati della nostra Arduino SIM dobbiamo andare sul device manager (https://create.arduino.cc/devices/). Scorrendo e arrivando in fondo alla pagina, vedremmo la nostra sim e il suo stato.

Per i dettagli è sufficiente cliccare sull’icona della sim attiva:

In questa pagina troviamo anche delle informazioni che dovranno essere inserite nel codice dello sketch che andremmo a scrivere:

Aggiungere una scheda al Device Manager

Dopo aver attivato la Arduino SIM dobbiamo associare nel Device Manager (https://create.arduino.cc/devices/) una scheda Arduino che potrà interagire con il cloud Arduino. Le schede abilitate all’uso del cloud Arduino sono le seguenti:

• MKR 1000
• MKR WiFi 1010
• MKR GSM 1400
• MKR NB 1500
• Nano 33 IoT
• MKR WAN 1300
• MKR WAN 1310

Nel mio caso utilizzerò una MKR GSM 1400.

Clicchiamo sull’icona ADD NEW BOARD. Verrà caricata una pagina con una procedura guidata che permetterà di associare la nostra scheda al Device Manager.

Nella prima pagina della procedura guidata, selezioniamo la scheda da utilizzare:

clicchiamo sull’icona Arduino MKT GSM 1400. Nella schermata successiva, vengono indicate le fasi per configurare la MKR GSM 1400:

Clicchiamo sul pulsante START per andare avanti. La prima fase della procedura guidata indica che dobbiamo scaricare il plugin Arduino Create Agent, il cui compito è quello di mettere in comunicazione la scheda collegata al pc con la procedura di configurazione on line.

Clicchiamo sul pulsante DOWNLOAD:

Una volta cliccato sul pulsante, la procedura mostra che dopo aver terminato il download del file, dobbiamo eseguire un doppio click su di esso e seguire le istruzioni:

Dopo l’installazione dell’Arduino Create Agent, la procedura guidata indicherà che la comunicazione con il plugin è avvenuta con successo:

Andiamo avanti cliccando sul pulsante NEXT. Nella schermata successiva viene richiesto di collegare la scheda al pc. Quindi procediamo collegando, tramite cavo usb, la scheda MKR GSM 1400 al nostro computer:

Dopo qualche istante il plug Arduino Create Agent, aggiornerà la procedura guidata on line che la scheda MKR 1400 è stata collegata al computer.

A questo punto otterremo la seguente schermata dove assoceremmo un nome alla nostra scheda:

Inseriamo un nome identificativo, ad esempio gsm_1400 e andiamo avanti cliccando sul pulsante NEXT.

Ora la procedura indica se vogliamo configurare il Crypto Chip presente nella MKR GSM 1400. Questa procedura è importante perché aumenta il livello di sicurezza della comunicazione tra la scheda e l’Arduino Cloud.

Clicchiamo su CONFIGURE e attendiamo la fine della configurazione del Crypto Chip.

Nella schermata successiva ci viene chiesto di inserire la scheda SIM. Io in questa fase ho scollegato la scheda dalla porta usb, ho inserito la sim e ricollegato la scheda alla porta usb.

Quindi clicchiamo nuovamente sul pulsante NEXT.

Nella schermata successiva viene visualizzato uno sketch di esempio. Lasciamo questo codice invariato e clicchiamo sul pulsante ENTER GSM DATA:

Ora viene richiesta la compilazione dei campi relativi ai parametri della Arduino SIM. Questi parametri gli abbiamo già incontrati quando abbiamo configurato la Arduino SIM.

Inseriamoli nei relativi campi e clicchiamo sul pulsante UPLOAD

Terminato l’upload dello sketch sulla Arduino GSM 1400, la procedura guidata prova a stabilire una connessione con la scheda utilizzando la rete gsm:

Se tutto funziona correttamente otterremo la schermata del Network Monitor:

In questa schermata possiamo accendere o spegnere il led on board della MKR GSM 1400. Scrivendo sulla textbox la stringa ON e cliccando sul bottone SEND potremo osservare che sulla scheda il led viene effettivamente acceso.
Per spegnerlo sarà sufficiente inserire la stringa OFF e premere nuovamente sul bottone SEND.

Terminiamo la procedura guidata cliccando sul pulsante PLAY.

Nel prossimo articolo andremmo a creare una THING utilizzando l’Arduino cloud e a scrivere del codice per spedire o ricevere dei dati.

The post Scopri come configurare Arduino sim e MKR 1400 appeared first on Esperimenti con logiche programmabili.

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!

The post Arduino. Utilizzare la rete GSM per progetti IoT appeared first on Esperimenti con logiche programmabili.