Condividi tramite

Arduino due e Mobile Service(it-IT)

  • Articolo

 

Introduzione.

Nel precedente articolo Arduino Due Development, è stata fatta un introduzione su questa scheda, eseguita la configurazione iniziale partendo dall’installazione delle librerie necessarie, per terminare con la configurazione della scheda Ethernet shield, con la quale la scheda Arduino Due potrà accedere a Internet. In questo secondo articolo, vedremo come Arduino può interagire con i servizi di Microsoft Azure, precisamente con i Mobile Service. Partiremo dalla creazione di un Mobile Service, continueremo costruendoci un piccolo circuito usando il sensore di temperatura e umidità DHT11, terminando con la parte di codice che si occuperà di trasferire le informazioni rilevate dal sensore su Microsoft Azure. Vedremo nell’ordine:

  • Creazione di un Mobile Service.
  • Montaggio del circuito elettronico.
  • Scrittura del codice per l’upload dei dati dal sensore a Microsoft Azure.
  • Test dell’applicazione.
  • Conclusioni.

Creazione di un Mobile Service.

La creazione di un Mobile service è molto semplice, per prima cosa occorre avere un account Microsoft e una sottoscrizione ad Azure. Entrati nel portale, alla schermata iniziale premiamo il tasto New che troviamo in basso a sinistra come mostrato in figura.

Alla successiva schermata, dobbiamo assegnare un nome al Mobile Service, scegliere se usare un DataBase esistente o crearne uno free da 20 mb, Dove situarlo, nel mio caso il Data Center più vicino e North Europe, per cui questo non sarà uguale per tutti, ma e consigliabile scegliere il Data Center più vicino a voi, ultima cosa, la parte di Backend, io lascerò Javascript.

Prossimo passo, creare un DataBase, quindi un nome da assegnargli, scegliere se creare un nuovo database SqlServer, e ultima cosa inserire le credenziali, come mostrato in figura.

Terminata quest’attività, attendiamo che Azure crei il Mobile Service, noteremo che avremo un mobile service e un DataBase.

Siamo ora pronti per creare una tabella all’interno del DataBase sensorfarm_db. Click con il mouse su sensorfarm nella sezione Mobile Service, alla successiva schermata click sul pulsante posto di fianco alla scritta “ADD A TABLE”. Sarà visualizzata un altra schermata dove dovremo inserire il nome della tabella, inseriamo tabsensor come mostrato nella figura seguente.

Lasciamo tutti gli altri campi così come sono e click sul tasto rappresentato con segno di spunta posto in basso a destra e attendiamo che venga creata la tabella.

Abbiamo fino a qui terminato la procedura per la creazione di un Mobile Service, passiamo ora alla realizzazione del circuito elettronico.

Montaggio del circuito elettronico.

Per la realizzazione del circuito, occorrono i seguenti componenti:

  • Scheda Arduino Due
  • Scheda Ethernet shield
  • Sensore DHT11
  • BreadBoard (base per il collegamento del sensore)
  • Colmeter (cavi per il collegamento tra la scheda Arduino Due e il sensore DHT11)
  • Alimentatore per il collegamento della scheda Arduino due

Di seguito lascio le immagini del circuito finale. Il sensore può funzionare da una tensione di 3,3 Vdc fino ad un massimo di 5,5V. Per maggiore chiarezza sul collegamento e funzionamento, rimando alla documentazione ufficiale.

Nell’immagine precedente, bisogna precisare che la scheda Ethernet Shield, va sovrapposta sulla scheda Arduino Due, così da avere i pin necessari per il collegamento, vedere la freccia nera da destra verso sinistra. Ho lasciato separate le due schede solo per visualizzare tutti i componenti necessari. Terminato il collegamento ecco come deve essere in pratica il nostro circuito.

Come e possibile notare la scheda Ethernet Shield viene sovrapposta alla scheda Arduino Due.

Scrittura del codice per l’upload dei dati dal sensore a Microsoft Azure.

Terminata anche la realizzazione del circuito, siamo pronti per iniziare la parte software, prima cosa da fare se non eseguito, e scaricare le librerie necessarie per utilizzare il sensore DHT11 che trovate a questo link. Dopo il download, è  necessario eseguirne l’installazione, possiamo eseguirla un due modalità:

  • Estraendo i file all’interno del file .zip e copiarli manualmente nella directory C:\Program Files (x86)\Arduino\libraries
  • Seguire la seguente procedura, Avviare l’ide di Arduino, dal menù  Sketch andiamo a selezionare il comando Include Library e successivamente Add .ZIP Library… come mostrato in figura.

