L’idea è quella di usare il nostro ESP8266 come lettore di sensori. Ovviamente l’esempio è puramente didattico e generico, ma con poco sforzo può essere replicato per altri sensori.

Cosa ci occorre

• una basetta ESP8266
• un cavetto micro-usb
• un sensore di umidità FC-28
• due cavetti dupont femmina-maschio (colore a piacere) per collegare da sonda a sensore
• quattro cavetti dupont femmina-maschio per collegare da sensore a ESP8266
• software Arduino (scarica qui la versione del nostro test 1.8.12)

Prepariamo l’IDE

Prepariamo prima l’ambiente di sviluppo ovvero il nostro IDE Arduino per riconoscere la scheda. Se non lo abbiamo fatto in altre esercitazioni, ci occorre aggiungere al nostro IDE la il software della scheda. Andiamo in File->Impostazioni->URL Aggiuntive per il gestore Schede e incolliamoci questo URL ufficiale e sempre aggiornato:

https://arduino.esp8266.com/stable/package_esp8266com_index.json

Selezioniamo la porta. Su linux la porta di default è la /dev/ttyUSB0. Su Windows, a second della versione che usate, potrebbe essere una tra le COM1, COM2 o la più probabile COM3. Selezionatela nella voce di menù Strumenti->Porta avendo cura di provare anche le altre se lo sketch desse errore in fasi di upload. In genere, su Windows, la porta viene riconosciuta automaticamente o compare una voce di fianco nella tendina che indica il nome del dispositivo.

Selezioniamo il dispositivo, ovvero scheda, corretto. Qui ci sono due possibilità: o usiamo la versione ESP8266 nuda e creda che fa uso di una architettura GPIO per la numerazione dei pin oppure ricorriamo ad una semplificazione con scheda NodeMCU 1.0 (ESP12E-Module) che nomina i pin con le lettere che sono stampate direttamente sulla basetta. Lasciamo ad altri post la spiegazione, vantaggi e svantaggi dei due approcci.

Per la nostra esperienza ci basta configurare al meglio il tutto in modo semplice. Usate la voce di menù sull’IDE Strumenti->Scheda e cercate nella tendina la voce indicata NodeMCU 1.0 (ESP12E-Module). Notiamo che alcune librererie aggiuntive sono spesso scritte per ragionare con la scheda ESP8266, altre volte con la NodeMCU: il discrimine si evidenzia in fase di compilazione poiché avremo un errore sul nome utilizzato per pilotare i pin. Se tra le schede non compare il nome indicato, niente paura, dobbiamo aggiungerlo da libreria. Andate quindi  Strumenti->Scheda->Gestore Schede e nella finestrella in alto a destra cercate ESP8266, vi comparirà un risultato ESP8266 by ESP8266 Community che, mentre scriviamo, è arrivata alla versione 2.6.3.

In Strumenti->Gestione librerie assicuriamoci che sia installata la libreria che ci fornisce funzioni e strumenti vari per gestire le connessioni senza fili. Scorrete la lista fino a trovare WiFi built-in Arduino, giunto alla versione 1.2.7. Stessa cosa, cercate ed installate Arduino Uno WiFi Dev ed by Arduino.

Assemblaggio

L’assemblaggio è molto semplice, non richiede particolari abilità manuali o in campo elettronico. La maggior parte dei sensori in commercio hanno quattro pin: due son oda collegare all’alimentazione VCC 3.3 ed uno al G/GND per l’alimentazione. I dati possono poi essere mandati in formato analogico mentre il pin digitale serve semplicemente a rilevare se la misurazione è o no al di sopra del valore di “threshold”, il valore limite di soglia che può essere regolato con il potenziometro, ovvero la vitarella sul sensore. Dati dei sensori è sempre bene acquisirli in modo analogico, quindi assicuriamoci di collegare il pin A0 sul sensore al pin A0 o simile sul nostro ESP8266. Collegarne tre o quattro, sia lettura analogica che digitale, non pregiudica la misurazione.

Il codice

