Sensore di livello del collettore d'acqua alimentato a batteria: 7 passaggi (con immagini)

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 09:59

La nostra casa dispone di una cisterna per l'acqua alimentata dalla pioggia caduta sul tetto, e utilizzata per il wc, la lavatrice e per annaffiare le piante del giardino. Negli ultimi tre anni le estati sono state molto secche, quindi abbiamo tenuto d'occhio il livello dell'acqua nel serbatoio. Finora abbiamo usato un bastoncino di legno, che abbiamo messo nel serbatoio e segnato il livello. Ma sicuramente deve essere possibile migliorare su questo!

È qui che entra in gioco questo progetto. L'idea è di collegare un sensore di distanza ad ultrasuoni nella parte superiore del serbatoio. Questo sensore funziona come un sonar emettendo onde sonore, che vengono poi riflesse dalla superficie dell'acqua. Dal tempo impiegato dalle onde per tornare indietro e dalla velocità del suono, puoi calcolare la distanza dalla superficie dell'acqua e determinare quanto è pieno il serbatoio.

Dato che non ho un collegamento di rete vicino al serbatoio, è essenziale che l'intero dispositivo funzioni a batterie. Ciò significa che dovevo essere consapevole del consumo energetico di tutte le parti. Per inviare i dati ho deciso di utilizzare il Wifi integrato di un microchip ESP8266. Sebbene il Wifi sia abbastanza affamato di energia, ha un vantaggio rispetto a un altro tipo di connessione radio: puoi connetterti direttamente al router wireless di casa senza dover costruire un altro dispositivo che funge da relè.

Per risparmiare energia metterò l'ESP8266 in modalità di sospensione profonda per la maggior parte del tempo e prenderò una misurazione ogni ora. Per il mio scopo di seguire il livello dell'acqua questo è più che sufficiente. I dati verranno inviati a ThingSpeak e potranno essere letti su uno smartphone tramite un'app.

Un dettaglio in più! La velocità del suono, essenziale per la misurazione della distanza, dipende dalla temperatura e in misura minore dall'umidità. Per una misurazione esterna accurata nel corso delle stagioni, verrà inserito un sensore BME280, che misura temperatura, umidità e pressione. Come bonus, questo fa del nostro sensore di livello dell'acqua anche una mini stazione meteorologica.

Parti:

• 1x ESP8266 ESP-12F.
• 1x piastra adattatore ESP-12F.
• 1x FT232RL FTDI: adattatore da USB a seriale.
• 1x HC-SR04-P: modulo di misurazione della distanza ad ultrasuoni. Si noti che la P è importante, poiché questa è la versione che ha una bassa tensione operativa minima di 3V.
• 1x BME280 versione 3.3V: sensore di temperatura, pressione e umidità.
• 1x IRL2203N: transistor MOSFET a canale n.
• 1x MCP1700-3302E Versione 3.3V: regolatore di tensione.
• 3 batterie AA ricaricabili, ad es. 2600mAh.
• 1x portabatterie per 3 batterie.
• 1x tagliere.
• Resistori: 1x 470K, 1x 100K, 4x 10K.
• Condensatori: 2x ceramici 1uF.
• Interruttore a levetta 3x.
• Fili per breadboard a forma di U.
• Fili di ponticello.
• Contenitore in plastica per zuppa 1l.
• Anello di fissaggio per il contenitore.

Ho reso disponibile il codice su GitHub.

Passaggio 1: conoscere il sensore di distanza a ultrasuoni

Misureremo la distanza dalla superficie dell'acqua con un sensore a ultrasuoni, l'HC-SR04-P. Proprio come un pipistrello, questo sensore utilizza il sonar: invia un impulso sonoro con una frequenza troppo alta per l'orecchio umano, quindi ultrasonico, e aspetta che colpisca un oggetto, rifletta e torni indietro. La distanza può quindi essere calcolata dal tempo impiegato per ricevere l'eco e dalla velocità del suono.

