Dataino sketch – seconda parte

Carmelo, un giovane appassionato arduino, ha realizzato un progetto di data monitoring che ha voluto condividere: Dataino a cui ho dedicato un articolo la scorda settimana.

dataino interfaccia web

Dopo aver cerato il DB e le tabelle in cui memorizzare i tutoi dati è arrivato il momento di usare il dataino per raccogliere le informazioni dai sensori e pubblicarle nelle tabelle create.

Lo sketch del Dataino

Carmelo mi ha inviato lo sketch ed i commenti che ti riporto nella loro versione integrale:

//*************************************************************************
//** created 2013                                                        **
//** by dataino <http://www.dataino.it>                                  **
//** modified 18 Oct 2013                                                **
//** by G. Carmelo                                                       **
//*************************************************************************

//====================================================================== //
//                        ARDUINO LIBRARY                                //
//=======================================================================//
// [en] Library Ethernet                                                 //
// [it] Librerie Ethernet                                                //
//--------------------------------------------------------------         //
#include <Ethernet.h>                                                    //
#include <SPI.h>                                                         //
//=======================================================================//

//=======================================================================//
//                        DS18B20 LIBRARY                                //
//=======================================================================//
// [en] Library OneWire and DallasTeperature                             //
// [it] Librerie OneWire e DallasTeperature                              //
//--------------------------------------------------------------         //
#include <OneWire.h>                                                     //
#include <DallasTemperature.h>                                           //
//=======================================================================//

//=======================================================================//
//                         ARDUINO SETTING                               //
//=======================================================================//
// [en] remember to chang mac!!! this must be unique                     //
// [it] Ricordarsi di cambiare il mac è unico per scheda                 //
//--------------------------------------------------------------         //
byte mac[] = {0x90,0xA2,0xDA,0x0D,0x82,0x39};                            //
//--------------------------------------------------------------         //
// [en] change to your network settings                                  //
// [it] Cambiare con le impostazioni della propria rete                  // 
//--------------------------------------------------------------         //
IPAddress ip(192,168,1,200);                                             //
IPAddress gateway(192, 168, 1, 254);                                     //
IPAddress subnet(255, 255, 255, 0);                                      //
//--------------------------------------------------------------         //
// !!! IP ONLINE SERVER !!!  dataino.it                                  //
//--------------------------------------------------------------         //
IPAddress server(94,23,64,3);                                            //
//--------------------------------------------------------------         //
// !!! IP LOCAL SERVER !!!  localhost                                    //
//--------------------------------------------------------------         //
//IPAddress server(192,168,1,2);                                         //
//--------------------------------------------------------------         //
//[it] imposto il funzionamento della scheda                             //
//--------------------------------------------------------------         //
EthernetClient client;                                                   //
//=======================================================================//

//=======================================================================//
//                     DATAINO.IT VARIABLE SETTINGS                      //
//=======================================================================//
// [en] Api_key of table                                                 //
// [it] La chiave privata della tabella                                  //
//--------------------------------------------------------------         //
char API_key[] = "7y6X-3T7i-0d5N-979Q-yUV3";                             //
//--------------------------------------------------------------         //
// [en] Columns name of table                                            //
// [it] Nome delle colonne nella tabella                                 //
//--------------------------------------------------------------         //
char var[] = "&casa=";                                                   //
//--------------------------------------------------------------         //
// [en] commad for the table                                             //
// [it] comandi disponibili per la tabella                               //
//--------------------------------------------------------------         //
char cmd_find[] = "find_value";                                          //
char cmd_add[] = "add_value";                                            //
char cmd_delete[] = "delete_value";                                      //
//--------------------------------------------------------------         //
// [en] Command ahttp rray                                               //
// [it] Array del comando http                                           //
//--------------------------------------------------------------         //
char pageAdd[128];                                                       //
//=======================================================================//