Il codice per la gestione del sensore è piuttosto banale. Eseguiamo una lettura analogica con la funzione standard dedicata. Il valore senza umidità tornato è 1024,00, mentre mano a mano che si inumidisce la sonda, ad esempio con una spugna o immergendo in un terriccio umido, il valore letto diminuisce. Le letture possono quindi essere ripetute periodicamente scegliendo un intervallo di ritardo. Stampiamo sull’interfaccia seriale il valore letto. Manteniamo semplice il nostro esercizio con un solo sensore, ma facciamo mente locale alle potenzialità degli 8 pin digitali e 1 analogico. L’analogico è dotato di un convertitore ADC a 10bit con valori a decimali a due cifre e parte intera compresa tra 0 e 1023 che può essere multiplexato per ricevere segnali da svariati sensori (ne accendo/invio uno alla volta, per capirci)

float value = 0;

void setup() {
pinMode(A0, INPUT); 

Serial.begin(9600);
}

void loop() {
value = analogRead(A0);
Serial.print("Umidità rilevata= ");
Serial.println(value);  
delay(5000); //ogni 5 secondi fai una misurazione
}

Le funzionalità di rete

Siamo pronti ora a vedere come scrivere questi dati catturati su un database. ESP8266 non scrive pagine PHP, ma può sempre collegarsi ad una pagina PHP esistente su qualche dominio esterno e mandargli dei dati col GET nell’URL o POST. I dati possono essere sotto forma di semplici parametri, o addirittura stringhe JSON, molto utili se alla ESP ci fossero collegati sensori multipli.

Sensore -> ESP8266 -> Access Point/Router -> Sito in Hosting con Apache -> pagina  in PHP raccogli dati GET/POST -> Database MySQL -> esposizione dati JSON con PHP

Per questo esercizio predispongo gli script PHP e il database qui sul dominio che ospita questo sito web. Potete trovare in rete numerosi servizi gratuiti che mettono a disposizione un server Apache con PHP e un db MySQL. Su quest’ultimo creiamo una tabella dove andremo a raccogliere i dati del sensore. La struttura, al momento semplice e autodescrittiva, potrebbe essere simile a questa:

CREATE TABLE IF NOT EXISTS `Sensore` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `nome` varchar(60) NOT NULL,
  `valore` float NOT NULL,
  `lettura` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP,
  PRIMARY KEY (`id`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1 AUTO_INCREMENT=1 ;

Nel campo nome inseriremo un identificativo del sensore, il valore che ha inviato ed in automatico stacchiamo un valore progressivo come chiave della tabella e la data/ora automatica in cui è stato inserito il record.

Occupiamoci ora del nostro codice sulla basetta ESP8266. Creiamo un nuovo scketch nel nostro Arduino IDE. Ci servono prima un po’ di librerie e qui andiamo ad utilizzare quelle standard ESP8266 con i primi include. Come in tutte le esperienze  con funzionalità di rete/WiFi, ci andiamo ad impostare due stringhe con SSID e password del nostro Access Point o modem di casa. Ci serviranno poi una variabile reale per gestire i valori del sensore e una variabile stringa dove possiamo inserire un nome identificativo del sensore.

#include <ESP8266WiFi.h>
#include <ESP8266HTTPClient.h>

float value = 0;

String ssid     = "SSIDdellaTUArete";
String password = "PASSWORDdellaTUArete";
String nomesensore = "FC28"; 

Il secondo frammento è quello del setup dove andiamo a predisporre il sensore e il suo pin seria, la console seriale per la stampa dei messaggi di debug (che vi ricordo si apre col menu Strumenti->Monitor seriale e si imposta la medesima velocità/banda in fondo del valore del codice qui sotto). Segue quindi la connessione effettiva alla rete Wi-Fi con tanto di configurazione/IP fisso. Se usate il DHCP, potete eliminare o commentare le righe IPAddress* e WiFi.config.

void setup() 
{
  //GESTIONE PIN
  pinMode(A0, INPUT); 

  //GESTIONE MONITOR SERIALE
  Serial.begin(115200);

  //GESTIONE WI-FI
  IPAddress ip(192, 168, 1, 108); 
  IPAddress gateway(192, 168, 1, 1); 
  IPAddress subnet(255, 255, 255, 0); 
  WiFi.config(ip, gateway, subnet);

  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) 
  {
    delay(500);
    Serial.print(".");
  }
  Serial.println("Sei collegato alla rete LAN");
  Serial.println(WiFi.localIP());
}