Concretamente, se il pin Trig viene tirato in alto per almeno 10 μs il sensore invia un burst di 8 impulsi con una frequenza di 40 Hz. La risposta si ottiene quindi sul pin Echo sotto forma di un impulso con durata pari al tempo tra l'invio e la ricezione dell'impulso ultrasonico. Quindi dobbiamo dividere per 2, poiché l'impulso ultrasonico va avanti e indietro e abbiamo bisogno del tempo di viaggio unidirezionale, e moltiplicarlo per la velocità del suono, che è di circa 340 m/s.

Ma aspetta un minuto! Infatti la velocità del suono dipende dalla temperatura e in misura minore dall'umidità. Sto pignolo o è rilevante? Utilizzando uno strumento di calcolo troviamo che in inverno (prendendo -5 °C) potremmo avere 328,5 m/s, e in estate (prendendo 25 °C) 347,1 m/s. Quindi supponiamo di trovare un tempo di viaggio di sola andata di 3 ms. In inverno, ciò significherebbe 98,55 cm e in estate 104,13 cm. È una bella differenza! Quindi, per ottenere una precisione sufficiente durante le stagioni e anche di giorno e di notte, dobbiamo aggiungere un termometro alla nostra configurazione. Ho deciso di includere il BME280, che misura temperatura, umidità e pressione. Nel codice ho usato nella funzione speedOfSound una formula che calcola la velocità del suono in termini di tutti e tre i parametri, sebbene la temperatura sia davvero il fattore più importante. L'umidità ha ancora un effetto minore, ma l'impatto della pressione è trascurabile. Potremmo usare una formula più semplice che tenga conto solo della temperatura che ho implementato in speedOfSoundSimple.

C'è un altro punto importante sull'HC-SR04. Sono disponibili due versioni: la versione standard funziona a 5V, mentre l'HC-SR04-P può funzionare con un range di tensioni da 3V a 5V. Poiché le 3 batterie AA ricaricabili forniscono circa 3x1,25V=3,75V, è importante acquistare la versione P. Alcuni venditori potrebbero inviare quello sbagliato. Quindi dai un'occhiata alle foto se ne acquisti uno. Le due versioni hanno un aspetto diverso sia sul retro che sul davanti come spiegato in questa pagina. Nella parte posteriore della versione P tutti e tre i chip sono orizzontali mentre nella versione standard uno è verticale. Nella parte anteriore la versione standard ha un componente argento extra.

Nel circuito elettronico utilizzeremo un transistor come interruttore per spegnere l'alimentazione del sensore a ultrasuoni quando la nostra configurazione va in modalità di sospensione profonda per risparmiare la durata della batteria. Altrimenti, consumerebbe ancora circa 2 mA. Il BME280 invece consuma solo circa 5 μ quando inattivo, quindi non è necessario spegnerlo con il transistor.

Passaggio 2: scelta della scheda ESP8266

Per far funzionare il sensore il più a lungo possibile con una batteria, dobbiamo risparmiare sul consumo di energia. Sebbene il Wifi dell'ESP8266 fornisca un modo molto conveniente per connettere il nostro sensore al cloud, è anche piuttosto affamato di energia. In funzione, l'ESP8266 consuma circa 80 mA. Quindi con batterie da 2600 mAh saremmo in grado di far funzionare il nostro dispositivo solo per 32 ore al massimo prima che si scarichino. In pratica, sarà inferiore poiché non saremo in grado di utilizzare l'intera capacità di 2600 mAh prima che la tensione scenda a un livello troppo basso.

Fortunatamente l'ESP8266 ha anche una modalità di sospensione profonda, in cui quasi tutto è spento. Quindi il piano è mettere l'ESP8266 in modalità di sospensione profonda per la maggior parte del tempo e svegliarlo ogni tanto per effettuare una misurazione e inviare i dati tramite Wi-Fi a ThingSpeak. Secondo questa pagina il tempo massimo di deep-sleep era di circa 71 minuti, ma dal core Arduino 2.4.1 di ESP8266 è aumentato a circa 3,5 ore. Nel mio codice mi sono accontentato di un'ora.

