ESP01 (8266)- Termometro WiFi – it

Nello scorso articolo abbiamo visto come collegare il modulo ESP-01 ad Arduino UNO, DUE e convertitore USB <–> TTL. Dopodichè abbiamo visto come utilizzare i comandi AT per provare il firmware di default e creare sia un server che un client su rete WiFi. Abbiamo accennato al fatto che i comandi AT benchè utili per i primi test non sarebbero stati con noi a lungo per la complessità di gestione da parte di Arduino. Inoltre vi avevo accennato che è stato fatto il porting per i moduli ESP dell’ambiente di programmazione Wiring a cui siete stati abituati in quanto utilizzato dall’IDE di Arduino. L’utilizzo di questo ambiente ci permette di muoverci in qualcosa di famigliare che dobbiamo solo adattare alla specifica scheda e vedrete che è la strada migliore per cominciare a sviluppare i nostri progetti con questo meraviglioso modulo.

Colleghiamo il modulo

Beh, la scorsa volta abbiamo descritto in maniera molto dettagliata le possibili vie di collegamento di questo modulo e relative problematiche per cui vi rimando al precedente articolo e per semplicità vi ripropongo l’immagine con la piedinatura. Se vogliamo programmare in ambiente Wiring, ogni volta che riprogrammiamo il modulo ne modifichiamo il firmware e la scorsa volta avevamo accennato al fatto che ciò comporta alcune difficoltà aggiuntive. La prima cosa da fare, oltre a quanto già dettto, è collegare il pin GPIO0 a massa. Facendo ciò una volta alimentato il modulo, questo entrerà in “modalità programmazione” per cui sarà possibile sostituire il firmware con quello che di volta in volta abbiamo preparato. Va da se che una volta fatta la programmazione dobbiamo disconnettere questo pin dalla massa per ripristinare il normale funzionamento, tenete conto che anche togliendo questo pin da massa, la “modalità programmazione” resta attiva finchè non avviene un reset del modulo. Questo vi spiega perchè in rete trovate un sacco di tutorial in cui viene preparato un circuitino minimale per la programmazione del modulo.

Qui sotto vi riporto una figura che mostra in maniera molto semplice i collegamenti da fare. Fate ovviamente attenzione al BJT in vostro possesso dato che non è escluso che base, collettore ed emettitore siano disposti allo stesso modo. Ovviamente se anzichè Arduino UNO utilizzate una scheda a 3.3V non occorrerà il bjt ma potrete fare un collegamento diretto fra il pin rx del modulo ed il pin di Arduino che sarà l’rx nel caso di Arduino UNO o il tx in caso di convertitori usb <–> ttl o porte hardware secondarie come su Arduino DUE (e tutto spiegato nel precedente articolo).

E qui di seguito vi riporto un più professionale schema elettronico:

Prepariamo l’IDE

La seconda cosa da fare è preparare l’IDE di Arduino andando a scaricare l’ambiente Wiring per i moduli ESP. Per farlo andate su File -> Impostazioni. Vi troverete una finestra simile a quella qui sotto:

Come potete notare vi ho evidenziato con un cerchio rosso la voce “URL aggiuntive per il gestore schede”, nel cui campo dovrete scrivere:

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

Ora andate su strumenti->Scheda->Gestore shede come nella figura qui sotto.

Ora nella finestra del gestore scorrete fino a trovare la voce ESP, premeteci sopra e premete sul pulsante di installazione che nel frattempo sarà comparso.

A questo punto dovrete avere unl po’ di pazienza perchè deve essere scaricato tutto il necessario per programmare questi moduli in ambiente Wiring e rendere perciò la programmazione molto similare a quella a cui siamo abituati con Arduino. Non appena l’installazione sarà completata, nella lista delle schede troverete tutta una serie di nuovi  prodotti basati sull’esp8266. Eh già, perchè non esiste solamente il modulo che stiamo provando, ci sono tutta una serie di schede, alcune molto interessanti e di cui parleremo in futuro, che sono simili ad Arduino in quanto contengono tutto il necessario per l’uso “standalone” come la sezione per l’alimentazione, programmazione e connessione USB il tutto programmabile con l’IDE di Arduino e con caratteristiche di memoria e velocità che non sono nemmeno lontanamente paragonabili a quelle di Arduino UNO.

