Quanto consuma l’ESP-01? Scopriamolo con Arduino – it

Sembra una domanda semplice: quanto consuma Arduino o la scheda ethernet o un modulo ESP-01? Nel 99% dei casi non ci interessa più di tanto, che assorbano 50 o 80mA cosa ci cambia? Beh, c’è un particolare ambito ove il consumo è molto importante, ossia l’alimentazione a batteria. Il consumo influisce in modo diretto sulla durata della batteria e se questa dura una settimana o 6 mesi fa una bella differenza. Sinora non ho mai pensato al consumo energetico dei nostri progetti, ma è nelle mie intenzioni cominciare a farlo in modo da poter iniziare a creare delle reti di sensori wireless alimentati a batteriE, magari ricaricabili. In questo modo avremmo l’occasione di imparare a gestire i meccanismi di risparmio energetico per ridurre al massimo i consumi cosa che non è proprio così scontata come potrebbe sembrare.

Vi preannuncio che in questo articolo sono descritti anche alcuni fallimenti per cui non cominciate a fare ordini online e preparare circuiti vari finchè non avete letto tutto, rischiate di ripetere i miei medesimi errori. Chi mi segue sa che è mia abitudine descrivere anche le cose andate male, i fallimenti, perchè non ha senso trovare solo articoli in cui tutto funziona sempre al primo colpo e poi nella pratica ci si deve confrontare con mille forum perchè nella realtà dei fatti non funziona nulla e non capiamo perchè.

Il progetto

Nello scorso articolo abbiamo visto come realizzare un semplice termometro WiFi attraverso il modulo ESP-01. Oggi vorrei fare due cose. Innanzitutto vorrei alimentare quel termometro con delle batterie ricaricabili, inoltre vorrei inviare i dati letti sul Web in modo da accorgermi quando il modulo smette di inviare i dati, senza dover andare continuamente a guardare il led di alimentazione che peraltro, come vi ho mostrato nello scorso video, potrebbe essere acceso ma con il modulo del tutto bloccato. La seconda cosa che vorrei realizzare è un misuratore della corrente assorbita da fare con Arduino, in questo modo utilizzo Arduino per valutare il consumo energetico dell’ESP-01. Una volta realizzato il tutto ho il necessario per valutare il consumo di base, capire se i calcoli teorici corrispondono poi alla quelli reali sul campo e con tutti questi dati possiamo poi pensare di cominciare ad ottimizzare sia il software che l’hardware per ridurre al massimo il consumo energetico. Cominciamo?

Arduino e il monitoraggio energetico

Noooo, ancora? Si lo so abbiamo parlato in lungo e in largo di questo argomento, ma oggi ci sono delle sostanziali differenze rispetto a quanto detto sinora. Arduino o ESP-01 funzionano a corrente continua e non alternata, inoltre i consumi non sono dell’ordine degli ampere ma dei milli-ampere. Ciò fa si che tutto quel che abbiamo detto sinora sulla misura del consumo energetico lo possiamo buttare nel ces…..tino. Le misurazioni andremo a farle con un sensore invasivo basato sul chip, l’INA219, sensore in grado di operare fra 0 e 26V e di misurare tensione, corrente e potenza fino a 3.2A con una precisione di 0.8mA. La verità è che quel sensore può misurare correnti sino a 32A, e il range massimo dipende da un resistore montato sul modulo e che quindi ne stabilisce la scala di misura. La precisione è a 12 bit per cui è sufficiente dividere la scala per 4096 per trovare la risoluzione di misura. Io ho a disposizione un modulino già bello che pronto per misure fino 3.2A per cui non dovrò preoccuparmi di fare complicate saldature e calcoli, mi basterà collegare i vari pin ed il modulo sarà già pronto per operare. Il modulino in questione è questo qui sotto:

Come vedete non è nulla di particolarmente complesso. Da un lato, in alto,  abbiamo i due pin a cui collegare il carico che intendiamo misurare. Dall’altra troviamo i pin per l’alimentazione del modulo stesso (3-5.5V) e quelli per la comunicazione I²C (scl, sca). Vi riporto qui a lato un esempio di schema di collegamento. In alto vediamo appunto il polo positivo entrare nel modulo mentre alla sua uscita viene collegato il carico che vogliamo misurare, nel caso specifico ho messo un motore, ma è solo una questione di puro disegno, possiamo infatti metterci qualunque cosa.

Nel lato inferiore vediamo la connessione all’interfaccia I2C con i relativi pin SCL ed SDA corrispondenti ai pin A5 e A4 delle vecchie schede Arduino UNO, ma che nelle più recenti R3 trovate anche replicate sul versante opposto, vicino al pin AREF, posizione che ritrovate anche in Arduino DUE. Sempre sul lato inferiore possiamo vedere i fili rosso e nero per l’alimentazione del modulo. Come vedete è davvero tutto molto semplice e siamo pronti per effettuare le misure di assorbimento dei dispositivi che ci interessano. Prima però dobbiamo pensare alla parte software. Il sensore utilizza l’interfaccia I2C per cui otteniamo un dato digitale che possiamo utilizzare in modo diretto. Scarichiamoci la libreria per controllare il modulo INA219 e prepariamo il primo sketch di esempio. Anche qui non dobbiamo fare grossi sforzi, ci è sufficiente utilizzare lo sketch di esempio che troviamo incluso nella libreria e che per completezza vi riporto qui sotto:

#include <Wire.h>
#include <Adafruit_INA219.h>

Adafruit_INA219 ina219;

#if defined(ARDUINO_ARCH_SAMD)
 // for Zero, output on USB Serial console, remove line below if using programming port to program the Zero!
 #define Serial SerialUSB
#endif

void setup(void) 
 {
 #ifndef ESP8266
 while (!Serial); // will pause Zero, Leonardo, etc until serial console opens
 #endif
 uint32_t currentFrequency;
 
 Serial.begin(115200);
 Serial.println("Hello!");
 
 // Initialize the INA219.
 // By default the initialization will use the largest range (32V, 2A). However
 // you can call a setCalibration function to change this range (see comments).
 ina219.begin();
 // To use a slightly lower 32V, 1A range (higher precision on amps):
 //ina219.setCalibration_32V_1A();
 // Or to use a lower 16V, 400mA range (higher precision on volts and amps):
 //ina219.setCalibration_16V_400mA();

Serial.println("Measuring voltage and current with INA219 ...");
 }

void loop(void) 
 {
 float shuntvoltage = 0;
 float busvoltage = 0;
 float current_mA = 0;
 float loadvoltage = 0;

shuntvoltage = ina219.getShuntVoltage_mV();
 busvoltage = ina219.getBusVoltage_V();
 current_mA = ina219.getCurrent_mA();
 loadvoltage = busvoltage + (shuntvoltage / 1000);
 
 Serial.print("Bus Voltage: "); Serial.print(busvoltage); Serial.println(" V");
 Serial.print("Shunt Voltage: "); Serial.print(shuntvoltage); Serial.println(" mV");
 Serial.print("Load Voltage: "); Serial.print(loadvoltage); Serial.println(" V");
 Serial.print("Current: "); Serial.print(current_mA); Serial.println(" mA");
 Serial.println("");

delay(2000);
 }

