ESP8266 Adafruit IoT sketch

ESP8266 Adafruit IoT sketch è finalmente l’articolo che aspettavi per capire meglio come funziona l’IoT

Adafruit Io wemos sketch

Tralascerò la parte noiosa dell’argomento: reti, comunicazioni, protocolli .. o almeno li tratterò con l’idea di farti capire come funziona senza troppi tecnicismi.

Leggerai le parti pratiche della realizzazione e configurazione dello sketch.

Il materiale necessario

La lista del Materiale per la realizzazione del progetto è davvero semplice:

una volta che avrai assemblato tutti i componenti come descritto nella parte relativa all’elettronica del progetto potrai procedere con lo sketch.

ESP8266 Adafruit IoT sketch

Prima di scrive lo sketch è necessario che ti procuri le librerie necessarie: Adafruit IO Arduino e DHT

Apri il Library Manager ( Gestore librerie dell’IDE Arduino ) e cerca “Adafruit” scorri fino alla libreria Adafruit IO Arduino e installala:

Adafruit Io wemos sketch library

poi cerca DHT e installa la “DHT

Adafruit Io wemos sketch DHT library

In questo modo sarai pronto per realizzare il tuo ESP8266 Adafruit IoT sketch.

Passiamo al codice

lo sketch si compone di due parti:

Adafruit IO Arduino sketch esemio

la prima rappresenta lo sketch vero e proprio, mentre nel secondo tab “config.h” ci andranno tutte le parti relative alla configurazione, leggerai in seguito cosa inserire.

Come avrai notato dalla schermata precedente sono partito da uno degli esempi base rilasciati con la libreria Adafruit IO Arduino.

Iniziamo dallo sketch vero e proprio:

// Adafruit IO Analog In Example
// Tutorial Link: https://learn.adafruit.com/adafruit-io-basics-analog-input
//
// Adafruit invests time and resources providing this open source code.
// Please support Adafruit and open source hardware by purchasing
// products from Adafruit!
//
// Written by Todd Treece for Adafruit Industries
// Copyright (c) 2016 Adafruit Industries
// Licensed under the MIT license.
//
// All text above must be included in any redistribution.

/************************** Configuration ***********************************/

// edit the config.h tab and enter your Adafruit IO credentials
// and any additional configuration needed for WiFi, cellular,
// or ethernet clients.
#include "config.h"
#include "DHT.h"

/************************ Example Starts Here *******************************/

#define DHTPIN 2
#define DHTTYPE    DHT22

float currentT = 0;
float currentH = 0;
float lastT = -1;
float lastH = -1;
uint32_t timerThresold = 5000;
long timer = 0;

DHT dht(DHTPIN, DHTTYPE);

// set up the 'analog' feed
AdafruitIO_Feed *analogT = io.feed("temperature");
AdafruitIO_Feed *analogH = io.feed("humidity");

void setup() {
  // start the serial connection
  Serial.begin(115200);

  // wait for serial monitor to open
  while(! Serial);

  // connect to io.adafruit.com
  Serial.println("Connecting to Adafruit IO");
  io.connect();
  
  // wait for a connection
  while(io.status() < AIO_CONNECTED) {
    Serial.print(".");
    delay(500);
  }

  // we are connected
  Serial.println();
  Serial.println(io.statusText());

  // Initialize device.
  dht.begin();
}

void loop() {

  // io.run(); is required for all sketches.
  // it should always be present at the top of your loop
  // function. it keeps the client connected to
  // io.adafruit.com, and processes any incoming data.
  io.run();

  // grab the current state of the temp
  // Delay between measurements.
  delay(timerThresold);
  
  currentT = dht.readTemperature();
  if (isnan(currentT)) {
    Serial.println(F("Error reading temperature!"));
  }
  else {
    Serial.print(F("Temperature: "));
    Serial.print(currentT);
    Serial.println(F(" °C"));
  }
  // Get humidity event and print its value.
  currentH = dht.readHumidity();
  if (isnan(currentH)) {
    Serial.println(F("Error reading humidity!"));
  }
  else {
    Serial.print(F("Humidity: "));
    Serial.print(currentH);
    Serial.println(F("%"));
  }
  

  // return if the value hasn't changed
  if((currentT != lastT && ((millis() - timer) >= timerThresold)) || 
     (currentH != lastH && ((millis() - timer) >= timerThresold))) {
    timer=millis();
    
    // save the current state to the analog feed
    Serial.print("sending -> ");
    Serial.print(currentT);
    Serial.print(" – ");
    Serial.println(currentH);
    
    analogT->save(currentT);
    analogH->save(currentH);
    
    // store last photocell state
    lastT = currentT;
    lastH = currentH;
  }
}

tralasciando la parte relativa al commento iniziale le prime linee di codice sono 019-020: in cui includi il file config.h e la libreria per il DHT22 ( DHT.h );