ESP8266

Si ne abbiamo già parlato, è il piccolo chip che si trova sul nostro modulo ESP-01 e che equipaggia anche le altre schede della famiglia. Ma che caratteristiche ha?

• Processore 32bit – 80MHz
• 64K di memoria per la programmazione, 96K di RAM
• Connettività WiFi
• 16 GPIO
• 10 bit ADC

Queste sono solo alcune delle caratteristiche principali ma sono sufficienti a farci capire che ci troviamo di fronte ad un vero e proprio piccolo mostro di potenza. Ora facciamoci una domanda. Se il modulo ESP-01 è una controparte similare ad Arduino, perchè sono indicati 16 GPIO (pin generici di input / output) mentre sul modulo ne abbiamo solo due? Semplice, i restanti non sono collegati, ma altri moduli / schede permettono di sfruttare al 100% questo chip dando accesso a tutti i pin. In via teorica potreste anche saldare direttamente un filo ai vari pin, ma sono talmente piccoli che vi sfido a riuscirci. L’altra domanda che possiamo farci è: ma se abbiamo 2 pin GPIO possiamo programmarli a nostro piacimento? Ebbene si! Ora pensate un attimo. Potremmo usare uno dei due pin per connetterci ad un sensore di temperatura e l’altro ad un relè. Possiamo così creare un semplice termostato che funziona in maniera del tutto indipendente da Arduino, bastano due batterie per alimentarlo, inoltre avendo connettività WiFi può essere controllato direttamente attraverso la rete domestica. Che ne dite? Non è perciò obbligatorio interfacciarci con Arduino, per tutte quelle applicazioni che non necessitano di più di due pin, possiamo tranquillamente usare il modulo Esp-01 da solo, senza ausigli esterni.

Il primo test

Per cominciare cercherò di fare qualcosa di molto semplice., senza hardware aggiuntivo. Ci limiteremo ad usare uno dei pin digitali per emettere un segnale alternato acceso / spento che andrò ad analizzare con l’oscilloscopio. Niente di particolarmente entusiasmante, ma ci farà capire se quel che stiamo facendo funziona. Ovviamente potete anche fare la stessa cosa con un semplice led, non dimenticatevi però il resistore. Allora, avete fatto i collegamenti? Vi siete ricordati di collegare il GPIO0 a massa? Bene allora copiamo questo banale listato sull’IDE di Arduino.

void setup() 
{
  pinMode(2, OUTPUT);
}
void loop() 
{
  digitalWrite(2, HIGH);    // livello logico alto
  delay(1000);              // attende un secondo
  digitalWrite(2, LOW);     // il livello logico basso
  delay(1000);              // attende un secondo
}

Ora nella scelta della scheda utilizzate “Generic ESP8266” ed operate come fareste con un qualunque Arduino. Una volta lanciata la compilazione verrà inviato il nuovo firmware al modulo e tutto dovrebbe funzionare al primo colpo. Io non ho avuto nessun problema, l’unica cosa che ho notato è che ci mette un po’ più tempo rispetto ad Arduino UNO sia nella compilazione che nell’invio del firmware. A questo punto staccate l’alimentazione, scollegate il GPIO0 da massa e siete pronti per provare se tutto funziona come deve. Il listato sopra è banale, non fa altro che settare l’uscita 2 come output digitale e manda l’uscita stessa continuamente a livello prima alto e poi basso ogni secondo. Funzionerà? Ricolleghiamo l’alimentazione e…..

Come potete osservare il risultato è stato quello voluto con l’uscita 2 che passa repentinamente dal livello alto a quello basso e viceversa ogni secondo.

Il primo progetto e nuovi problemi…