Io al posto delle batterie ho usato un alimentatore da breadboard e al posto del motore ho messo un Arduino UNO programmato con uno sketch vuoto in modo da tenere il più costante possibile il consumo energetico. Vi confesso che i risultati sono stati un po’ instabili, il modulo più volte si è bloccato improvvisamente smettendo di funzionare per ore senza apparenti motivi per poi riprendersi poi come nulla fosse.  Mediamente il sistema mi ha misurato una tensione di 4.9V ed una corrente compresa 46.6 e 48.4mA, ma sono riuscito a farlo funzionare correttamente solo per brevi periodi. Non so se sia il mio modulo ad essere difettoso, ma non ho perso ulteriore tempo e sono passato ad un secondo tipo di modulo, il Max471 che a differenza del precedente non usa l’interfaccia I2C (secondo me causa del malfunzionamento) ma utilizza delle semplici uscite analogiche. Il modulo è quello rosso della foto qui vicino. Come vedete c’è un connettore a vite per l’ingresso dell’alimentazione (da 3 a 25V) ed uno per l’uscita, che va ad alimentare il carico di cui vogliamo conoscere l’assorbimento. Nella foto vediamo la corrente di alimentazione provvenire da un alimentatore per breadboard, attraverso i cavetti azzurro e verde. In uscita vediamo i cavetti marrone ed arancione che vanno ad alimentare l’Arduino in alto a destra e che come detto è pre-programmato con uno sketch vuoto.

Sull’altro versante abbiamo 4 pin, due sono delle masse, gli altri due le uscite analogiche VT e AT, rispettivamente arancio e verde che terminano sui pin A1 e A0 dell’Arduino “misuratore”. VT fornisce un segnale da 0 a 5V, dove il 5V indica un ingresso di 25V (ossia ogni V in uscita rappresenta 5V in ingresso). AT invece rappresenta la corrente assorbita, ogni V corrisponde ad 1A di assorbimento. Usando la risoluzione a 10bit di Arduino UNO abbiamo  una precisione di 1/1024=0.97mA, quindi leggermente inferiore al modulo precedente anche se sappiamo benissimo che il rumore di fondo normalmente aumenta di almeno 3-4 volte il limite di misura minimo. Io utilizzerò la McMajan Library Pack e lasciando la precisione di misura a 10 bit ottengo fluttuazioni massime dell’ordine di circa 1.2mA, mentre portandola a 12bit con la tecnica dell’oversampling, tale fluttuazione scende a circa 0.39mA anche se vi devo confessare che tale stabilità l’ho ottenuta solo con uno sketch più complesso di quello che vi riporto qui sotto e che sfrutta i filtri di Kalman. Come letture ho ottenuto 4.85V con un assorbimento fra 33.05 e 33.44mA. Purtroppo  non ho un multimetro di un certo livello per verificare quale dei due sensori mi fornisce la misura più accurata, il mio comunque mi fornisce un dato pari a 0.03A quindi più vicina a questo secondo sensore che al primo. Ora vediamo il software semplificato che ho utilizzato in questa seconda realizzazione, per le singole funzioni della libreria vi rimando alla documentazione ufficiale:

#include <Ss_McMajan_Config.h>

struct Mc_AnalogSensor I_Probe;
struct Mc_AnalogSensor V_Probe;

double I,V;
unsigned long ciclo=0;

void setup()
{
  Serial.begin(9600);
  while (!Serial) {} // wait for serial port to connect. Needed for Leonardo only
  Serial.println("STARTING READER.... ");
  Mc_Analog_Inist(); 

  I_Probe.pin=A1; 
  I_Probe.sensor_range=5;
  I_Probe.sensor_voltage_range=5;
  Mc_CalculateSensorStep(&I_Probe); 

  V_Probe.pin=A0; 
  V_Probe.sensor_range=25;
  V_Probe.sensor_voltage_range=5;
  Mc_CalculateSensorStep(&V_Probe); 

}

void loop() 
{
  V=Mc_SampleAnalogAvg(A0,150)*V_Probe.sensor_step;
  I=Mc_SampleAnalogAvg(A1,150)*I_Probe.sensor_step*1000;

 ciclo++;
 if(ciclo%20==0)
 {
  //Serial.println(" ");
  Serial.print("I= ");
  Serial.print(I);
  Serial.print(" mA - V :");
  Serial.print(V);
  Serial.print("V - P:");
  Serial.print(V*I);
  Serial.println(" mW");
  Serial.println(" ");
 }
}