//=======================================================================//
//                      PROGRAM VARIABLE                                 //
//=======================================================================//
// [en] Array for response                                               //
// [it] Array per le risposte                                            //
//--------------------------------------------------------------         //
int response[50];                                                        //
//--------------------------------------------------------------         //
// [en] Counters                                                         //
// [it] Contatori                                                        //
//--------------------------------------------------------------         //
int totalCount = 0;                                                      //
int loopCount  = 0;                                                      //
//=======================================================================//

//=======================================================================//
//                       DS18B20 SETTING                                 //
//=======================================================================//
// [en] Data wire is plugged into pin 10 on the Arduino                  //
// [it] Il pin Data è connesso al pin 10 sull Arduino                    //
//--------------------------------------------------------------         //
#define ONE_WIRE_BUS 3                                                   //
//--------------------------------------------------------------         //
// [en] Setup a oneWire instance to communicate with any                 //
//      OneWire devices                                                  //
// [it] Creo un istana oneWire per comunicare con tutti i                //
//      dispositivi oneWire                                              //
//--------------------------------------------------------------         //
OneWire oneWire(ONE_WIRE_BUS);                                           //
//--------------------------------------------------------------         //
// [en] Pass our oneWire reference to Dallas Temperature                 // 
// [it] Passo il riferimento oneWire                                     //
//--------------------------------------------------------------         //
DallasTemperature sensors(&oneWire);                                     //
//--------------------------------------------------------------         //
// [en] Assign the addresses of your 1-Wire temp sensors                 //
// [it] Assegno il codice identificativo del sensore                     //
//--------------------------------------------------------------         //
DeviceAddress insideThermometer={
  0x28,0x67,0xE7,0x47,0x04,0x00,0x00,0x2B};
//=======================================================================//

//=======================================================================//
//                               S E T U P                               //
//=======================================================================//
void setup()
{
  //=====================================================================//
  //                             SERIAL                                  //
  //=====================================================================//
  // [en] Start serial port                                              //     
  // [it] Inizializzo la seriale                                         //
  //--------------------------------------------------------------       //
  Serial.begin(9600);                                                    //
  //=====================================================================//

  //=====================================================================//
  //                          SENSOR DS18B20                             //
  //=====================================================================//
  // [en] Start up the library                                           //
  // [it] Faccio partire la libreria                                     //
  //--------------------------------------------------------------       //
  sensors.begin();                                                       //
  //--------------------------------------------------------------       //
  // [en] Set the resolution to 10 bit                                   //
  // [it] Setto la risoluzione a 10 bit                                  //
  //--------------------------------------------------------------       //
  sensors.setResolution(insideThermometer, 10);                          //
  //=====================================================================// 

  //=====================================================================//
  //                             NETWORK                                 //
  //=====================================================================//
  // [en] Serial Log                                                     //
  // [it] Log Sulla seriale                                              //
  //--------------------------------------------------------------       //
  Serial.println(F("Starting ethernet..."));                             //
  //--------------------------------------------------------------       //
  // [en] Start ethernet                                                 //
  // [it] Faccio partire la scheda di rete                               //
  //--------------------------------------------------------------       //
  Ethernet.begin(mac, ip, gateway, gateway, subnet);                     //
  //--------------------------------------------------------------       //
  // [en] If using dhcp, comment out the line above and uncomment        //
  //      the next 2 lines                                               //
  // [it] se uso il DHCP commentare la riga precedente e eliminare       //
  //      il commento dalle prossime due                                 //
  //--------------------------------------------------------------       //
  // if(!Ethernet.begin(mac)) Serial.println(F("failed"));               //
  // else Serial.println(F("ok"));                                       //
  //--------------------------------------------------------------       //
  // [en] Delay after Start ethernet                                     //
  // [it] Ritardo per far partire la scheda di rete                      //
  //--------------------------------------------------------------       //
  delay(1000);                                                           //
  //--------------------------------------------------------------       //
  // [en] Print the local IP                                             //
  // [it] Stampo il valore l ip della scheda                             //
  //--------------------------------------------------------------       //
  Serial.println(Ethernet.localIP());                                    //
  //--------------------------------------------------------------       //
  // [en] Serial Log                                                     //
  // [it] Log Sulla seriale                                              //
  //--------------------------------------------------------------       //
  Serial.println(F("Ready"));                                            //
  //=====================================================================//
}
//=======================================================================//
//                            END SETUP                                  //
//=======================================================================//