alle linee 024.025: definisci la variabile contenente il valore del pin a cui è connesso il sensore e il tipo di sensore della famiglia DHT;

linee 027-032: ti servono per impostare una serie di variabili il cui scopo ti sarà più chiaro nel corso della spiegazione delle linee successive;

linea 034: definisci una istanza dht della classe DHT passandole il pin a cui hai connesso il sendore ed il tipo di sensore;

Funzione Setup

linee 037-038: sono le prime linee a cui porre attenzione in quanto usando un metodo della libreria Adafruit IO definisci i due Feeds ( ossia variabili sul cloud IoT ). Il primo denominato temperature sarà quello che userai per inviare i valori di temperatura. Il secondo denominato humidity, allo stesso modo, sarà il feeds relativo ai valori di umidità rilavati.

linea 045: è una linea che ti permette di attendere che ci sia una comunicazione seriale attiva per procedere con l’esecuzione delle linee successive, tale linea andrà commentata quando metterai in produzione il tuo progetto;

linee 048-049: Scrivi sul monitor seriale la stringa “Connecting to Adafruit IO” mantre la linea 49 esegue la connessione al cloud prendendo le informazioni che avrai inserito nel file config.h che vedremo dopo.

linee 051-055: verifica con un loop ( while ) lo stato della connessione usando il metodo io.status() della libreria di Adafruit;

linea 062: inizializza la comunicazione con il sensore DHT usando il metodo begin().

Funzione Loop

la linea 071: ti serve a comunicare con il cloud Io per inviare o ricevere dati, in questo sketch invierai solo dati dallo sketch al cloud;

linea 075: imposta una pausa in modo che l’invio di dati sia cadenzato. Il valore di delay è quello che imposti nella variabile timerThresold alla linea 031 e deve essere definito seguendo le regole del cloud:

Adafruit IO rules

nel mio esempio, trattandosi di un account free il dato di cui tener conto è il primo: 30 data point per minute ossia non potrai inviare al cloud più di 30 valori al minuto.

Apro una piccola parentesi in merito a questo calcolo in quanto i 30 valori dati al minuto vanno considerati in base al numero di valori e variabili che invierai, in questo esempio invierai 2 valori alla volta: temperatura e umidità per cui il calcolo sarà

60 secondi / 30 data point * 2 variabili dati = 4 secondi

ossia puoi inviare i tuoi dati con una cadenza di 4 secondi minimo, se inviassi i valori ogni 2 secondi il cloud ti bloccherebbe dopo i primi 15 invii in quando avrai raggiunto la soglia dei 30 valori al minuto.

Nello sketch il valore di delay tra un loop ed il successivo è stato impostato a 5 secondi che garantisce di poter inviare tutto il minuto di dati senza essere bloccati dalle regole del cloud;

linea 077: recupera dal sensore il valore di temperatura ambiente;

linee 078-085: eseguono dei controlli sul valore recuperato per scrivere sul monitor seriale eventuali errori di lettura o la temperatura corrente;

linea 087: recupera il valore di umidità corrente;

linee 088-095: analogamnete alle linee 078-085 verifica che il valore recuperato sia coerente con un numero e lo visualizza sul monitor seriale.

Avrai notato che i due valori di temperatura ed umidità sono stati memorizzati in due delle variabili viste nelle prime linee: currentT e currentH.

linee 099-100: un IF con una condizione molto lunga controlla che il valore di temperatura ed umidità corrente sia differente dal precedente e che il tempo trascorso sia superiore al valore di soglia ( timerThresold ) impostato;

linea 101: reimposta il valore della variabile timer in modo che al successivo loop il tempo trascorso possa essere aggiornato e superare la soglia dei 5 secondi impostati;

linee 104-107: scrivono i valori sul monitor seriale, per aiutarti a visualizzarli nelle prime fasi di test;

linee 109-110: sono quelle designate all0invio vero e proprio dei dati al cloud e lo facco usando il metodo save messo a disposizione dalla libreria Adafruit Io;

linee 113-114: reimpostano i valori di lastT e lastH come quelli correnti in modo che al loop successivo possano essere confrontati con i nuovi valori dalle linee 099-100.

File config.h

il file config.h contiene le configurazioni necessarie a far riconoscere il tuo progetto dal cloud Adafruit, in modo che quando invii i dati essi siano associati al tuo Cloud.

Vediamo come fa:

/************************ Adafruit IO Config *******************************/

// visit io.adafruit.com if you need to create an account,
// or if you need your Adafruit IO key.
#define IO_USERNAME "[username]"
#define IO_KEY "[access key]"

/******************************* WIFI **************************************/