Non ci rimane che creare il nostro codice principale che a loop leggerà il sensore e predisporrà un URL per raggiungere una pagina PHP e consegnargli quindi i dati letti. Nel nostro caso la pagina si trova su questo dominio e la chiameremo soilmoisture.php. Inserite l’url del dominio che ospita il file. Il codice per inviare l’URL è piuttosto semplici ed intuitivo, utilizzando le funzioni messeci a disposizione dalle librerie. Ci colleghiamo ad una pagina, gli inviamo un header che sia un GET, un POST o JSON, qui un POST da form simulato e quindi  si preparano i dati da inviare come un URL con GET

  HTTPClient http;
  http.begin("https://www.unsito.it/soilmoisture.php"); //l'URL HTTP a cui ci collegheremo
  http.addHeader("Content-Type", "application/x-www-form-urlencoded"); 
  String httpPost = "sensore=" + nomesensore
                  + "&valore=" + String(value)

 Inviare i dati appena costruiti allo script è semplicissimo e la stessa chiamata restituisce una risposta con il classico valore 200 se positivo, o uno della serie 300, 400, 500 per errori vari  o -1 se la connessione non si innesca.

  int httpResponse = http.POST(httpPost);

La risposta e il payload può essere usata per debug. Sicuramente se httpResponse dovesse essere -1, allora ci troviamo davanti ad un bel problema che la nostra basetta non raggiunge la pagina per problemi di rete o un link sballalo.

Il codice completo:

#include <ESP8266WiFi.h>
#include <ESP8266HTTPClient.h>

float value = 0;

String ssid     = "SSIDdellaTUArete";
String password = "PASSWORDdellaTUArete";
String nomesensore = "FC28"; 

void setup() 
{
  //GESTIONE PIN
  pinMode(A0, INPUT); 

  //GESTIONE MONITOR SERIALE
  Serial.begin(115200);

  //GESTIONE WI-FI
  IPAddress ip(192, 168, 1, 108); 
  IPAddress gateway(192, 168, 1, 1); 
  IPAddress subnet(255, 255, 255, 0); 
  WiFi.config(ip, gateway, subnet);

  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) 
  {
    delay(500);
    Serial.print(".");
  }
  Serial.println("Sei collegato alla rete LAN");
  Serial.println(WiFi.localIP());
}

void loop() 
{
  //LETTURA SENSORE
  value = analogRead(A0);
  Serial.print("Umidità rilevata= ");
  Serial.println(value);  

  //PREPRAZIONE URL
  HTTPClient http;
  
  //l'URL HTTP a cui ci collegheremo
  http.begin("https://www.unsito.it/soilmoisture.php"); 
  http.addHeader("Content-Type", "application/x-www-form-urlencoded"); 
    
  //Aggiungo le variabili da passare col POST
  String httpPost = "sensore=" + nomesensore
               + "&valore=" + String(value)
               +"";
  Serial.print("HTTP Post: ");
  Serial.println(httpPost);
  

  // Invia richiesta HTTP POST
  int httpResponse = http.POST(httpPost);

  //Feedback del server per debug
  String payload = http.getString();  
  Serial.print("Risposta Server: ");
  Serial.println(httpResponse);
  Serial.print("Payload: ");
  Serial.println(payload);  

  delay(1000 * 60); //ogni minuto fai una misurazione
}

La pagina PHP

Lo script PHP in realtà non ha nulla di particolare per il lettore appassionato di queste pagine. Si tratta di uno script che riceve i dati $_POST e li elabora per inserirli con una query su db. Vediamo qui sotto un esempio. Il file config.php contiene le variabili da inizializzare e passare al db per la connessione.

<?php
require_once("config.php");