Andiamo a selezionare il file .zip che abbiamo scaricato che solitamente viene messo nella cartella Download.

Confermiano con il comando Apri, ed ecco che se andiamo a verificare che tutto sia andato a buon fine troviamo il file dht11 tra le librerie disponibili.

Con questa procedura, i file vengono estratti e salvati non nella directory precedente, ma in C:\Users\nome utente\Documents\Arduino, dove “nome utente” cambierà a seconda di cosa avete inserito al momento dell’installazione del sistema operativo, nel mio caso è C:\Users\CARMELO LA MONICA\Documents\Arduino. Abbiamo installato le librerie necessarie, passiamo adesso alla scrittura del codice. Avviamo l’ide Arduino e creiamo un file Sketch denominato DHT11 Sample. ed inseriamo il codice seguente al suo interno.

#include <SPI.h>
#include <Ethernet.h>
#include <dht11.h>
 
// Ethernet shield MAC address (sticker in the back)
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
 
/*You can find this values in your Mobile Service dashboard
   server = namemobileservice.azure-mobile.net
   table_name = nametable
   ams_key = your keyvalue, find in home page mobile service, with a click on button MANAGE KEYS*/
 
const char* server = "sensorfarm.azure-mobile.net";
const char* table_name = "tabsensor";
const char* ams_key = "NyWPlQgRcUWHsrGwcwhHMRxVLtnItA64";
 
EthernetClient client;
char buffer[64];
dht11 DHT;
#define  DHT11_PIN 4
 
 
/*This method use Mobile service REST API fot to write value*/
void write_sensorvalue(double tempvalue, double humidityvalue)
{
   if (client.connect(server, 80)) {
      
     /*Table name in Mobile service*/
     sprintf(buffer, "POST /tables/%s HTTP/1.1", table_name);
     client.println(buffer);
 
    /*Sever name in Mobile Service*/
     sprintf(buffer, "Host: %s", server);
     client.println(buffer);
 
    /*Mobile Services application key*/
     sprintf(buffer, "X-ZUMO-APPLICATION: %s", ams_key);
     client.println(buffer);
 
    // JSON content type for the information 
     client.println("Content-Type: application/json");
 
    /*Write values of temperature and humidity from DHT11 sensor*/
     sprintf(buffer, "{\"tempvalue\":\"%f\",\"humidityvalue\":\"%f\"}", tempvalue, humidityvalue);
 
    // Content length
     client.print("Content-Length: ");
     client.println(strlen(buffer));
 
    // End of headers
     client.println();
 
    // Request body
     client.println(buffer);
 
  }
    
   else
   {
     Serial.println("no connection available!");
   }
     client.stop();
}
 
/*-------------------------------------------------------*/
/*Setup method*/
/*-------------------------------------------------------*/
void setup()
{
   Serial.begin(9600);
 
  if (Ethernet.begin(mac) == 0) 
   {
     Serial.println("ethernet shield failed");
     for (;;);
   }
    
   // Ethernet shield initialization:
   delay(1000);
}
 
/*-------------------------------------------------------*/
/*Loop method*/
/*-------------------------------------------------------*/
void loop()
{
   /*Read value from sensor input*/
   int chk = DHT.read(DHT11_PIN);
 
  /*Call method writ_sensorvalue and pass sensor parameter for to save on mobile service*/
   write_sensorvalue((DHT.temperature), (DHT.humidity));
 
  /*Time wait for new input data*/
   delay(10000);
}

Vediamo il funzionamento del codice. Includiamo in questo caso la libreria installata per il sensore dht11, nella fattispecie il file dht11.h, mentre le altre due librerie vi erano già nel precedente articolo. Ci sono tre variabili di tipo const char*, che non sono altro che il nome della tabella, il nome del server e il codice key, tutti necessari per l’upload dei dati.

#include <dht11.h>
const char* server = "sensorfarm.azure-mobile.net";
const char* table_name = "tabsensor";
const char* ams_key = "reperibile da portale";

Andiamo a dichiarare ancora altre tre variabili

char buffer[64];
dht11 DHT;
#define  DHT11_PIN 4