Per questo primo progetto rispolveriamo una vecchia conoscenza, il sensore DS18b20 che abbiamo utilizzato in numerose occasioni. Il progetto è estremamente semplice. Colleghiamo uno di questi sensori al nostro ESP in modo che possa leggere la temperatura ambiente. Dall’altra parte sfrutteremo le possibilità di collegarsi alla rete WiFi per operare come piccolo server locale che mostra la temperatura letta su una rudimentale pagina web. 

Non pensiate, questa volta non è andato tutto dritto al primo colpo. Il listato che vedremo a breve non funzionava per cui ho fatto un passo indietro ed ho usato l’esempio incluso “WifiScan” per accertarmi che il modulo vedesse la rete WiFi. Sorpresa delle sorprese il software mi rispondeva sempre con “no networks found” per cui non solo non vedeva la mia rete, ma nemmeno nessuna altra rete quasi il WiFi fosse spento. Ho fatto varie prove, sia modifiche software che utilizzo del convertitore usb <–> ttl o dell’alimentazione esterna per cercare di individuare il problema, per poi scoprire che se collegavo il pin CH_PD alla 3.3V non in contemporanea alla VCC ma poco dopo, il software funzionava e “vedeva” correttamente la rete. Verrebbe da pensare possa esserci un problema hardware, ma non facciamoci ingannare perchè la stessa configurazione con il firmware originale (comandi AT) funzionava perfettamente per cui è plausibile che ci sia qualche problema software nell’inizializzazione del chip, problema che può essere bypassato (teoricamente, non ho provato) attivando il CH_PD con un certo ritardo tramite un filtro RC , oppure utilizzando un pin digitale di Arduino (ma in questo caso verrebbe meno l’indipendenza del modulo e non potremmo fare lo stesso con il modulo TTL). Cercando in rete direi che il problema che ho riscontrato è talmente diffuso da chiedermi se a qualcuno ha funzionato davvero, inoltre non ho trovato nessuno che abbia notato che l’attivazione tardiva del CH_PD è in grado di attivare correttamente l’ESP-01. Anche se per ora lo tralasceremo, sono riuscito a rintracciare il problema solo attivando il debug del modulo che mi ha portato a scovare le informazioni di cui necessitavo. Questo utente in questa pagina suggerisce la soluzione che ora vi riporterò e che dopo due giorni di intensi test mi ha rallegrato la giornata con qualcosa di realmente funzionante.

L’errore nasce da una libreria interna del modulo che si chiama libphy.a e che fa parte dell’SDK rilasciato dalla Espressif, l’azienda che produce i chip del modulo ESP-01. A quanto pare il porting Wiring per Arduino si basa sulla versione 1.5.3 mentre è disponibile sul sito Espessif la più aggiornata versione 2.0.0. che vi dovrete scaricare (il file si chiama ESP8266 NONOS SDK V2.0.0 20160810). A questo punto dovete sostituire il file libphy.a della versione presente nell’IDE di Arduino con quella appena scaricata. La prima si trova in C:\Users\[user]\AppData\Local\Arduino15\packages\esp8266\hardware\esp8266\2.3.0\tools\sdk\lib\libphy.a (ovviamente sul vostro sistema potrebbero esserci delle differenze nel percorso), mentre la seconda la trovate in ESP8266_NONOS_SDK\lib\libphy.a nella cartella che avete scaricato e scompattato. Nel mio caso la sostituzione di quel file ha fatto si che, dopo la ricompilazione e reinvio al modulo, all’avvio successivo è stata subito vista la rete wifi, cosa che prima non accadeva. In definitiva se anche voi siete afflitti dallo stesso problema qui avete la soluzione senza passare giorni interi a cercare improbabili soluzioni.

…e finalmente