//=======================================================================//
//                      DS18B20 READ TEMPERATURE                         //
//=======================================================================//
void printTemperature(DeviceAddress deviceAddress)
{                                                                        //
  //--------------------------------------------------------------       //
  // [en] Read Temperature and store in variable                         //
  // [it] Leggo la temperatura e memorizzo nella Variabile               //
  //--------------------------------------------------------------       //
  float tempC = sensors.getTempC(deviceAddress);                         //
  //--------------------------------------------------------------       //
  // [en] Check the temperature value                                    //
  // [it] Controllo il valore di temperatura                             //
  //--------------------------------------------------------------       //
  if (tempC == -127.00) {                                                //
    //------------------------------------------------------------       //
    // [en] Serial Log                                                   //
    // [it] Log Sulla seriale                                            //
    //------------------------------------------------------------       //
    Serial.print(F("Error getting temperature"));                        //
  }                                                                      //
  //--------------------------------------------------------------       //
  // [en] Else if tem is correct                                         //
  // [it] Altrimenti se la temperatura è corretta                        //
  //--------------------------------------------------------------       //
  else {                                                                 //
    //------------------------------------------------------------       //
    // [en] Serial Log value C                                           //
    // [it] Log Sulla seriale del valore in C                            //
    //------------------------------------------------------------       //
    Serial.print(F("C: "));                                              //
    Serial.print(tempC);                                                 // 
    //------------------------------------------------------------       //
    // [en] Serial Log value F                                           //
    // [it] Log Sulla seriale del valore in F                            //
    //------------------------------------------------------------       //
    Serial.print(F(" F: "));                                             //
    Serial.print(DallasTemperature::toFahrenheit(tempC));                //
    //------------------------------------------------------------       //
    // [en] char Buffer for temp value nedd to assebly http command      //
    // [it] buffer di caratteri per il valore della temperatura          //
    //      necessario per assemblare il comando http                    //
    //                                                                   //
    // dtostrf(FLOAT,WIDTH,PRECSISION,BUFFER);                           //
    //                                                                   //
    //------------------------------------------------------------       //
    char buffer[10];                                                     //
    dtostrf(tempC, 5, 2, buffer);                                        //
    //------------------------------------------------------------       //
    // [en] Serial Log End Row                                           //
    // [it] Log Sulla seriale fine riga                                  //
    //------------------------------------------------------------       //
    Serial.println("\n\r");                                              //
    //------------------------------------------------------------       //
    // [en]clear page address (pageadd) by strcpy                        //
    // [it] Pulisco la riga dell indirizzo (pageadd) con strcpy          //
    //------------------------------------------------------------       //
    strcpy(pageAdd, "GET /~dataino/api/"); //ONLINE                      //
    //strcpy(pageAdd, "GET /dataino.it/api/"); // LOCAL                  //
    //------------------------------------------------------------       //
    // [en] Complete command width key variable, value                   //
    // [it] Completo il comando con la chiave la variabile e il          // 
    //      valore                                                       //
    //------------------------------------------------------------       //
    strcat(pageAdd, cmd_add);                                            //
    strcat(pageAdd, ".php?api-KEY=");                                    //
    strcat(pageAdd, API_key);                                            //
    strcat(pageAdd, var);                                                //
    strcat(pageAdd, buffer);                                             //
    strcat(pageAdd, " HTTP/1.1");                                        //
    //------------------------------------------------------------       //
    // [en] Serial Log http command                                      //
    // [it] Log Sulla seriale comando http                               //
    //------------------------------------------------------------       //
    Serial.println(pageAdd);                                             //
    //------------------------------------------------------------       //
  }                                                                      //
}                                                                        //
//=======================================================================//
//                      END DS18B20 READ TEMPERATURE                     //
//=======================================================================//