Ho provato prima la comoda scheda di sviluppo NodeMCU, ma peccato, nel sonno profondo ha comunque consumato circa 9 mA, il che ci dà al massimo 12 giorni di puro sonno profondo senza nemmeno considerare gli intervalli di risveglio. Un importante colpevole è il regolatore di tensione AMS1117, che utilizza l'alimentazione anche se si tenta di bypassarla collegando la batteria direttamente al pin 3.3V. Questa pagina spiega come rimuovere il regolatore di tensione e l'UART USB. Tuttavia, non sono mai riuscito a farlo senza distruggere la mia tavola. Inoltre, dopo aver rimosso l'UART USB non è più possibile connettersi all'ESP8266 per capire cosa è andato storto.

La maggior parte delle schede di sviluppo ESP8266 sembra utilizzare il regolatore di tensione AMS1117 dispendioso. Un'eccezione è il WEMOS D1 mini (immagine a sinistra) che viene fornito con il più economico ME6211. In effetti, ho scoperto che il WEMOS D1 mini utilizza circa 150 μA nel sonno profondo, che è più simile. La maggior parte è probabilmente dovuta all'UART USB. Con questa scheda devi comunque saldare le intestazioni per i pin.

Tuttavia, possiamo fare molto meglio usando una scheda essenziale come l'ESP-12F (immagine a destra), che non ha un UART USB o un regolatore di tensione. Alimentando il pin da 3,3V ho riscontrato un consumo in modalità deep-sleep di soli 22 μA!

Ma per far funzionare l'ESP-12F, preparati per un po' di saldatura e un po' più di problemi per programmarlo! Inoltre, a meno che le batterie non forniscano direttamente la tensione corretta, che è compresa tra 3 V e 3,6 V, dobbiamo fornire il nostro regolatore di tensione. In pratica, risulta difficile trovare un sistema di batterie che fornisca una tensione in questo intervallo durante il suo ciclo di scarica completo. Ricorda che dobbiamo anche alimentare il sensore HC-SR04-P, che teoricamente può funzionare con una tensione fino a 3 V, ma funziona in modo più accurato se la tensione è più alta. Inoltre nel mio diagramma l'HC-SR04-P è acceso da un transistor, che induce una piccola caduta di tensione extra. Useremo il regolatore di tensione MCP1700-3302E. La tensione di ingresso massima è di 6V, quindi la alimentiamo con un massimo di 4 batterie AA. Ho deciso di utilizzare 3 batterie AA.

Passaggio 3: crea un canale ThingSpeak

Useremo ThingSpeak, un servizio cloud IoT, per archiviare i nostri dati. Vai su https://thingspeak.com/ e crea un account. Una volta effettuato l'accesso, fai clic sul pulsante Nuovo canale per creare un canale. Nelle Impostazioni canale inserisci il nome e la descrizione come preferisci. Successivamente nominiamo i campi del canale e li attiviamo facendo clic sulle caselle di controllo a destra. Se usi il mio codice invariato i campi sono i seguenti:

• Campo 1: livello dell'acqua (cm)
• Campo 2: livello batteria (V)
• Campo 3: temperatura (°C)
• Campo 4: umidità (%)
• Campo 5: pressione (Pa)

Per riferimento futuro, annotare l'ID del canale, la chiave API di lettura e la chiave API di scrittura, che si trovano nel menu Chiavi API.

Puoi leggere i dati di ThingSpeak sul tuo smartphone utilizzando un'app. Sul mio telefono Android utilizzo il widget IoT ThingSpeak Monitor. Devi configurarlo con l'ID del canale e la chiave API di lettura.

Passaggio 4: come programmare ESP-12F

Abbiamo bisogno di una scheda essenziale per risparmiare sulla durata della batteria, ma il lato negativo è che è un po' più difficile da programmare rispetto a una scheda di sviluppo con USB UART integrata.

Useremo l'IDE di Arduino. Ci sono altri Instructables che spiegano come usarlo, quindi sarò breve qui. I passaggi per renderlo pronto per ESP8266 sono:

• Scarica l'IDE Arduino.
• Installa il supporto per la scheda ESP8266. Nel menu File - Preferenze - Impostazioni aggiungi l'URL https://arduino.esp8266.com/stable/package_esp8266com_index.json agli URL aggiuntivi di Board Manager. Successivamente nel menu Strumenti - Board - Boards Manager install esp8266 by esp8266 community.
• Seleziona come scheda: Modulo ESP8266 generico.