if (isset($_POST['sensore']) && isset($_POST['valore']))
{
	$sensore     = $_POST['sensore'];
	$valore      = $_POST['valore']; 
	$connessione = mysqli_connect($mysql_host,$mysql_user,$mysql_pass,$mysql_db);
	if (mysqli_connect_errno())
	die("Connessione non riuscita: " . mysqli_error($connessione));
  
  	$query = "INSERT INTO Sensore (id, nome, valore, lettura) VALUES (null, $sensore, $valore,CURRENT_TIMESTAMP)";
	$res = mysqli_query($connessione,$query) or die("Errore nella query: " . mysqli_error($connessione));
	mysqli_close($connessione); 

}
else
	echo "Script invocato senza parametri POST";

?>

Come migliorare il nostro applicativo

• Scritti i dati su un database, il lettore può graficarli con la più classica delle pagine PHP/HTML/CSS, oppure semplicemente esporli in formato JSON per renderli disponibili per altri applicativi web o app mobile.
• Un dettaglio di cui non abbiamo tenuto conto in questa guida è l’uso del protocollo HTTPS basato su TLS. Questa considerazione ci obbliga a modificare il codice per aggiungere un certificato una impronta del sito a cui ci colleghiamo per permettere alla basetta di creare una connessione sicura.
• Abbiamo scartato l’invio dei dati col GET ma applicazione più interessante potrebbe essere quella di mandare alla pagina PHP i dati sono forma di JSON, decisamente utile nel caso si debbano inviare oggetti complessi e multipli e soprattutto se dobbiamo inviare dati a sistemi strutturati di cui abbiamo delle specifiche API in tal senso.

L'articolo Inviare dati da un sensore di umidità del suolo ad un db con ESP8266 proviene da alfredocentinaro.it.

La guida è sperimentata su Ubuntu Studio 18.10 perfettamente aggiornata. Su Windows gli stessi passaggi sono decisamente più complessi. Se non volete installare linux in una virtual box, potete sempre munirvi di un dvd o penna usb da lanciare al volo. La basetta scelta è una WeMos D1 con chip EPS8266 perfettamente compatibile.

Prima di tutto dobbiamo caricare il firmware su misura. Per farlo occorre un tool molto semplice denominato ESPTOOL che su Linux è facilmente installabile con

sudo pip install esptool

Dovrebbe tranquillamente girare con Python 2.7 e 3

Attacchiamo il nostro ESP8266 col cavetto microusb e liberiamo prima la memoria col comando

esptool.py --port /dev/ttyUSB0 erase_flash

Se la porta ttUSB0 da errore probabilmente ne sta usando un’altra. Proviamo ad aprire Arduino, selezioniamo la nostra basetta ESP8266/WeMOS e controlliamo che porte ha individuato i lsoftware.

Preleviamo il nuovo firmware. Io preferisco prendere la versione stable, tranquilla e sicura per i nostri test. La potete trovare al seguente link, nella porte più alta con tanto di scritta “latest” di fianco. Mentre scriviamo siamo alla versione 1.11

http://micropython.org/download#esp8266

Una volta scaricato i lfile .bin carichiamolo col nostro tool con un comando simile a questo dove avrete cura di sostituire il percorso per raggiungere il file o aprendo una shell direttamente nella cartella del download.

esptool.py –port /dev/ttyUSB0 –baud 460800 write_flash –flash_size=detect 0 ../Scaricati/esp8266-20190529-v1.11.bin

Possiamo connetterci finalmente alla nostra basetta con un collegamento seriale. Installiamo sulla nostra distribuzione:

sudo aptitude install picocom o sudo apt-get install picocom 

Ci basta digitare il comando in una shell con tanto di banda di scambio e siamo subito online

picocom /dev/ttyUSB0 -b115200

 Potete inserire codice come nelle normali shell python, ma probabilmente volete inserire script con copia/incolla. Usate CTRL-e e incollate col tasto destro. Occhio agli spazi e righe vuote che vengono mal digeriti dall’interprete. Vi suggerisco di scrivere il vostro codice su IDLE o altro IDE Python sul vostro pc e inserirlo successivamente sulla basetta così da avere un debug, sintassi colorata e tutti gli aiuti che non avrete a digitare il codice secco sulla shell python appena aperta sul basetta. Il nostro primo esempio è un classico: far lampeggiare il led integrato. Il codice è abbastanza intuitivo rispetto alla versione C/C++.