//=======================================================================//
//                               INFINITE LO0P                           //
//=======================================================================//
void loop () {
  //------------------------------------------------------------         //
  // [en] if loopCount is less than 10, just delay a 1000 ms             //
  // [it] se loopCount è < 10, aspetto 1000 millisecondi                 //
  //------------------------------------------------------------         //
  if( loopCount < 10 )
  {
    //----------------------------------------------------------         //
    // [en] delay a 1000 millisecond                                     //
    // [it] aspetto 1000 millisecondi                                    //
    //---------------------------------------------------------          //
    delay(1000);                                                         //
    //---------------------------------------------------------          //
    // [en] Serial Log "."                                               //
    // [it] Log Sulla seriale "."                                        //
    //---------------------------------------------------------          //
    Serial.print(F("."));                                                //
    //---------------------------------------------------------          //
  }
  else
  {

    //---------------------------------------------------------          //
    // [en] Else Start Reading temperature and send value to             //
    //      dataino.it every ten seconds this runs                      //
    // [it] Altrimenti leggo la temperatura e invio il dato              //
    //      ogni 10 secondi eseguo                                        //
    //---------------------------------------------------------          //
    // [en] Reset loopCount                                              //
    // [it] Resetto il contatore loopCount                               //
    //---------------------------------------------------------          //
    loopCount = 0;                                                       //
    //---------------------------------------------------------          //
    // [en] Serial Log End Row  [it] Log Sulla seriale fine riga         //
    //---------------------------------------------------------          //
    Serial.print(F("\n\r"));                                             //
    //---------------------------------------------------------          //
    // [en] Serial Log End Row  [it] Log Sulla seriale fine riga         //
    //---------------------------------------------------------          //
    Serial.print(F("Getting temperatures...\n\r"));                      //
    //---------------------------------------------------------          //
    // [en] Call sensor requestTemperatures                              //
    // [it] Chiamo la funzione del sensore requestTemperatures           //
    //---------------------------------------------------------          //
    sensors.requestTemperatures();                                       //
    //---------------------------------------------------------          //
    // [en] Serial Log End Row  [it] Log Sulla seriale fine riga         //
    //---------------------------------------------------------          //
    Serial.print(F("Inside temperature is: "));                          //
    //---------------------------------------------------------          //
    // [en] Call Read printTemperature                                   //
    // [it] Chiamo la funzione printTemperature                          //
    //---------------------------------------------------------          //
    printTemperature(insideThermometer);                                 //
    //---------------------------------------------------------          //
    // [en] Serial Log End Row  [it] Log Sulla seriale fine riga         //
    //---------------------------------------------------------          //
    Serial.print(F("\n\r"));                                             //
    //---------------------------------------------------------          //
    // [en] call the http address                                        //
    // [it] chiamo l indirizzo http e se la risposta è positiva          //
    //---------------------------------------------------------          //
    if(!getPage(server,pageAdd)) 
    {

    //---------------------------------------------------------          //
    // [en] Serial Log   [it] Log Sulla seriale                          //
    //---------------------------------------------------------          //
      Serial.print(F("Fail "));                                          //
    //---------------------------------------------------------          //

    }
    else
    {
      //-------------------------------------------------------          //
      // [en] Serial Log   [it] Log Sulla seriale                        //
      //-------------------------------------------------------          //
      Serial.print(F("Pass "));                                          //
      //-------------------------------------------------------          //
      // [en] Increment the reading counter                              //
      // [it] Incremento il contatore delle letture                      //
      //-------------------------------------------------------          //
      totalCount++;                                                      //
      //-------------------------------------------------------          //
      // [en] Serial Log   [it] Log Sulla seriale                        //
      //-------------------------------------------------------          //
      Serial.println(totalCount,DEC);                                    //
      //-------------------------------------------------------          //
    }
      //-------------------------------------------------------          //
      // End IF
      //-------------------------------------------------------          //
  }

 //------------------------------------------------------------          //
 // [en] Increment the reading counter                                   //
 // [it] Incremento il contatore delle letture                           //
 //------------------------------------------------------------          //
 loopCount++;                                                            //
 //------------------------------------------------------------          //
}