Dove la prima sarà il buffer di dati in upload, la seconda rappresenta il file dht11 dove mediante i metodi e altre variabili saremo in grado di leggere i valori di temperatura e umidità dal sensore. Ultima variabile non fa altro che impostare il pin 4 della scheda Arduino Due come Input per il sensore, quindi dobbiamo necessariamente collegare il pin “Signal” del sensore DHT11 sul pin 4 della scheda. Il metodo write_sensorvalue, è la parte più interessante, poiché si occupa di eseguire l’upload dei dati su Azure, vediamo le parti di codice più significative.

/*Table name in Mobile service*/
     sprintf(buffer, "POST /tables/%s HTTP/1.1", table_name);
     client.println(buffer);
 
    /*Sever name in Mobile Service*/
     sprintf(buffer, "Host: %s", server);
     client.println(buffer);
 
    /*Mobile Services application key*/
     sprintf(buffer, "X-ZUMO-APPLICATION: %s", ams_key);
     client.println(buffer);

Eseguiamo una richiesta HTTP e una chiamata di tipo POST, dove dobbiamo indicare il nome della tabella cerata precedentemente, il nome del Server il codice key, questo per poter eseguire consentire il corretto upload dei dati.

// JSON content type for the information 
client.println("Content-Type: application/json");
 
/*Write values of temperature and humidity from DHT11 sensor*/
sprintf(buffer, "{\"tempvalue\":\"%f\",\"humidityvalue\":\"%f\"}", tempvalue, humidityvalue);

Con il codice precedente, specifichiamo in che formato stiamo inviando i dati, quindi tipo JSON, e nell’ultima parte di codice specifichiamo il pattern, ovvero cosa ritroveremo nella tabella tabsensor quando andremo a verificare se i dati sono stati caricati correttamente. Il metodo Setup lo abbiamo già visto nel precedente articolo, mentre più interessante e il metodo Loop.

void loop()
{
   /*Read value from sensor input*/
   int chk = DHT.read(DHT11_PIN);
 
  /*Call method writ_sensorvalue and pass sensor parameter for to save on mobile service*/
   write_sensorvalue((DHT.temperature), (DHT.humidity));
 
  /*Time wait for new input data*/
   delay(10000);
}

Dichiariamo una variabile di tipo int, che non fa altro che leggere lo stato del sensore di temperatura e umidità, questo mediante il metodo read che come parametro richiede il pin di ingresso. Richiamiamo poi il metodo write_sensorvalue passando come parametri i valori di temperatura e umidità tramite DHT.temperature e DHT.humidity. L’ultima istruzione di codice non e altro che un tempo di attesa di dieci secondi prima di avviare una nuova lettura. Abbiamo così terminato la parte relativa al codice, siamo ora pronti per eseguire le prove di funzionalità, ma prima dobbiamo caricare lo sketch di codice sulla scheda Arduino Due, per questa procedura rimando al precedente articolo.

Test dell’applicazione.

Diamo un occhiata adesso all’interno della tabella tabsensor, è troveremo questa situazione.

Questo perché non abbiamo definito nessun record al suo interno, ma soprattutto nessuna colonna. Possiamo alimentare ora la scheda Arduino Due in diversi modi, o con il suo alimentatore, o attaccandoci tramite porta usb del nostro pc, dove attualmente siamo perché abbiamo caricato precedentemente lo sketch di codice. Se tutto procede in modo corretto dovremmo vedere lampeggiare i led verdi della scheda Ethernet Shield, ciò sta a significare che e andata in funzione, ma soprattutto se andiamo sul portale Azure e verificare se i dati che sono stati caricati, e se tutto è stato eseguito correttamente ecco cosa ci troveremo.

  

Notiamo dall’immagine che i servizi di Azure anno aggiunto per noi i campi tempvalue e humidityvalue, con altri campi, id, timestamp e version questi ultimi non fanno parte del nostro codice ma vengono aggiunti automaticamente al momento in cui viene inserito un nuovo record nella tabella tabsensor, in altre parole non ci siamo dovuti preoccupare noi di questo, ci ha pensato Azure per noi.

Conclusione.

In questo secondo articolo, abbiamo visto come da Arduino e possibile interagire con Microsoft Azure e i Mobile Service, creando un semplice circuito dove leggiamo mediante sensore dht11 i valori di temperatura e umidità, per poi andare a salvare i dati all’interno della tabella tabsensor. Nel prossimo articolo, creeremo un applicazione Windows Phone 8.1 che farà in modo di visualizzare i dati ed intraprendere poi un azione da eseguire.