// the AdafruitIO_WiFi client will work with the following boards:
//   - HUZZAH ESP8266 Breakout -> https://www.adafruit.com/products/2471
//   - Feather HUZZAH ESP8266 -> https://www.adafruit.com/products/2821
//   - Feather HUZZAH ESP32 -> https://www.adafruit.com/product/3405
//   - Feather M0 WiFi -> https://www.adafruit.com/products/3010
//   - Feather WICED -> https://www.adafruit.com/products/3056
//   - Adafruit PyPortal -> https://www.adafruit.com/product/4116
//   - Adafruit Metro M4 Express AirLift Lite ->
//   https://www.adafruit.com/product/4000
//   - Adafruit AirLift Breakout -> https://www.adafruit.com/product/4201
//   - Adafruit AirLift Shield -> https://www.adafruit.com/product/4285
//   - Adafruit AirLift FeatherWing -> https://www.adafruit.com/product/4264

#define WIFI_SSID "[ssid]"
#define WIFI_PASS "[password wifi]"

// uncomment the following line if you are using airlift
// #define USE_AIRLIFT

// uncomment the following line if you are using winc1500
// #define USE_WINC1500

// uncomment the following line if you are using mrk1010 or nano 33 iot
//#define ARDUINO_SAMD_MKR1010

// comment out the following lines if you are using fona or ethernet
#include "AdafruitIO_WiFi.h"

#if defined(USE_AIRLIFT) || defined(ADAFRUIT_METRO_M4_AIRLIFT_LITE) ||         \
    defined(ADAFRUIT_PYPORTAL)
// Configure the pins used for the ESP32 connection
#if !defined(SPIWIFI_SS) // if the wifi definition isnt in the board variant
// Don't change the names of these #define's! they match the variant ones
#define SPIWIFI SPI
#define SPIWIFI_SS 10 // Chip select pin
#define NINA_ACK 9    // a.k.a BUSY or READY pin
#define NINA_RESETN 6 // Reset pin
#define NINA_GPIO0 -1 // Not connected
#endif
AdafruitIO_WiFi io(IO_USERNAME, IO_KEY, WIFI_SSID, WIFI_PASS, SPIWIFI_SS,
                   NINA_ACK, NINA_RESETN, NINA_GPIO0, &SPIWIFI);
#else
AdafruitIO_WiFi io(IO_USERNAME, IO_KEY, WIFI_SSID, WIFI_PASS);
#endif
/******************************* FONA **************************************/

// the AdafruitIO_FONA client will work with the following boards:
//   - Feather 32u4 FONA -> https://www.adafruit.com/product/3027

// uncomment the following two lines for 32u4 FONA,
// and comment out the AdafruitIO_WiFi client in the WIFI section
// #include "AdafruitIO_FONA.h"
// AdafruitIO_FONA io(IO_USERNAME, IO_KEY);

/**************************** ETHERNET ************************************/

// the AdafruitIO_Ethernet client will work with the following boards:
//   - Ethernet FeatherWing -> https://www.adafruit.com/products/3201

// uncomment the following two lines for ethernet,
// and comment out the AdafruitIO_WiFi client in the WIFI section
// #include "AdafruitIO_Ethernet.h"
// AdafruitIO_Ethernet io(IO_USERNAME, IO_KEY);

Descrizione del file

Il file è ricco di commenti ma le uniche linee che dovrai cambiare sono:

linea 05: al posto del valore di username dovrai impostare il tuo username, scelto in fase di registrazione;

linea 06: l’access key è una chiave univoca associata al tuo account che rende possibile l’associazione tra il tuo account ed i dati che gli invierai, senza questa “key” il cloud IoT di Adafruit non accetterà i tuoi dati.

Recuperare l’access key

l’access key puoi recuperarla dal tuo account AdafruitIO, accedendo al sito adafruit.io con la tua utenza:

Adafruit Io shows key

e cliccando sul simbolo della chiave in alto a destra, come indicato dalla freccia ( che ho aggiuno io per chiarezza ) vedrai una schermata simile alla seguente:

ESP8266 Adafruit Io active key

in cui sono presenti i due valori che devi inserire nel file config.h:

  • Username
  • Active Key o IO_KEY

Infine dovrai inserire nelle linee 023 e 024 i dati di accesso alla tua WiFi.

Finite queste modifiche non ti resta che eseguire l’upload dello sketch sulla tua wemos o esp8266 e testare che la connessione avvenga correttamente.

Se tutto è corretto visualizzerai sul cloud Adafruit, nella sezione relativa ai feeds i due nuovi feed temperaturehumidity :

Adafruit Io feeds

nel prossimo articolo realizzeremo insieme una dashboard che sfrutta i dati inviati per visualizzarli in modalità grafica.

Prima di inserire un commento, per favore, leggi il regolamento

Permanent link to this article: https://www.mauroalfieri.it/elettronica/esp8266-adafruit-iot-sketch.html

Lascia un commento

Your email address will not be published.

Questo sito usa Akismet per ridurre lo spam. Scopri come i tuoi dati vengono elaborati.