Vi dico subito che a parte i problemi di funzionamento vero e proprio che mi hanno fatto perdere alcuni giorni, la programmazione è stata poi tutta in discesa. Di fatto ho fatto ampi copia e incolla di codice usato per Arduino in vecchi progetti senza riscontrare particolari problemi, il codice per i sensori DS128B20 è praticamente lo stesso che ho usato in vecchi articoli che trovate sul blog. Che dire poi della connettività di rete? Chi avrà provato la shield WiFi si troverà a suo agio, ho trovato infatti buona corrispondenza fra le istruzioni necessarie per questo modulo e la shield “ufficiale”, tant’è che più di una volta ho usato la documentazione dell’una o dell’altra in modo del tutto indifferente.

Il codice che vi propongo è forse un po’ complesso e piuttosto lungo, ma tutta la parte riguardante il sensore di temperatura, che di fatto è la parte più corposa, è stata abbondantemente trattata in precedenti articoli a cui potete fare riferimento.  Vi riporto qui sotto il listato, poi a seguire vi propongo la spiegazione dei tratti più importanti:

#include <ESP8266WiFi.h>
#include <OneWire.h>
#define SensorLimit 10
byte G_addr[SensorLimit][8]; //qui memorizzo fino a 10 (SensorLimit)indirizzi
byte G_Devices; // variabile usata per tenere traccia del numero di sensori riconosciuti nel bus
float temp[SensorLimit];

const char* ssid     = "LATUASSID"; // Your ssid
const char* password = "LATUAPASSWORD"; // Your Password

IPAddress ip(192,168,0,99); 
IPAddress gate(192, 168,0,1); 
IPAddress subnet(255,255,255,0); 
  
OneWire  ow(2);  // on pin 2 (a 4.7K resistor is necessary)
WiFiServer server(80);
unsigned long my_start;
float celsius=0, fahrenheit=0;

void setup()
{
  //delay(500);
  Serial.begin(115200);
  //while (!Serial.available());
  Serial.print("Starting up..");
  delay(10);


Wait4SSID(ssid); // wait if desiderated wifi network is present

// Connect to WiFi network
Serial.println();
Serial.println();
Serial.print("Connecting to ");
Serial.println(ssid);

 my_start = millis();

  int i = 0;
  while ((WiFi.status() != WL_CONNECTED) &&  (millis() - my_start < 80000))
 {
    delay(500);
    Serial.print(".");
    ESP.wdtFeed();
    if(i>40) ESP.reset();
    i++;
  //WiFi.config(ip,gate,subnet); // use this for static ip
    WiFi.begin(ssid, password);
    
    }


Serial.println("");
Serial.println("WiFi connected");

// Start the server
server.begin();
Serial.println("Server started");

// Print the IP address
Serial.println(WiFi.localIP());

lookUpSensors();
my_start = millis()+100000;
}

void loop() 
{
  

WiFiClient client = server.available(); // check if client requests
if (client)
{
client.println("HTTP/1.1 200 OK");
client.println("Content-Type: text/html");
client.println("Connection: close");  // the connection will be closed after completion of the response
client.println("Refresh: 120");  // refresh the page automatically every 2 minute
client.println();
client.println("<!DOCTYPE HTML>");
client.println("<html>");
client.println("<head><title>Termometro Wifi by McMajan</title></head>");
client.println("<body>");
client.print("<p style='text-align: center;'>&nbsp;</p>");
client.print("<p style='text-align: center;'><span style='font-size: x-large;'><strong>Termometro WiFi 1.0</strong></span></p>");
client.print("<p style='text-align: center;'><span style='font-size: x-large;'><strong>www.mcmajan.com</strong></span></p>");

for(int i=0;i<G_Devices;i++)
{

client.print("<p style='text-align: center;'><span style='color: #4444ee;'><strong style='font-size: large;'>Temperatura ");
client.print(i);
client.print(" = ");
client.println(temp[i]);
client.print("</strong></span><h style='text-align: center;'><span style='color: #4444ee;'><strong style='font-size: large;'><sup>o</sup>C</strong></span></h></p>");
}

client.print("<p style='text-align: center;'>&nbsp;</p>");
client.print("<p style='text-align: center;'>&nbsp;</p>");
client.print("<p style='text-align: center;'>&nbsp;");
client.print("</p>");
client.println("</body>");
client.println("</html>");
}

if(millis() - my_start > 60000)
{
  
byte i;
byte present = 0;
byte type_s;
byte data[12];
byte addr[8]; 
  
Serial.println("");
for(int num=0;num<G_Devices;num++) // vado a leggere tutti i sensori registrati
{
celsius=GetTemp(&G_addr[num][0]); // leggo la temperatura
temp[i]=celsius;

PrintAddress(G_addr[num]);
Serial.print(" -> ");
Serial.print(celsius);

/*if(CheckAddress(S_Salotto,G_addr[num])) Serial.println(" - Salotto ");
else Serial.println("");*/


fahrenheit = celsius * 1.8 + 32.0;
Serial.print("  Temperatura = ");
Serial.print(celsius);
Serial.print(" C, ");
Serial.print(fahrenheit);
Serial.println(" F");
Serial.println();
my_start = millis();

delay(50); // prevent capacitor discharging
}
} // millis

} // loop 