Lo sketch che vi propongo utilizza come detto la mia McMajan Library Pack per effettuare l’oversampling del segnale che vi ricordo va impostato sul file Ss_McMajan_Config.h. Tutte le varie funzioni sono presenti nella documentazione e negli esempi allegati alla libreria, ma tralasciando il funzionamento interno della libreria che in realtà è molto complesso, dovrebbe essere invece particolarmente semplice la comprensione del suo utilizzo, di fatto dopo tutte le inizializzazioni del caso viene utilizzata solo la Mc_SampleAnalogAvg che effettua una media sul numero specificato di campionamenti analogici con i parametri di oversampling indicati nel file di configurazione della libreria. Qui sopra vi riporto la versione semplificata dello sketch, senza l’uso dei filtri di Kalman che introducono qualche complicazione di troppo. Si noti anche l’uso delle strutture Mc_AnalogSensor per ottenere i fattori di conversione dalla lettura grezza al voltaggio e corrente senza dover fare alcuna conversione manuale, cosa assai utile perchè permette di modificare anche a posteriori i parametri di oversampling del segnale senza dover rifare i calcoli per la conversione.

Ora che abbiamo un sistema per fare le misurazioni vediamo quanto consuma il “termometro WiFi” che abbiamo visto nello scorso articolo: ho rilevato 3.17V (con solo 0.03V di scarto rispetto alla misura fatta con l’oscilloscopio) con un assorbimento a riposo di circa 63mA ma con dei picchi di oltre 180mA. Ovviamente se dobbiamo andare ad alimentare a batteria questo modulo, non possiamo ignorare tutti questi picchi.

Seconda parte

Per quanto riguarda l’invio delle temperature a web dobbiamo fare solo qualche piccola modifica allo sketch visto precedentemente, inoltre dobbiamo preparare anche il software che riceve i dati sul server remoto e li riporta su grafico. Quest’ultima parte la tralasceremo, ne abbiamo parlato in passato, ma credo che questa sarà una delle ultime volte che utilizzeremo questo sistema perchè è mia intenzione costruire qualcosa di più sofisticato. Sono cosciente che esistono già dei sistemi pronti, fra i quali vi segnalo Cayenne segnalatomi con entusiasmo da un amico del blog e che mi pare essere davvero ben fatto. Rispetto all’articolo sul termometro WiFi ho aggiunto solamente una funzione che viene richiamata ogni 10 minuti ed invia il dato termico ad un mio server remoto. La porzione di codice aggiunta è la seguente:

void SendWebTemp()
{ 
  WiFiClient ArduinoClient; // check if client requests

if (ArduinoClient.connect(remote, 80)==1)  
{
 if(ArduinoClient.connected())
      {
        ArduinoClient.print("HEAD /wsendtemp.php?c1=");
        ArduinoClient.print(temp[0]); 
        ArduinoClient.print("&time=");
        ArduinoClient.print(now());  
                
        ArduinoClient.println(" HTTP/1.1"); // attenzione allo spazio
        //ArduinoClient.println("Host: 127.0.0.1");
        ArduinoClient.println("Host: www.mcmajan.com");
        ArduinoClient.println("User-Agent:Arduino");
        ArduinoClient.println("Accept: text/html");
        ArduinoClient.println("Connection: close");
        ArduinoClient.println();
        ArduinoClient.stop();
        delay(500);
      } 
}
}

Ho lasciato il sistema in funzione per una notte per verificarne il corretto funzionamento, e devo dire che come test preliminare è andato decisamente sin troppo liscio. Il risultato ve lo riporto qui sotto:

Ora dobbiamo solo preparare un sistema per l’alimentazione a batteria. La mia intenzione era quella di utilizzare due batterie ricaricabili AA Ni-Mh dato che avrei il materiale necessario in casa. Questo tipo di batterie è noto avere una tensione di 1.2V per cui anche mettendole in serie otteniamo una tensione di soli 2.4V, insufficienti ad alimentare l’ESP-01. L’ideale sarebbe utilizzare un modulo step-up 3.3V come questo, che a partire da un ingresso compreso fra 1 e 3V fornisce in uscita 3.3V. Purtoppo non ne ho uno, l’unico modulo step up che possiedo mi porta la tensione di ingresso a 5V a partire da 1-5V. Ho inoltre un modulo step-down regolabile che mi fornisce in uscita i 3.3V per cui potrei metterli in serie per ottenere la tensione voluta, certo non è la soluzione ideale ma è quel che ho in casa. Allora, ho collegato lo step up a 5V e questa prima parte ha funzionato, ossia dalle due batterie ho ottenuto i 5V attesi. Poi ho messo in serie lo step-down regolato sui 3.3V ed ho ottenuto il risultato voluto anche in questo caso. Qui sotto vi riporto una foto con i vari collegamenti e la misura fatta con il multimetro. Le batterie della foto sono di tipo alcalino, ma con le ricaricabili da 1.2V ho ottenuto il medesimo risultato.

Nonostante la tensione in uscita fosse corretta nei primi tentativi non ha funzionato nulla, ne con le batterie alcaline ne quelle ricaricabili. Ho pensato che il problema potesse essere dovuto come sempre ai picchi di assorbimento, in particolare quando le richieste di corrente del convertitore step-down 5 -> 3.3V aumentano in modo improvviso per i picchi di assorbimento dell’ESP-01 il convertitore 2.4V -> 5V potrebbe non essere sufficientemente reattivo da fornire la corrente richiesta. Per questo motivo ho aggiunto un condensatore da 470μF e devo ammettere che le cose sono migliorate, in particolare il sistema ha cominciato a funzionare sia alimentando con le batterie alcaline che sostituendo tutta la prima parte con la 5V in uscita da Arduino. Con le batterie ricaricabili ho invece avuto un sacco di problemi. Il sistema tende a non avviarsi o bloccarsi dopo le prime letture, per riuscire a fare dei test ho dovuto mantenere una connessione seriale per accertarmi che il modulo fosse partito e avesse iniziato a fare le prime misurazioni.

Per quanto riguarda i consumi ho rilevato assorbimenti di circa 54mA a 4.77V. Le batterie usate sono una da 2000mAh e l’altra da 1800mAh per cui ho un totale teorico di 3800mAh a 1.2V. Non ho alcuna esperienza nel campo del funzionamento a batteria, ma sicuramente avendo tensioni differenti fra la fonte e la misurazione dell’assorbimento, non possiamo calcolare in modo diretto il consumo solo in base al rapporto fra mA e mAh. Per questo ho convertito il tutto in mW, quindi secondo il mio ragionamento le batterie mi dovrebbero dare totale di circa 4560mWh. Ho rifatto le misurazioni di consumo ponendo il misuratore fra i due convertitori, il che mi permette di calcolare anche il consumo del secondo convertitore (ma non il primo). Questo ha una resa dichiarata del 95%, quindi dobbiamo sottrarre un 5% alla capacità complessiva, poi ci sono altri fattori, come ad esempio il fatto che le batterie sono vecchiotte e non terranno la carica come da nuove per cui possiamo togliere almeno un altro 5% ed arriviamo a 4140. Beh dai, arrotondiamo a 4000mWh e vediamo cosa succede. Dicevo che ho rimisurato il consumo, ottenendo circa 54mA (media di 100000 misurazioni) con 4.77V, ossia 258mW. Facendo quindi 4000/258 dovrei ottenere 15.5 ore di funzionamento: sarà realistico? Ho iniziato il test alle 22:34 ma alle 23:40, ossia dopo solo una misera ora è terminato. Qui sotto potete vedere il risultato dei campionamenti fatti ogni minuto. Il fatto che all’inizio le misurazioni risultino più alte dipende dal fatto che l’avvio del sistema lo faccio sempre vicino a me e al PC dove c’è più calore e poi sposto il tutto sopra un mobile isolato dove è più fresco.