Per gestire l'ESP-12F ho utilizzato una piastra di adattamento, comunemente disponibile nei negozi online. Ho saldato il chip alla piastra e poi ho saldato le intestazioni alla piastra. Solo allora ho scoperto che la piastra dell'adattatore è troppo larga per una breadboard standard! Non lascia pin liberi sul lato per effettuare le connessioni.

La soluzione che ho scelto è usare cavi a forma di U e collegarli come nell'immagine a destra prima di mettere l'ESP8266 con la piastra adattatore sulla breadboard. Quindi GND e VCC sono collegati alle rotaie della breadboard e i pin rimanenti sono resi disponibili più in basso nella breadboard. Lo svantaggio è che la tua breadboard sarà piuttosto affollata di fili una volta terminato il circuito completo. Un'altra soluzione consiste nell'incastrare due breadboard come mostrato in questo video.

Successivamente, per programmare l'ESP-12F tramite la porta USB del tuo computer, abbiamo bisogno di un adattatore da USB a seriale. Ho usato il programmatore FTDI FT232RL. Il programmatore ha un ponticello per selezionare tra 3.3V o 5V. Dovrebbe essere messo a 3,3 V per ESP8266. Non dimenticarlo perché 5V potrebbero friggere il tuo chip! L'installazione dei driver dovrebbe essere automatica, ma se la programmazione non funziona puoi provare ad installarli manualmente da questa pagina.

L'ESP8266 ha una modalità di programmazione per caricare il nuovo firmware sulla flash e una modalità flash per eseguire il firmware corrente dalla memoria flash. Per scegliere tra queste modalità alcuni pin devono assumere un certo valore al momento dell'avvio:

• Programmazione: GPIO0: basso, CH-PD: alto, GPIO2: alto, GPIO15: basso
• Flash: GPIO0: alto, CH-PD: alto, GPIO2: alto, GPIO15: basso

La piastra dell'adattatore si occupa già di sollevare CH-PD e abbassare GPIO15 con resistori da 10K.

Quindi nel nostro circuito elettronico abbiamo ancora bisogno di tirare su GPIO2. Forniamo anche un interruttore per mettere l'ESP8266 in programmazione o in modalità flash e un interruttore per ripristinarlo, cosa che avviene collegando RST a terra. Assicurati inoltre di collegare il pin TX dell'FT232RL al pin RXD dell'ESP8266 e viceversa.

La sequenza di programmazione è la seguente:

• Impostare GPIO2 su basso chiudendo l'interruttore di programmazione.
• Ripristina ESP8266 chiudendo e riaprendo l'interruttore di ripristino. L'ESP8266 ora si avvia in modalità di programmazione.
• Reimpostare GPIO2 su alto aprendo l'interruttore di programmazione.
• Carica il nuovo firmware dall'IDE di Arduino.
• Ripristina nuovamente ESP8266 chiudendo e riaprendo l'interruttore di ripristino. L'ESP8266 ora si avvia in modalità flash ed esegue il nuovo firmware.

Ora puoi testare se la programmazione funziona caricando il famoso sketch dei Blink.

Se tutto questo funziona almeno i pin GND, VCC, GPIO2, RST, TXD e RXD sono saldati e collegati correttamente. Che sollievo! Ma prima di procedere ti consiglierei di testare anche gli altri pin con il tuo multimetro. Anch'io ho avuto un problema con uno dei pin. È possibile utilizzare questo schizzo, che imposta tutti i pin in alto uno per uno per 5 secondi e successivamente mette l'ESP8266 in modalità di sospensione profonda per 20 secondi. Per consentire all'ESP8266 di riattivarsi dopo il sonno profondo, è necessario collegare RST a GPIO16, che fornisce il segnale di riattivazione.

Passaggio 5: caricamento dello schizzo

Ho reso disponibile il codice su GitHub, è solo un file: Level-Sensor-Deepsleep.ino. Basta scaricarlo e aprirlo nell'IDE di Arduino. Oppure puoi selezionare File - Nuovo e semplicemente copiare/incollare il codice.

Ci sono alcune informazioni che devi inserire all'inizio del file: il nome e la password della WLAN da utilizzare, i dettagli dell'IP statico e l'ID del canale e la chiave API di scrittura del canale ThingSpeak.