void Wait4SSID(const char * name)
{
bool ssidfound=false;
Serial.print("Wait 5 seconds for capacitor charging");
for(int i=0;i<10;i++) {delay(500);Serial.print(".");} // you have time to connect serial monitor :-)
Serial.println("");
for(;;)
{
 Serial.println("WiFi scan start");

  // WiFi.scanNetworks will return the number of networks found
  int n = WiFi.scanNetworks();
  Serial.println("scan done");
  if (n == 0) Serial.println("no networks found");
  else
  {
    Serial.print(n);
    Serial.println(" networks found");
    for (int i = 0; i < n; ++i)
    {
      // Print SSID and RSSI for each network found
      Serial.print(i + 1);
      Serial.print(": ");
      Serial.print(WiFi.SSID(i));
      if(WiFi.SSID(i)==name) ssidfound=true;
      Serial.print(" (");
      Serial.print(WiFi.RSSI(i));
      Serial.print(")");
      Serial.println((WiFi.encryptionType(i) == ENC_TYPE_NONE)?" ":"*");
      delay(10);
    }
  }
  Serial.println("");
  if(ssidfound==true) break;

  // Wait a bit before scanning again
  delay(5000);
} // for(;;)  
  
}


void lookUpSensors()
{
byte address[8]; // questo array conterrà l'indirizzo locale dei sensori

Serial.print("--Ricerca avviata--"); // avvia la ricerca e lo scrive sulla porta seriale

while (ow.search(address)) // loop finchè trova nuovi dispositivi
{
// Se il primo byte dell'indirizzo è 0x10, si tratta di una sonda DS18S20
// il primo byte dell'indirizzo identifica il tipo di sensore
// se  0x10 è un DS18S20, se è 0x28 è un DS18B20 (notare la S e B)
if (address[0] == 0x10 || address[0] == 0x28)
{
if(CheckSensor(address)==1) //crc ok
{
Serial.println("");

if (address[0] == 0x10) Serial.print("Found DS18S20 : "); // notare che la S invece che la B
else if (address[0] == 0x28) Serial.print("Found DS18B20 : ");

PrintAddress(address);

for(int aa=0;aa<8;aa++) G_addr[G_Devices][aa]=address[aa]; // copia l'indirizzo
G_Devices++; // incrementa il numero di devices memorizzati
}
else Serial.print("found error");
}

}//end while
Serial.println("");
Serial.println("--Ricerca terminata--");
}

void PrintAddress(byte * address)
{
int i;
 for (i=0;i<8;i++)
 {
   if (address[i] < 9) Serial.print("0");
   Serial.print(address[i],HEX);
   if (i<7) Serial.print("-");
 }
}

int CheckSensor(byte * address)
{
  if (OneWire::crc8(address, 7) != *(address+7)) return(0);// faccio il controllo del CRC8, se fallito ritorno -1
  else return(1); // cr8 OK, ritorno 1
}

bool CheckAddress(const unsigned char  * fix,byte*address)
{
unsigned char i;
for (i=0;i<8;i++) if(*(fix+i)!=*(address+i)) return(false);
return(true);

}