import time
import machine
pin = machine.Pin(2, machine.Pin.OUT)
while True:
	pin.off()
	time.sleep(1)
	pin.on()
	time.sleep(1)

Possiamo sempre annullare il codice e il nostro ciclo con un CTRL-c, ed ovviamente la basetta smetterà di lampeggiare.

Se vogliamo uscire e tornare alla shell usiamo in rapida successione CTRL-a e CTRL-q 

L'articolo MicroPython su ESP8266 proviene da alfredocentinaro.it.

 Quella della stazione meteo è una esperienza relativamente molto semplice per approcciarsi al mondo dei micro-controllori come Arduino. In questo caso però abbiamo bisogno di gestire anche dati in rete, quindi ci affidiamo alla basetta ESP8266 per raggiungere il nostro scopo.

Cosa ci occorre

– una basetta EPS8266. Se ne trovano a 6/7 euro su Amazon e una manciata di euro in meno su Aliexpress e Wish.  Fate attenzione se ha o meno i piedini dei pin già saldati o meno, nel caso ovviamente non siate in grado di fare con facilità saldature a stagno. Nelle foto viene usata una basetta di marca Amica v2, reperibile su un noto negozio di Amazon, molto affidabile e con pin già assemblati.

– Una breadboard. In foto c’è la versione ridotta da 400 buchi, ma la classica da 830 va benissimo, non occorre molto spazio.

– Un sensore BME/BPM 280. Costa approssimativamente 7/10 euro, lo trovate su Amazon e le solite app “cinesi”. Ho scelto questo sensore per la versatilità di misurazioni che effettua e la precisione discreta. L’alternativa sarebbe quella di acquistare tre sensori singoli per effettuare le stesse misurazioni. Rassegnatevi all’ide di dover saldare i 4 pin necessari, sensori così piccoli, difficilmente vengono venduti già saldati. Esistono anche BME e BMP separati: il secondo è più economico perché triangola l’umidità da tempertura e pressione, il primo la misura direttamente.

– Un display OLED. In commercio ce ne sono diversi, il più diffuso è lo SSD1306, semplice da utilizzare e con molte librerie, documentazione ed esempi già preconfezionati. Qui usiamo invece un più economico monocromatico e retroilluminato SH1106.

– 8 cavetti per breadboard maschio/maschio.

 L’alternativa è quella di comprare un kit con i componenti necessari già raccolti in una scatoletta con istruzioni magari cartacee o online. Di questi kit se ne trovano sempre più spesso come elementi educativi per la IoT. Occhio però che spesso sono inseriti sensori o componenti non perfettamente rispondenti alle specifiche ma vengono venduti secondo disponibilità e anche le istruzioni possono essere scritte in cinese o con siti web non di facile utilizzo.

Prepariamo l’IDE

Prepariamo prima l’ambiente di sviluppo ovvero il nostro IDE Arduino per riconoscere la scheda.

Selezioniamo la porta. Su linux la porta di default è la /dev/ttyUSB0. Su Windows, a second della versione che usate, potrebbe essere una tra le COM1, COM2 o la più probabile COM3. Selezionatela nella voce di menù Strumenti->Porta avendo cura di provare anche le altre se lo sketch desse errore in fasi di upload. In genere, su Windows, la porta viene riconosciuta automaticamente o compare una voce di fianco nella tendina che indica il nome del dispositivo.

Selezioniamo il dispositivo, ovvero scheda, corretto. Qui ci sono due possibilità: o usiamo la versione ESP8266 nuda e creda che fa uso di una architettura GPIO per la numerazione dei pin oppure ricorriamo ad una semplificazione con scheda NodeMCU 1.0 (ESP12E-Module) che nomina i pin con le lettere che sono stampate direttamente sulla basetta. Lasciamo ad altri post la spiegazione, vantaggi e svantaggi dei due approcci.