//=======================================================================//
//                           END INFINITE LO0P                           //
//=======================================================================//

//=======================================================================//
// [en] Call the http address   [it] Chiamo l indirizzo http             //
//=======================================================================//
byte getPage(IPAddress ipBuf,char *page)
{
  //-----------------------------------------------------------          //
  // [en] Variable containing the ASCII value of the character           //
  // [it] Variabile contenente il valore ascii del carattere             //
  //-----------------------------------------------------------          //
  int inChar;                                                            //
  //-----------------------------------------------------------          //
  // [en] Serial Log   [it] Log Sulla seriale                            //
  //-----------------------------------------------------------          //
  Serial.print(F("connecting..."));                                      //
  //-----------------------------------------------------------          //
  // [en] If the connection to the server ip is ok                       //
  // [it] Se la connessione all'indirizzo ip server è ok                 //
  //-----------------------------------------------------------          //
  if(client.connect(ipBuf,80))
  {

    //---------------------------------------------------------          //
    // [en] Serial Log   [it] Log Sulla seriale  
    //---------------------------------------------------------          //
    Serial.println(F("connected"));                                      //
    //---------------------------------------------------------          // 
    // [en] Write the GET command to the server                          //
    // [it] Scrivo al server il comando GET                              //
    //---------------------------------------------------------          //
    client.println(page);                                                //
    client.println("Host: www.dataino.it");                              //
    client.println("User-Agent: Arduino");                               //
    client.println("Connection: close\r\n");                             //
    //---------------------------------------------------------          //

  } 
  else
  {

    //---------------------------------------------------------          //
    // [en] Serial Log   [it] Log Sulla seriale                          //
    //---------------------------------------------------------          //
    Serial.println(F("failed"));                                         //
    //---------------------------------------------------------          //
    // [en] return code 0 = FAIL                                         //
    // [it] ritorno il valore 0 = FALLITO                                //
    //---------------------------------------------------------          //
    return 0;                                                            //
    //---------------------------------------------------------          //

  }
  //-----------------------------------------------------------          //
  // [en] ConnectLoop controls the hardware fail timeout                 //
  // [it] ConnectLoop controlla l'hardware fail timeout                  //
  //-----------------------------------------------------------          //
  int connectLoop = 0;                                                   //
  //-----------------------------------------------------------          //
  // [en] If the client is connected                                     //
  // [it] Se il client è connesso                                        //
  //-----------------------------------------------------------          //
  while(client.connected())
  {
    //---------------------------------------------------------          //
    // [en]                                                              //
    // [it] Se il client è avviable                                      //
    //---------------------------------------------------------          //
    while(client.available())
    {
      //-------------------------------------------------------          //
      // [en] I read a character                                         //
      // [it] Leggo un carattere                                         //
      //-------------------------------------------------------          //
      inChar = client.read();                                            //
      //-------------------------------------------------------          //
      // [en] If the character is #                                      //
      // [it] Se il carattere è  #                                       //
      //-------------------------------------------------------          //
      if ( inChar == char('#') )
      {
        //-----------------------------------------------------          //
        // [en] I read a character                                       //
        // [it] Leggo un carattere                                       //
        //-----------------------------------------------------          //
        inChar = client.read();                                          //
        //-----------------------------------------------------          //
        // [en] 
        // [it] 
        //-----------------------------------------------------          //
        while (inChar!='*'){                                             //
          //---------------------------------------------------          //
          // [en] Reset value of couter for the split of value           //
          // [it] Resetto i valori dei contatori per lo split dei valori //
          //---------------------------------------------------          //
          int count_val = 0 ;                                            //
          unsigned long i = 1;                                           //
          response[count_val] = 0;                                       //
          //---------------------------------------------------          //
          // [en] Run a loop until read the character ";"                //
          // [it] eseguo un ciclo fino ad incontrare il carattere ";"    //
          //---------------------------------------------------          //

          do {
            //-------------------------------------------------          //
            // [en] read the value of the numerical answer in            //
            //      character and translate it into an integer           //
            // [it] Leggo il valore della risposta numerica in           //
            //      caratteri e la traduco in numero intero              //
            //-------------------------------------------------          //
            response[count_val] = response[count_val] + (inChar-48) * i; //
            i = i * 10;                                                  //
            inChar = client.read();                                      //
            //-------------------------------------------------          //
          }
          while ((inChar!=char(';')));

          //---------------------------------------------------          //
          // [en] I read a character                                     //
          // [it] Leggo un carattere                                     //
          //---------------------------------------------------          //
          inChar = client.read();                                        //
          //---------------------------------------------------          //
          // [en] If it is the stop character * log and I go out         //
          // [it] Se è il carattere di stop * stampo il log e esco       //
          //---------------------------------------------------          //
          if ( inChar == char('*') ){                                    //
            //-------------------------------------------------          //
            // [en] Print the result                                     //
            // [it] Stampo il Risultato                                  //
            //-------------------------------------------------          //
            Serial.print(F("Query = "));                                 //
            Serial.print(response[count_val]);                           //
            Serial.print(F("\r\n"));                                     //
            //-------------------------------------------------          //
            break;                                                       //
            //-------------------------------------------------          //
          }
          //---------------------------------------------------          //
          // [en] increment the counter of the number of                 //
          //      received values                                        //
          // [it] incremento il contatore del numero di                  // 
          //      valori ricevuti                                        //
          //---------------------------------------------------          //
          count_val++;                                                   //
          //---------------------------------------------------          //
        }
        //-----------------------------------------------------          //
      }

      //-------------------------------------------------------          //
      // [en] set connectLoop to zero if a packet arrives                //
      // [it] Setto a Zero se è arrivato un pacchetto                    //
      //-------------------------------------------------------          //
      connectLoop = 0;                                                   //
      //-------------------------------------------------------          //

    }

    //---------------------------------------------------------          //
      // [en] Increment connectLoop if a packet do not arrives           //
      // [it] Incremento  connectLoop se non arrivano pacchetti          //
    //---------------------------------------------------------          //
    connectLoop++;                                                       //
    //---------------------------------------------------------          //

  }
  //-----------------------------------------------------------          //
  // [en] if more than 15000 milliseconds since the last packet          //
  // [it] se sono passati piu di 15000 milliseconds dall'ultimo          //
  //      pacchetto                                                      //
  //-----------------------------------------------------------          //
  if(connectLoop > 15000)
  {

    //---------------------------------------------------------          //
    // [en] then close the connection from this end                      //   
    // [it] Chiude la connessione                                        //
    //---------------------------------------------------------          //
    Serial.println(F("Timeout"));                                        //
    client.stop();                                                       //
    //---------------------------------------------------------          //

  }
  //-----------------------------------------------------------          //
  // [en] this is a delay for the connectLoop timing                     //
  // [it] Questo è un ritardo per i tempi connectLoop                    //
  //-----------------------------------------------------------          //
  delay(1);                                                              //
  Serial.println(F("disconnecting."));                                   //
  //-----------------------------------------------------------          //
  // [en] close client end                                               //
  // [it] Chiusura lato client                                           //
  //-----------------------------------------------------------          //
  client.stop();                                                         //
  //-----------------------------------------------------------          //
  // [en]return 1 = OK                                                   //
  // [it] ritorno il valore 1 = OK                                       //
  //-----------------------------------------------------------          //
  return 1;                                                              //
  //-----------------------------------------------------------          //
}
//=======================================================================//
//                [en] END CALL   [it] FINE CHIAMATA                     //
//=======================================================================//