float GetTemp(byte * addr)
{
byte present = 0;
byte data[12];
int i;
byte address[8];
for(i=0;i<8;i++) address[i]=*(addr+i); //copia l'indirizzo nella stringa locale
ow.reset();
ow.select(addr);
ow.write(0x44,1);         // start conversion, with parasite power on at the end
delay(1000);     // maybe 750ms is enough, maybe not
// we might do a ds.depower() here, but the reset will take care of it.

present = ow.reset();

ow.select(addr);
ow.write(0xBE);         // Read Scratchpad

for ( i = 0; i < 9; i++) data[i] = ow.read();// we need 9 bytes //Serial.print(data[i], HEX);
Serial.print(" CRC=");
Serial.print(OneWire::crc8(data, 8), HEX);
Serial.println();

int HighByte, LowByte, TReading, SignBit, Tc_100, Whole, Fract;

double result;

LowByte = data[0];
HighByte = data[1];

TReading = (HighByte << 8) + LowByte;
SignBit = TReading & 0x8000;  // test most sig bit

if (SignBit) TReading = (TReading ^ 0xffff) + 1; // 2's comp // negative

Tc_100 = (6 * TReading) + TReading / 4;    // multiply by (100 * 0.0625) or 6.25

Whole = Tc_100 / 100;  // separate off the whole and fractional portions
Fract = Tc_100 % 100;

result = Whole;
result += ((double)Fract/100);

if(SignBit) result *= -1;

return result;

}

La prima parte prevede le inclusioni di rito e la dichiarazione di alcune variabili

#include <ESP8266WiFi.h>
#include <OneWire.h>
#define SensorLimit 10
byte G_addr[SensorLimit][8]; //qui memorizzo fino a 10 (SensorLimit) indirizzi
byte G_Devices; // variabile usata per tenere traccia del numero di sensori riconosciuti nel bus
float temp[SensorLimit];

In particolare G_addr conterrà gli indirizzi rom dei sensori, G_Devices il numero di sensori trovati e temp i valori di temperatura letti. Di default il software è predisposto per leggere sino a 10 sensori ma modificando la definizione SensorLimit si può aumentare o ridurre questo numero. Attenzione che il software non verifica se i sensori trovati sono superiori alla memoria predisposta.

const char * ssid     = “LATUASSID”; // Your ssid
const char * password = “LATUAPASSWORD”; // Your Password
IPAddress ip(192,168,0,99);
IPAddress gate(192, 168,0,1);
IPAddress subnet(255,255,255,0);

Le prime due righe permettono di specificare il nome della rete WiFi a cui connettersi e la relativa password. Questi parametri sono di fondamentale importanza. Le tre righe successive non sono utilizzate successivamente nel listato, ma permettono di scegliere IP, gate e subnet se siete interessati a configurare l’ESP con un indirizzo IP statico.

Wait4SSID(ssid);

Nel setup dopo l’apertura della porta seriale viene chiamata la funzione Wait4SSID(ssid);. Ho previsto questa funzione per due motivi: da una parte ci permette di capire cosa sta facendo il modulo e quali reti identifica, dall’altra ci permette di tentare il collegamento solamente quando la rete viene realmente agganciata. Nelle svariate prove fatte, infatti, come vi dicevo agli inizi, ho perso un sacco di tempo a cercare di capire perchè non riuscivo a collegarmi ad una determinata rete, ma non mi ero accorto che il modulo non ne vedeva nessuna. La funzione utilizza la scanNetworks che permette di identificare il numero di reti riconosciute e le loro caratteristiche (SSID, segnale, etc).

  while ((WiFi.status() != WL_CONNECTED) &&  (millis() – my_start < 80000))
 {
    delay(500);
    Serial.print(“.”);
    ESP.wdtFeed();
    if(i>40) ESP.reset();
    i++;
  //WiFi.config(ip,gate,subnet); // use this for static ip
    WiFi.begin(ssid, password);
    
    }