Per la nostra esperienza ci basta configurare al meglio il tutto in modo semplice. Usate la voce di menù sull’IDE Strumenti->Scheda e cercate nella tendina la voce indicata NodeMCU 1.0 (ESP12E-Module). Notiamo che alcune librerie aggiuntive sono spesso scritte per ragionare con la scheda ESP8266, altre volte con la NodeMCU: il discrimine si evidenzia in fase di compilazione poiché avremo un errore sul nome utilizzato per pilotare i pin. Se tra le schede non compare il nome indicato, niente paura, dobbiamo aggiungerlo da libreria. Andate quindi  Strumenti->Scheda->Gestore Schede e nella finestrella in alto a destra cercate ESP8266, vi comparirà un risultato ESP8266 by ESP8266 Community che, mentre scriviamo, è arrivata alla versione 2.6.3.

Assemblaggio

L’assemblaggio è piuttosto semplice. Inseriamo lo ESP8266 al centro della nostra breadboard. Cerchiamo di lasciare una o due file di buchi sul lato dei pin digitali D, dove andremo ad inserire i cavetti necessari. In foto vedete che le file a e b della breadboard sono lasciate libere mentre la scheda è schiacciata immediatamente sopra.

Colleghiamo poi l’alimentazione 3v3 (sulla breadboard A10 e B10 ) ai poli VCC e VIN dello schermo e del sensore. In foto i cavetti sono rossi. Stesso lavoro con i cavetti neri che vanno da GND della basetta (in foro A9 e B9) ai GND di sensore e schermo. Con i cavetti arancioni colleghiamo il pin D1 ai pin SCL di scheda e monitor, mentre con i cavetti verdi il pin D2 coni pin SDA dei due componenti. I colori dei cavetti sono a titolo esemplificativo per meglio “leggere” la nostra basetta di prova.

Tensione e terra potevano essere presi anche dal l’altro lato del nostro ESP8266. I componenti sono scelti appositamente con interfaccia IIC che minimizza il numero di collegamenti da  effettuare. Occhio se volete fare  la stessa esperienza su Arduino i pin standard sono i pin analogici A5 e A4, che qui su ESP vengono rimappati in modo un po’ caotico sui citati D1 e D2.

 Uno schema di massima realizzato con fritzing

Il codice

Per questo esperimento abbiamo deciso di scrivere il codice in c/c++ sfruttando gli esempi forniti dai manutentori delle librerie che stiamo andando ad utilizzare. Esistono codici esistenti per diverse tipologie di stazioni meteo analoghe alla nostra, ma nessuna che sfrutti le stesse componenti, ma si può far tesoro di quanto esistente e assemblarlo per i nostri scopi. Vediamo frammento per frammento cosa scrivere e perché. Tra le librerie, tralasciando le prime due standard, aggiungiamo la U8x8lib per il monitor e le adafruit per gestire il sensore. Dichiariamo globalmente la variabile bme del sensore e la u8x8 per lo schermo. I valori dello schermo sono presi da un elenco di tutti i monito compatibili con i nostri arduino. La define è suggerita dal manuale del sensore per impostare lo “zero” del sensore in riferimento al livello del mare. outstr è invece un buffer testuale che useremo più avanti.

#include <Wire.h>
#include <Arduino.h>

#include <U8x8lib.h>

#include <Adafruit_Sensor.h>
#include <Adafruit_BME280.h>


#define SEALEVELPRESSURE_HPA (1013.25)

U8X8_SH1106_128X64_NONAME_HW_I2C u8x8(/* reset=*/ U8X8_PIN_NONE);
Adafruit_BME280 bme; // I2C

static char outstr[8];

Il setup del nostro software. Prima cosa da fare accendiamo/prepariamo il nostro schermo, quindi andiamo a sincronizzare il monitor seriale. Nel terzo blocco, controlliamo che il sensore sia attivo e diamo una serie di messaggi di errore che potete trovare tra gli esempi forniti dal produttore.