Descrizione dello sketch

Righe 14, 15 Libreria Ethernet e Serial Peripheral Interface (SPI) per la comunicazione con la shield Ethernet
Righe 24, 25 Libreria del protocollo OneWire e del sensore di temperatura DS18B20
Righa 34 valore del mac address della scheda di rete
Riga 39,40,41 Configurazione ip della scheda di rete
Riga 45 indirizzo ip del sito www.dataino.it
Riga 53 Inizializzo la libreria client Ethernet con l’indirizzo IP e la porta del server che si desidera connettersi (porta 80 è di default per HTTP)
Riga 62 Memorizzo nella variabile API_key[] i caratteri della chiave privata univoca per la tabella su cui opero
Riga 67 Memorizzo nella variabile var[] i caratteri del comando http per la colonna su cui opero
Riga 72, 73, 74 Memorizzo nelle variabili i caratteri delle funzioni dataino (in questo esempio solo “add_value” è necessaria)
Riga 79 array dei caratteri nel quale verrà costruito il comando http
Riga 88 Variabile nella quale memorizzo i valori di ritorno della chiamata http
Riga 93 Variabile contatore per il conteggio degli invi effetuati
Riga 94 Variabile contatore per il controllo del tempo di invio dei dati (loopCount * delay)
Riga 103 Definisco su quale pin di arduino è collegato il pin trasmittente del sensore
Riga 110 Creo un istana oneWire per comunicare con tutti dispositivi oneWire
Riga 115 Passo il riferimento
Riga 120 Assegno il codice identificativo univoco del mio sensore
Riga 127 Inizializzazione
Riga 135 inizializzo la seriale
Riga 144 Faccio partire la libreria del Sensore DS18B20
Riga 149 Setto la risoluzione a 10 bit del Sensore DS18B20
Riga 156 Messaggio sul terminale: “Ethernet in avvio”
Riga 163 inizializzo la scheda di rete con la conigurazione della mia rete locale
Riga 176 Aspetto un secondo che sia partita la scheda
Riga 156 Messaggio sul terminale: Indirizzo ip
Riga 186 Messaggio sul terminale: Pronta
Riga 196 Funzione di stampa della temperatura (una volta effettuata la lettura dal sensore prepato il comando http per inviare il dato)
Riga 202 Leggo la temperatura e memorizzo il valore nella Variabile
Riga 207 Controllo che il valore di temperatura non sia sballato
Riga 186 Messaggio sul terminale: Errore di lettuta della temperatura
Riga 218 Altrimenti se il valore è normale
Riga 223,224,229,230 Messaggio sul terminale: valore in centigradi e Farenheit
Riga 239 buffer di caratteri che conterrà il mio valore di temperatura
Riga 240 con la funzione dtostrf(FLOAT,WIDTH,PRECSISION,BUFFER) prendo il valore float della temperatura e lo converto in //
Riga 250 Pulisco e copio la parte iniziale dell indirizzo http (pageadd) con strcpy
Riga 257,258,259,260,261,262 completo l’indirizzo http con tutte le parti necessarie
Riga 267 Messaggio sul terminale: Comando http