Le istruzioni successive effettuano la connessione vera e propria. Nel mondo reale non aspettatevi che la connessione avvenga sempre subito, potrebbero essere necessari alcuni tentativi. Faccio notare l’istruzione ESP.wdtFeed() che impedisce al WatchDogTimer di resettare il modulo in quanto passa troppo tempo prima di ripassare dal loop principale. Visto che però in questo modo potrebbe bloccarsi in modo definitivo, c’è un contatore che arrivato al quarantesimo tentativo determina volontariamente il riavvio del modulo (ESP.reset()). Ciò è necessario perchè talvolta pur identificando la rete correttamente, non sempre la connessione avviente poi come previsto. Ho lasciato commentata l’istruzione config che dovrebbe permettere di settare l’IP statico, a dirvela tutta ho provato ma il router gli ha comunque assegnato un indirizzo dinamico ignorando del tutto questa impostazione. Il problema è relativo visto che leggo l’IP ottenuto tramite il monitor seriale, ciò non toglie che è un problema su cui che dovrò indagare.

Una volta entrati nel loop principale viene costantemente valutata con WiFiClient client = server.available();  la presenza di connessioni da parte di qualche client e nel caso positivo viene risposto subito con la presentazione di una pagina web rudimentale che mostra tutte le temperature lette dai vari sensori. Indipendentemente da questa fase, ogni minuto viene effettuata una nuova lettura su tutti i sensori che viene riportata anche sul monitor seriale.

Una volta acceso il modulo e attivato il monitor seriale, vedrete che viene dapprima ricercata la rete, poi viene effettuata la connessione alla ssid da noi scelta, anche se come dicevo non sempre la cosa avviene subito e spesso intercorre almeno un reset del modulo. Una volta effettuata la connessione ci viene fornito il prezioso indirizzo IP che possiamo utilizzare per collegarci con un browser da pc, smartphone o quello che preferite. Nell’immagine qui a lato potete osservare come si presenta il mio telefono una volta collegato all’indirizzo del modulo.

Considerazioni e consigli

Ho avuto davvero tanti problemi a far funzionare il tutto ma è anche vero che quando funziona è davvero una gran figata. Parliamo di un modulino di pochi centimetri che con una manciata di componenti ho trasformato in un semplice termometro WiFi e non c’è nemmeno la necessità di appoggiarsi ad Arduino. Il rovescio della medaglia è legato invece alla non perfetta maturità / aggiornamento del software di sviluppo e restano sempre in agguato i problemi di stabilità legati all’alimentazione. Ricordate che ad ogni malfunzionamento dovete pensare sempre che la prima causa possa essere un’insufficiente linea di alimentazione perchè se è vero che il consumo medio dichiarato è di 80mA, il consumo massimo è di 200mA nel normale funzionamento e con un tetto limite di 300. Ci sono poi sicuramente delle migliorie da poter fare. Trovo infatti strano che a volte il modulo si connetta immediatamente al router mentre in altre occasioni effettua più di un reset (40 tentativi a reset) ma ciò potrebbe essere anche legato alla pessima rete che ho in casa, certo è che se non avete il pc a monitorare cosa sta facendo il modulo potrebbe essere difficile capire se il sistema funziona o meno dato che sinchè non si collega alla rete WiFi non avrete alcun output. Poi ci sono migliorie dello sketch da fare, ad esempio non abbiamo preso in considerazione il fatto che una volta agganciata una rete potremmo anche perderla per cui non ha senso continuare ad inviargli le letture termiche o attendere che un client si connetta. Questo era però un primo articolo “esplorativo”, in futuro utilizzerò in maniera molto intensiva questi moluli per cui li vedremo all’opera in più occasioni. Vi lascio con un video riassuntivo che ho preparato per mostrarvi “con mano” le varie fasi di programmazione del modulo e suo funzionamento.

Salva

Salva

Salva

Salva

Salva

Salva

Salva

Salva

Salva

Salva

Salva

Salva

Salva

Salva

Salva

Salva

Salva