void setup() 
{
    u8x8.begin();
    u8x8.setPowerSave(0);
  
    Serial.begin(9600);
    while(!Serial);    // time to get serial running
    Serial.println(F("BME280 test"));

    unsigned status;
    
    status = bme.begin();  
    if (!status) {
        Serial.println("Non è stato trovato un sensore BME280 valido, controlla i filamenti, pin, modello del sensore!");
        Serial.print("SensorID è: 0x"); 
        Serial.println(bme.sensorID(),16);
        Serial.print("        ID di 0xFF probabilmente significa che il chip sia a BMP 180 o BMP 085\n");
        Serial.print("   ID 0x56-0x58 è il codice di un BMP 280,\n");
        Serial.print("        ID 0x60 è il codice di un BME 280.\n");
        Serial.print("        ID 0x61 è il codice di un BME 680.\n");
        while (1);
    }
}

Veniamo al loop. E’ molto semplice in quanto richiamiamo due semplici funzioni senza parametri che si limitano a leggere e stampare a video o console i valori. Un piccolo ritardo di un secondo per ripetere le misurazioni e stampe in tempi idonei.

void loop() 
{ 
   printSerialValues();
   printOLEDValues();

   delay(1000);
  
}

Vediamo finalmente la funzioncina che si occupa di scrivere sullo schermo. Il funzionamento è spartano ma efficace: si sceglie un font e si scrive un testo fornendo come parametro le coordinate x,y da dove si vuole far cominciare il testo. La coordinata (0,0) rappresenta il bordo in alto a sinistra.

Nel nostro codice non scriviamo solo testo ma anche i valori numerici in virgola. In c purtroppo le cose non sono esattamente agevoli ed abbiamo bisogno di una funzione che ci converta in modo spartano il numero in stringa e qui ci aiuta la dtostrf che prende una variabile decimale float, il numero totale di cifre da stampare della stessa e quante sono le cifre decimali, infine la variabile di buffer testuale su cui scrivere il valore desiderato da stampare.

dtostrf(float name, #digits, #decimalplaces, save it to buffer);

E’ relativamente semplice prelevare i valori dall’oggetto bme che ci siamo dichiarati globalmente.

void printOLEDValues() 
{
  u8x8.setFont(u8x8_font_chroma48medium8_r);
  u8x8.clearDisplay();
  u8x8.drawString(0,0,"Temp= ");
  //dtostrf(float name, #digits, #decimalplaces, save it to buffer);
  u8x8.drawString(6,0,dtostrf(bme.readTemperature(),3,1,outstr));
  u8x8.drawString(10,0," *C");

  u8x8.drawString(0,1,"BAR= ");
  u8x8.drawString(6,1,dtostrf(bme.readPressure() / 100.0F,3,1,outstr));
  u8x8.drawString(10,1," hPa");

  u8x8.drawString(0,2,"Altezza= ");
  u8x8.drawString(8,2,dtostrf(bme.readAltitude(SEALEVELPRESSURE_HPA),4,0,outstr));
  u8x8.drawString(12,2," m");

  u8x8.drawString(0,3,"Umidita'= ");
  u8x8.drawString(9,3,dtostrf(bme.readHumidity(),3,1,outstr));
  u8x8.drawString(13,3,"%");
    
  u8x8.refreshDisplay();    //solo per SSD1606/7  
}

La stampa sulla console seriale, non è obbligatoria, ma è sempre bene utilizzarla per testare i nostri sketch. Vi ricordo che potete aprila da Strumenti->Monitor seriale.

void printSerialValues() 
{
    Serial.print("Temperatura = ");
    Serial.print(bme.readTemperature());
    Serial.println(" *C");

    Serial.print("PRessione = ");

    Serial.print(bme.readPressure() / 100.0F);
    Serial.println(" hPa");

    Serial.print("Altitudine approssimata = ");
    Serial.print(bme.readAltitude(SEALEVELPRESSURE_HPA));
    Serial.println(" m");

    Serial.print("Umidità = ");
    Serial.print(bme.readHumidity());
    Serial.println(" %");

    Serial.println();
}

L'articolo Una stazione meteo con ESP8266, sensore BME280 e schermo OLED SH1106 proviene da alfredocentinaro.it.