Seguendo il suggerimento su questo blog, invece del DHCP in cui il router assegna dinamicamente un IP, utilizziamo l'IP statico, in cui impostiamo noi stessi l'indirizzo IP dell'ESP8266. Questo risulta essere molto più veloce, quindi risparmiamo sul tempo attivo e quindi sull'energia della batteria. Quindi dobbiamo fornire un indirizzo IP statico disponibile così come l'IP del router (gateway), la subnet mask e un server DNS. Se non sei sicuro di cosa compilare, leggi informazioni sull'impostazione di un IP statico nel manuale del tuo router. Su un computer Windows connesso tramite Wifi al tuo router, avvia una shell (Windows button-r, cmd) e inserisci ipconfig /all. Troverai la maggior parte delle informazioni di cui hai bisogno nella sezione Wi-Fi.

Esaminando il codice si vede che, a differenza di altri codici Arduino, la maggior parte dell'azione avviene nella funzione di configurazione anziché nella funzione di ciclo. Questo perché ESP8266 va in modalità di sospensione profonda dopo aver terminato la funzione di configurazione (a meno che non sia stato avviato in modalità OTA). Dopo che si è svegliato, è come un nuovo riavvio ed esegue di nuovo l'installazione.

Ecco le caratteristiche salienti del codice:

• Dopo il risveglio, il codice imposta switchPin (GPIO15 predefinito) su alto. Questo accende il transistor, che a sua volta accende il sensore HC-SR04-P. Prima di andare in deep sleep riporta il pin al minimo, spegnendo il transistor e l'HC-SR04-P, assicurandosi che non consumi altra preziosa batteria.
• Se il modePIN (default GPIO14) è basso il codice va in modalità OTA invece che in modalità misurazione. Con OTA (aggiornamento over-the-air) possiamo aggiornare il firmware tramite Wifi anziché tramite porta seriale. Nel nostro caso questo è abbastanza conveniente poiché non dobbiamo più collegare l'adattatore seriale a USB per ulteriori aggiornamenti. Basta impostare GPIO14 su basso (con l'interruttore OTA nel circuito elettronico), ripristinare ESP8266 (con l'interruttore di ripristino) e dovrebbe diventare disponibile nell'IDE Arduino per il caricamento.
• Sul PIN analogico (A0) misuriamo la tensione della batteria. Questo ci consente di spegnere il nostro dispositivo, ovvero il sonno profondo permanente, se la tensione diventa troppo bassa, al di sotto di minVoltage, per proteggere le batterie da una scarica eccessiva. La misurazione analogica non è molto accurata, eseguiamo numMeasuresBattery (default 10) misure e prendiamo la media per migliorare la precisione.
• La misurazione della distanza del sensore HC-SR04-P viene eseguita nella funzione DistanceMeasurement. Per migliorare la precisione, la misurazione viene ripetuta numMeasuresDistance (predefinito 3 volte).
• C'è una funzione per calcolare lo speedOfSound dalla misura di temperatura, umidità e pressione dal sensore BME280. L'indirizzo I2C predefinito del BME280 è 0x76, ma se non funziona potrebbe essere necessario cambiarlo in 0x77: bool bme280Started=bme280.begin(0x77);
• Useremo il BME280 in modalità forzata, il che significa che richiede una misurazione e torna in modalità di sospensione per risparmiare energia.
• Se si imposta capacità (l), fullDistance (cm) e area (m2), il codice calcola il volume residuo del serbatoio dell'acqua dalla misura della distanza: double rimanenteVolume=capacity+10.0*(fullDistance-distanza)*area; e caricalo su ThingSpeak. Se mantieni i valori di default carica la distanza dalla superficie dell'acqua in cm.

Passaggio 6: costruire il circuito elettronico

Sopra c'è lo schema del circuito elettronico. È abbastanza grande per una breadboard, specialmente con la piastra adattatore sovradimensionata e il trucco con i fili a forma di U. Ad un certo punto avrei certamente voluto usare l'alternativa di collegare due breadboard, ma alla fine ci sono riuscito.

Ecco le caratteristiche importanti del circuito:

• Ci sono due tensioni che giocano un ruolo: la tensione in ingresso dalla batteria (circa 3,75 V) e la 3,3 V che alimenta l'ESP8266 e il BME280. Ho messo il 3,3 V sul binario sinistro del breakboard e il 3,75 V sul binario destro. Il regolatore di tensione converte i 3,75 V in 3,3 V. Seguendo le istruzioni nella scheda tecnica ho aggiunto condensatori da 1 μF all'ingresso e all'uscita del regolatore di tensione per aumentare la stabilità.
• GPIO15 dell'ESP8266 è collegato al gate del transistor. Ciò consente all'ESP8266 di accendere il transistor e quindi il sensore a ultrasuoni quando è attivo e di spegnerlo quando si entra nel sonno profondo.
• GPIO14 è collegato a uno switch, lo switch OTA. La chiusura dell'interruttore dà il segnale all'ESP8266 che vogliamo avviare in modalità OTA, ovvero dopo aver premuto (chiuso e aperto) l'interruttore RESET e caricato un nuovo schizzo over-the-air.
• I pin RST e GPIO2 sono collegati come nello schema di programmazione. Il pin RST è ora collegato anche a GPIO16 per consentire all'ESP8266 di svegliarsi dal sonno profondo.
• I pin TRIG ed ECHO del sensore ad ultrasuoni sono collegati a GPIO12 e GPIO13, mentre i pin SCL e SDA del BME280 sono collegati a GPIO5 e GPIO4.
• Infine, il pin analogico ADC è tramite un partitore di tensione collegato alla tensione di ingresso. Questo permette di misurare la tensione di ingresso per verificare la carica delle batterie. Il pin ADC può misurare tensioni tra 0V e 1V. Per il partitore di tensione abbiamo scelto resistori da 100K e 470K. Ciò significa che la tensione al pin ADC è data da: V_ADC = 100K/(100K+470K) V_in. Prendendo V_ADC=1V questo significa che possiamo misurare tensioni di ingresso fino a V_in=570/100 V_ADC = 5.7V. Per quanto riguarda il consumo di energia c'è anche una perdita di corrente attraverso il partitore di tensione. Con V_in=3.75V dalle batterie troviamo I_leak = 3.75V/570K=6.6 μA.

Anche quando il circuito funziona a batterie, è possibile collegare l'USB all'adattatore seriale. Assicurati solo di scollegare VCC dall'adattatore e di collegare GND, RX e TX come nel diagramma di programmazione. Ciò consente di aprire il monitor seriale nell'IDE di Arduino per leggere i messaggi di debug e assicurarsi che tutto funzioni come previsto.

Per il circuito completo ho misurato un consumo di corrente di 50 μA in deep sleep quando funzionava con le batterie. Ciò include l'ESP8266, il BME280, il sensore a ultrasuoni (disattivato dal transistor) e le perdite attraverso il partitore di tensione e forse altre perdite. Quindi non è poi così male!

Ho scoperto che il tempo totale attivo è di circa 7 secondi, di cui 4,25 secondi per connettersi al Wifi e 1,25 secondi per inviare i dati a ThingSpeak. Quindi con una corrente attiva di 80 mA ho trovato 160 μAh all'ora per il tempo attivo. Aggiungendo 50 μAh all'ora per lo stato di sonno profondo abbiamo in totale 210 μAh all'ora. Ciò significa che le batterie da 2600 mAh durano teoricamente 12400 ore=515 giorni. Questo è il massimo assoluto se potessimo utilizzare la piena capacità delle batterie (che non è il caso) e non ci sono perdite che non ho trovato con le mie misurazioni attuali. Quindi devo ancora vedere se questo funziona davvero.

Passaggio 7: finitura del sensore

Ho messo il sensore in un contenitore di plastica da 1 litro, che conteneva la zuppa. In basso ho fatto due fori per incastrare gli "occhi" del sensore HC-SR04-P. A parte i fori, il contenitore dovrebbe essere impermeabile. Viene poi fissato alla parete del serbatoio dell'acqua con un anello circolare che normalmente viene utilizzato per un tubo di scarico dell'acqua piovana.

Buon divertimento con il progetto!