Quando mi sono svegliato l’indomani ho trovato tutto spento ed ho misurato la tensione delle due batterie: quella da 2000mAh erogava 0.44V mentre quella da 1800 erogava 1.179V.

A questo punto ho provato a ripetere il test con le batterie alcaline, non sono del tutto cariche e non ne conosco la capacità. Quali saranno i risultati? Intanto che aspetto la conclusione del secondo test facciamo alcune considerazioni. Il test preliminare è stato un gran fallimento, le due batterie ricaricabili si sono dimostrate inaffidabili, infatti riuscire a far partire le misurazioni in maniera stabile è stato molto difficile, vi risparmio le due giornate di prove che ho dovuto fare prima di riuscire a tirar fuori il grafico qui sopra e dopo tutta la fatica fatta il tutto si è fermato in poco più di una misera ora. C’è da dire che il sistema sotto test rappresenta il massimo del consumo atteso. In primo luogo funziona anche da server per leggere la temperatura attraverso la rete locale, ma questa funzione è del tutto inutile visto che i dati sono inviati ad un server remoto e possono essere prelevati da li. Ciò implica che il sistema deve essere sempre in ascolto di eventuali connessioni locali con relativo spreco di risorse. Questa sarà la prima cosa da eliminare nel proseguio del nostro progetto. La seconda cosa da notare che che la temperatura viene letta ogni minuto, ma potremmo accontentarci di leggerla ogni 5 o 10 minuti. La terza cosa fondamentale che dovremmo notare e che nel tempo in cui lo sketch non fa nulla se non attendere il passaggio del tempo, lavora comunque a “pieno carico”, ossia non vengono attivati i meccanismi di risparmio energetico disponibili per il chip ESP8266.

Ma torniamo al test: com’è andata? Ho cominciato alle 9:27 ed il test si è concluso alle 18:44, 9 ore e 20 di funzionamento continuato, comunue ben lontane da quanto sperassi. Qui sotto il grafico con i campionamenti.

 

Per ora i test si fermano qui, vi ho elencato le modalità che ho usato per calcolare il consumo energetico e vi ho mostrato i test preliminari a batterie, con tutti i problemi che ho avuto. Per ora sono particolarmente deluso in quanto il mio scopo è usare le batterie ricaricabili e riuscire a passare da quella misera ora di funzionamento a 6 mesi ininterrotti senza manutenzione. In alternativa potrei utilizzare le pile alcaline, ma in tal caso dovrei raggiungere perlomeno l’anno di funzionamento ininterrotto, cosa che dalle prime prove fatte mi sembra utopia pura. Il prossimo passo sarà l’acquisto di moduli step-up 3.3V ad alta efficienza e l’acquisto di batterie AA ricaricabili di alta qualità con relativo carica-batterie di altrettanta buona qualità. Quando avrò il materiale potrò ripetere tutti i test e cominciare ad ottimizzare il codice con un riguardo al risparmio energetico. Per ora siamo in alto mare, ma nell’attesa che mi arrivi il materiale spero che apprezziate il fatto che pubblico non solo i successi di questo mio hobby, ma anche gli insuccessi come quelli di oggi. La realtà è che avrei dovuto ricevere le prime batterie prima di concludere questo articolo, ma come sempre GLS si dimostra un pessimo corriere nella mia zona per cui approfitto per fargli della pubblicità, negativa ovviamente.

Salva

 

 

Salva

Salva

Salva

Salva

Salva

Salva

Salva

Salva

Salva

Salva

Salva

Salva

Salva

Salva

Salva

Salva

Salva

Salva

Salva

Salva

Salva

Salva

Salva

Salva

Salva

Salva

Salva

Salva

Salva

Salva