Riga 278 loop infinito
Riga 283 se loopCount è < 10
Riga 289 Ritardo un secondo
Riga 267 Messaggio sul terminale: .
Riga 297 altrimenti se loopCount = 10
Riga 309 Resetto il contatore loopCount //
Riga 267 Messaggio sul terminale: Lettura temperatura
Riga 322 Richiamo la funzione del sensore requestTemperatures //
Riga 326 Messaggio sul terminale: La temperatura è:

Riga 331 Richiamo la funzione printTemperature
Riga 338 Richiamo la funzione getPage (indirizzo ip del server + comando http) e se la risposta è negativa
Riga 346 Messaggio sul terminale: Fallito
Riga 350 altrimenti se il collegamento è riuscito
Riga 355 Messaggio sul terminale: Passato
Riga 360 Incremento il contatore delle letture totalCount
Riga 355 Messaggio sul terminale: Lettutture in formato DEC
Riga 376 Incremento il contatore di quante volte ho eseguito il loop infinito

Riga 387 funzione di chiamata http al server www.dataino.it
Riga 393 Variabile contenente il valore ascii del carattere letto sulla seriale
Riga 397 Messaggio sul terminale: Misto connettendo
Riga 402 Se il server è connesso sulla porta 80 (http)
Riga 409 Messaggio sul terminale: Connessso
Riga 413,414,415,416 Invio al server dataino.it il comando http
Riga 420 Altrimenti se a connessine fallisce
Riga 426 Messaggio sul terminale: fallito
Riga 431 ritorno il valore 0
Riga 439 Inizializzo il contatore ConnectLoop che controlla se fallisce l’hardware di rete
Riga 444 Ciclo wile finchè il client è connesso
Riga 450 Ciclo wile finchè il client è avviabile
Riga 456 Leggo un carattere dal client
Riga 461 Se il carattare è un “#” (carattere di inizio trasmissione dati)
Riga 467 Legggo il caratere successivo
Riga 472 Ciclo wile finchè il carattere e diverso da “*” (fine trasmissione)
Riga 477,476,477 Prima di iniziale la lettura del dato resetto le variabili che mi servono per recuperare i dati (count_val contatore dei dati trasmessi, i moltiplicatore , variabile che conterrà il valore della risposta)
Riga 485 Ciclo do wile finchè non incontro un carattere “;” divisore fra I valori
Riga 492 nella variabile response[] carico il valore del carattere letto per il moltiplicatore
Riga 493 Incremento il moltiplicatore * 10
Riga 494 Leggo un carattere
Riga 497 Se il carattere è diverso da “;” ripeto
Riga 503 Leggo un carattere
Riga 508 Se è il carattere di stop *
Riga 511 512 513 Stampo il Risultato
Riga 517 fermo il ciclo
Riga 526 incremento il contatore del numero di valori ricevuti
Riga 536 Setto a Zero se è arrivato un pacchetto
Riga 545 Incremento connectLoop se non arrivano pacchetti
Riga 554 se sono passati piu di 15000 milliseconds dall’ultimo pacchetto
Riga 561 Messaggio sul terminale: Timeout
Riga 563 Fermo il client
Riga 570 ritardo di 1 millisecondo per connectLoop
Riga 571 Messaggio sul terminale: Mi sto disconnettendo
Riga 576 Fermo il client
Riga 580 Ritorno il valoe 1 = OK il server ha risposto

Creazione grafici dei dati raccolti

Per completare il progetto Carmelo ha descritto anche l’operazione di creazione dei grafici provenienti dai dati raccolti con il suo Dataino.

Nella sezione Chart è possibile, dopo aver caricato dei dati attraverso arduino, creare dei grafici.

Dall’interfaccia:

  • seleziona il dato da visualizzare (ad es.: casa);
  • seleziona il tipo di grafico ( ad es.: line-hollow);
  • scegli il colore della linea il numero di record da visualizzare nel grafico;
  • salva con il nome “Temperatura casa”.

Grafici Dataino

Il grafico è pronto ed è disponibile nella zona pubblica DATA come pure i dati disponibili per il download in formato json, csv e xml

Grafici Dataino

Grafici Dataino Data

Buona raccolta dati !!!

Cortesemente, prima di inserire i commenti leggi il regolamento

Permanent link to this article: http://www.mauroalfieri.it/informatica/dataino-sketch-seconda-parte.html

Lascia un commento

Your email address will not be published.

This site uses Akismet to reduce spam. Learn how your comment data is processed.