A Micro:bit Dive-O-Meter: 8 passaggi (con immagini)

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

L'estate è arrivata, è tempo di piscina!

Una buona occasione per portare te stesso e il tuo micro:bit fuori, e in questo caso anche dentro, la piscina.

Il micro:bit dive-o-meter descritto qui è un semplice misuratore di profondità fai-da-te che ti consente di misurare quanto sei profondo, o stavi, immergendo. Consiste solo di un micro:bit, un pacco batteria o LiPo, un connettore edge per il micro:bit, un sensore di pressione barometrica BMP280 o BME280 e alcuni cavi jumper. L'utilizzo di Pimoroni enviro:bit rende le cose ancora più semplici. Tutto questo è confezionato in due strati di sacchetti di plastica trasparente o silicone a tenuta stagna, con l'aggiunta di alcuni pesi per compensare la forza di galleggiamento.

È un'applicazione del sensore di pressione micro:bit che avevo descritto in un precedente tutorial.

Puoi usare il dispositivo e. G. per le gare di immersioni con amici e familiari, o per scoprire quanto è profondo quello stagno. L'ho testato utilizzando la piscina più profonda del mio quartiere e ho scoperto che funziona almeno fino a una profondità di 3,2 metri. Circa cinque metri è il massimo teorico. Finora non ho testato la sua precisione in alcun dettaglio, ma i numeri riportati erano almeno nell'intervallo previsto.

Alcune osservazioni: questo non vuole essere uno strumento per veri subacquei. Il tuo micro:bit si danneggerà se si bagna. Usi questo istruibile a proprio rischio.

Aggiornamento 27 maggio: ora puoi trovare uno script HEX MakeCode che puoi caricare direttamente sul tuo micro: bit. Vedere il passaggio 6. Aggiornamento 13 giugno: aggiunta di un Enviro:bit e di una versione via cavo. Vedere i passaggi 7 e 8

Passaggio 1: la teoria dietro il dispositivo

Viviamo sul fondo di un oceano d'aria. La pressione quaggiù è di circa 1020 hPa (hectoPascal) poiché il peso della colonna d'aria nello spazio è di circa 1 kg per centimetro quadrato.

La densità dell'acqua è molto più alta, poiché un litro d'aria pesa circa 1,2 g e un litro d'acqua 1 kg, cioè circa 800 volte. Quindi, poiché il calo della pressione barometrica è di circa 1 hPa per ogni 8 metri di altezza, l'aumento di pressione è di 1 hPa per ogni centimetro sotto la superficie dell'acqua. Ad una profondità di circa 10 m, la pressione è di 2000 hPa, ovvero due atmosfere.

Il sensore di pressione qui utilizzato ha un campo di misura compreso tra 750 e 1500 hPa con una risoluzione di circa un hPa. Ciò significa che possiamo misurare profondità fino a 5 metri con una risoluzione di circa 1 cm.

Il dispositivo sarebbe un profondimetro di tipo Boyle Marriotte. Il suo montaggio è abbastanza semplice e descritto in un passaggio successivo. Il sensore utilizza il protocollo I2C, quindi un connettore edge per il micro:bit è utile. La parte più critica sono le buste stagne, in quanto l'eventuale umidità danneggerà il micro:bit, il sensore o la batteria. Poiché un po' d'aria sarà intrappolata all'interno delle borse, l'aggiunta di pesi aiuta a compensare la forza di galleggiamento.

Passaggio 2: utilizzo del dispositivo

Lo script, come mostrato in dettaglio in un passaggio successivo, è una variazione di uno script che ho sviluppato in precedenza per un misuratore di pressione. Per testare il dispositivo, puoi utilizzare la semplice camera a pressione ivi descritta.

Per le immersioni mostra la profondità in metri, calcolata dalle misurazioni della pressione, sotto forma di grafico a barre con incrementi di 20 cm o, su richiesta, in numeri.

Utilizzando il pulsante A del micro:bit, imposterai la pressione attuale come valore di pressione di riferimento. Per confermare l'inserimento, la matrice lampeggia una volta.

Puoi usarlo sia per vedere a che profondità ti stai immergendo, sia per registrare a quale profondità ti stavi immergendo.

Nel primo caso impostare come riferimento la pressione dell'aria esterna attuale. Nel secondo caso imposta la pressione nel punto più profondo in cui ti trovi come riferimento di pressione, che ti consente quindi di mostrare quanto sei stato profondo quando torni in superficie. Il pulsante B visualizza la profondità, calcolata dalla differenza di pressione, come valore numerico in metri.

Passaggio 3: materiali necessari

Un micro:bit. Per esempio. a 13 GBP/16 Euro presso Pimoroni UK/DE.

Un connettore edge (Kitronic o Pimoroni), 5 GBP. Ho usato la versione Kitronic.

Un sensore BMP/BME280. Ho usato un sensore BMP280 di Banggood, 4,33 Euro per tre unità.

Cavi jumper per collegare sensore e connettore per bordi.

Un'ottima alternativa alla combinazione connettore edge/sensore di cui sopra potrebbe essere Pimoroni enviro:bit (non ancora testato, vedere l'ultimo passaggio).

Un pacco batteria o LiPo per il micro:bit.

Un cavo di alimentazione con un interruttore (opzionale ma utile). Sacchetti stagni trasparenti. Ho usato una custodia in silicone per un telefono cellulare e una o due piccole buste ziploc. Assicurati che il materiale sia abbastanza spesso, in modo che i pin sul connettore del bordo non danneggino le borse.

Alcuni pesi. Ho usato pezzi di piombo che servono per la pesca.

Arduino IDE e diverse librerie.

Passaggio 4: assemblaggio

Installa l'IDE Arduino e le librerie richieste. I dettagli sono descritti qui.

(Non richiesto per lo script MakeCode.) Dato che utilizzi il connettore Edge Kitronik, saldare i pin alle porte I2C 19 e 20. Questo non è richiesto per il connettore edge Pimoroni. Saldare l'intestazione alla rottura del sensore e collegare il sensore e il connettore del bordo utilizzando i cavi jumper. Collegare VCC a 3V, GND a 0 V, SCL alla porta 19 e SDA alla porta 20. In alternativa, saldare i cavi direttamente al breakout. Collega il micro:bit al nostro computer tramite un cavo USB. Apri lo script fornito e esegui il flashing su micro: bit. Usa il monitor seriale o il plotter, controlla se il sensore fornisce dati ragionevoli. Scollega il micro:bit dal tuo computer. Collegare la batteria o LiPo al micro:bit. Premere il pulsante B, leggere il valore Premere il pulsante A. Premere il pulsante B, leggere il valore. Posizionare il dispositivo in due strati di sacchetti ermetici, lasciando solo pochissima aria nei sacchetti. Nel caso, posizionare un peso per compensare la forza di galleggiamento. Controlla se è tutto a tenuta stagna. Vai in piscina e gioca.

Passaggio 5: lo script MicroPython

Lo script prende semplicemente il valore della pressione dal sensore, lo confronta con il valore di riferimento e quindi calcola la profondità dalla differenza. Per visualizzare i valori come grafico a barre, vengono presi l'intero e la parte restante del valore di profondità. Il primo definisce l'altezza della linea. Il resto è suddiviso in cinque bin, che definiscono la lunghezza delle barre. Il livello più alto è 0 - 1 m, il più basso 4 - 5 m. Come accennato in precedenza, premendo il pulsante A si imposta la pressione di riferimento, il pulsante B visualizza la "profondità relativa" in metri, visualizzata come valore numerico. Ormai, i valori negativi e positivi sono presentati come grafico a barre sulla matrice LED allo stesso modo. Sentiti libero di ottimizzare lo script per le tue esigenze. È possibile riattivare determinate linee per presentare i valori sul monitor seriale o sul plotter dell'IDE Arduino. Per emulare la funzione, puoi costruire il dispositivo che ho descritto in una precedente istruzione.

Non ho scritto la parte dello script che legge il sensore. Non sono sicuro della fonte, ma ringrazio gli autori. Eventuali correzioni o suggerimenti per l'ottimizzazione sono i benvenuti.

#includere

#include Adafruit_Microbit_Matrix microbit; #define BME280_ADDRESS 0x76 unsigned long int hum_raw, temp_raw, pres_raw; firmato long int t_fine; uint16_t dig_T1; int16_t dig_T2; int16_t dig_T3; uint16_t dig_P1; int16_t dig_P2; int16_t dig_P3; int16_t dig_P4; int16_t dig_P5; int16_t dig_P6; int16_t dig_P7; int16_t dig_P8; int16_t dig_P9; int8_t dig_H1; int16_t dig_H2; int8_t dig_H3; int16_t dig_H4; int16_t dig_H5; int8_t dig_H6; doppia pressione_norm = 1015; // un valore iniziale double depth; // profondità calcolata //------------------------------------------- --------------------------------------------------- ---------------------- void setup() { uint8_t osrs_t = 1; //Sovracampionamento della temperatura x 1 uint8_t osrs_p = 1; //Sovracampionamento della pressione x 1 uint8_t osrs_h = 1; //Sovracampionamento dell'umidità x 1 uint8_t mode = 3; //Modalità normale uint8_t t_sb = 5; //Tstandby 1000ms uint8_t filter = 0; //Filtra uint8_t spi3w_en = 0; // Disabilita SPI a 3 fili uint8_t ctrl_meas_reg = (osrs_t << 5) | (osrs_p << 2) | modalità; uint8_t config_reg = (t_sb << 5) | (filtro <<2) | spi3w_it; uint8_t ctrl_hum_reg = osrs_h; pinMode(PIN_BUTTON_A, INPUT); pinMode(PIN_BUTTON_B, INPUT); Serial.begin(9600); // imposta la velocità della porta seriale Serial.print("Pressure [hPa] "); // header per l'output seriale Wire.begin(); writeReg(0xF2, ctrl_hum_reg); writeReg(0xF4, ctrl_meas_reg); writeReg(0xF5, config_reg); leggiTrim(); // microbit.begin(); // microbit.print("x"); ritardo (1000); } //------------------- ----------------- loop vuoto() { double temp_act = 0.0, press_act = 0.0, hum_act=0.0; firmato long int temp_cal; unsigned long int press_cal, hum_cal; int N; int M; doppia pressione_delta; // pressione relativa int profondità_m; // profondità in metri, parte intera double depth_cm; // resto in cm readData(); // temp_cal = calibrazione_T(temp_raw); press_cal = calibrazione_P(pres_raw); // hum_cal = calibrazione_H(hum_raw); // temp_act = (doppio)temp_cal / 100.0; press_act = (doppio)press_cal / 100.0; // hum_act = (doppio)hum_cal / 1024.0; microbit.clear(); //reset matrice LED // Il pulsante A imposta il valore effettivo come riferimento (P zero) // Il pulsante B visualizza il valore corrente come profondità in metri (calcolata dalla differenza di pressione) if (! digitalRead(PIN_BUTTON_A)) { // imposta la pressione dell'aria normale come zero press_norm = press_act; // microbit.print("P0: "); // microbit.print(press_norm, 0); // microbit.print(" hPa"); microbit.fillScreen(LED_ON); // lampeggia una volta per confermare il ritardo (100); }else if (! digitalRead(PIN_BUTTON_B)) { // visualizza la profondità in metri microbit.print(depth, 2); microbit.print("m"); // Serial.println(""); }else{ // calcola la profondità dalla differenza di pressione press_delta = (press_act - press_norm); // calcola la profondità di pressione relativa = (press_delta/100); // profondità in metri profondità_m = int(abs(profondità)); // profondità im metri profondità_cm = (abs(profondità) - profondità_m); // resto /* // usato per lo sviluppo Serial.println(depth); Serial.println(depth_m); Serial.println(profondità_cm); */ // Steps for bargraph if (depth_cm> 0.8){ // imposta la lunghezza delle barre (N=4); } else if (profondità_cm > 0,6){ (N=3); } else if (profondità_cm > 0,4){ (N=2); } else if (profondità_cm > 0.2){ (N=1); } else { (N=0); }

if (profondità_m == 4){ // imposta il livello == metro

(M=4); } else if (profondità_m == 3){ (M=3); } else if (profondità_m == 2){ (M=2); } else if (profondità_m == 1){ (M=1); } else { (M=0); // riga superiore } /* // utilizzata per scopi di sviluppo Serial.print("m: "); Serial.println(depth_m); Serial.print("cm: "); Serial.println(profondità_cm); Serial.print("M: "); Serial.println(M); // per scopi di sviluppo Serial.print("N: "); Serial.println(N); // per scopi di sviluppo delay(500); */ // disegna il grafico a barre microbit.drawLine(0, M, N, M, LED_ON); }

// invia il valore alla porta seriale per il plotter

Serial.print(press_delta); // disegna linee indicatrici e corregge l'intervallo visualizzato Serial.print("\t"); Serial.print(0); Serial.print("\t"); Serial.print(-500); Serial.print("\t"); Serial.println(500); ritardo (500); // Misura due volte al secondo } //--------------------------- --------------------------------------------------- --------------------------------------------------- -------- // quanto segue è richiesto per il sensore bmp/bme280, tienilo così com'è void readTrim() { uint8_t data[32], i=0; // Correzione 2014/Wire.beginTransmission(BME280_ADDRESS); Wire.write(0x88); Wire.endTransmission(); Wire.requestFrom(BME280_ADDRESS, 24); // Correzione 2014/while(Wire.available()){ data = Wire.read(); io++; } Wire.beginTransmission(BME280_ADDRESS); // Aggiungi 2014/Wire.write(0xA1); // Aggiungi 2014/Wire.endTransmission(); // Aggiungi 2014/Wire.requestFrom(BME280_ADDRESS, 1); // Aggiungi 2014/data = Wire.read(); // Aggiungi 2014/i++; // Aggiungi 2014/Wire.beginTransmission(BME280_ADDRESS); Wire.write(0xE1); Wire.endTransmission(); Wire.requestFrom(BME280_ADDRESS, 7); // Correzione 2014/while(Wire.available()){ data = Wire.read(); io++; } dig_T1 = (data[1] << 8) | dati[0]; dig_P1 = (data[7] << 8) | dati[6]; dig_P2 = (data[9] << 8) | dati[8]; dig_P3 = (data[11]<< 8) | dati[10]; dig_P4 = (data[13]<< 8) | dati[12]; dig_P5 = (data[15]<< 8) | dati[14]; dig_P6 = (data[17]<< 8) | dati[16]; dig_P7 = (data[19]<< 8) | dati[18]; dig_T2 = (data[3] << 8) | dati[2]; dig_T3 = (data[5] << 8) | dati[4]; dig_P8 = (data[21]<< 8) | dati[20]; dig_P9 = (data[23]<< 8) | dati[22]; dig_H1 = dati[24]; dig_H2 = (data[26]<< 8) | dati[25]; dig_H3 = dati[27]; dig_H4 = (data[28]<< 4) | (0x0F & dati[29]); dig_H5 = (data[30] 4) & 0x0F); // Fix 2014/dig_H6 = data[31]; // Fix 2014/} void writeReg(uint8_t reg_address, uint8_t data) { Wire.beginTransmission(BME280_ADDRESS); Wire.write(reg_address); Wire.write(dati); Wire.endTransmission(); } void readData() { int i = 0; uint32_t dati[8]; Wire.beginTransmission(BME280_ADDRESS); Wire.write(0xF7); Wire.endTransmission(); Wire.requestFrom(BME280_ADDRESS, 8); while(Wire.available()){ data = Wire.read(); io++; } pres_raw = (data[0] << 12) | (dati[1] 4); temp_raw = (data[3] << 12) | (dati[4] 4); hum_raw = (data[6] 3) - ((signed long int)dig_T1 11; var2 = (((((adc_T >> 4) - ((signed long int)dig_T1)) * ((adc_T>>4) - ((signed long int)dig_T1))) >> 12) * ((signed long int)dig_T3)) >> 14;t_fine = var1 + var2; T = (t_fine * 5 + 128) >> 8; return T; } unsigned long int calibrazione_P(signed long int adc_P) { firmato long int var1, var2; unsigned long int P; var1 = (((signed long int)t_fine)>>1) - (signed long int)64000; var2 = (((var1>>2) * (var1>>2)) >> 11) * ((signed long int)dig_P6); var2 = var2 + ((var1*((signed long int)dig_P5))2)+(((signed long int)dig_P4)2)*(var1>>2)) >> 13)) >>3) + (((signed long int)dig_P2) * var1)>>1))>>18; var1 = ((((32768+var1))*((signed long int)dig_P1))>>15); if (var1 == 0) { return 0; } P = (((unsigned long int)(((signed long int)1048576)-adc_P)-(var2>>12)))*3125; if(P<0x80000000) { P = (P <<1) / ((unsigned long int) var1); } else { P = (P / (unsigned long int)var1) * 2; } var1 = (((signed long int)dig_P9) * ((signed long int)(((P>>3) * (P>>3))>>13)))>>12; var2 = (((signed long int)(P>>2)) * ((signed long int)dig_P8))>>13; P = (unsigned long int)((signed long int)P + ((var1 + var2 + dig_P7) >> 4)); ritorno P; } unsigned long int calibrazione_H(signed long int adc_H) { firmato long int v_x1; v_x1 = (t_fine - ((signed long int)76800)); v_x1 = (((((adc_H << 14) -(((signed long int)dig_H4) 15)) * ((((((v_x1 * ((signed long int)dig_H6))) >> 10) * ((((v_x1 * ((signed long int)dig_H6))) (v_x1 * ((signed long int)dig_H3)) >> 11) + ((signed long int) 32768))) >> 10) + ((signed long int)2097152)) * ((signed long int) dig_H2) + 8192) >> 14)); v_x1 = (v_x1 - ((((v_x1 >> 15) * (v_x1 >> 15)) >> 7) * ((signed long int)dig_H1)) >> 4)); v_x1 = (v_x1 419430400 ? 419430400: v_x1); return (unsigned long int)(v_x1 >> 12);

Passaggio 6: una grande semplificazione: il codice MakeCode/JavaScript

A maggio 2018, Pimoroni ha rilasciato enviro:bit, che include un sensore di pressione/umidità/temperatura BME280, un sensore di luce e colore TCS3472 e un microfono MEMS. Inoltre offrono una libreria JavaScript per l'editor MakeCode e una libreria MicroPython per questi sensori.

Ho usato la loro libreria MakeCode per sviluppare script per il mio dispositivo. In allegato trovi i file esadecimali corrispondenti, che puoi copiare direttamente sul tuo micro:bit.

Di seguito trovi il codice JavaScript corrispondente. I test in pool hanno funzionato bene con una versione precedente dello script, quindi presumo che funzioneranno anche loro. Oltre alla versione base con bargraph, esiste anche una versione con mirino (X) e una versione L, pensata per facilitare la lettura, soprattutto in condizioni di scarsa illuminazione. Scegli quello che preferisci.

let Colonna = 0

let Meter = 0 let stay = 0 let Row = 0 let Delta = 0 let Ref = 0 let Is = 0 Is = 1012 basic.showLeds(` # # # # # #… # #. #. # #.. # # # # # # `) Ref = 1180 basic.clearScreen() basic.forever(() => { basic.clearScreen() if (input.buttonIsPressed(Button. A)) { Ref = envirobit.getPressure() basic.showLeds(` #. #. #. #. #. # # # # #. #. #. #. #. # `) basic.pause(1000) } else if (input.buttonIsPressed(Button. B)) { basic.showString("" + Row + "." + stay + " m") basic.pause(200) basic.clearScreen() } else { Is = envirobit.getPressure() Delta = Is - Ref Meter = Math.abs(Delta) if (Metro >= 400) { Riga = 4 } else if (Metro >= 300) { Riga = 3 } else if (Metro >= 200) { Riga = 2 } else if (Metro >= 100) { Riga = 1 } else { Riga = 0 } stay = Metro - Riga * 100 if (remain >= 80) { Column = 4 } else if (remain >= 60) { Column = 3 } else if (remain >= 40) { Colonna = 2 } else if (rimane >= 20) { Colonna = 1 } else { Colonna = 0 } for (lascia ColA = 0; ColA <= Colonna; ColA++) { led.plot(C olA, Riga) } basic.pause(500) } })

Passaggio 7: la versione Enviro:bit

Nel frattempo ho ricevuto l'enviro:bit (20 GBP) e il power:bit (6 GBP), entrambi da Pimoroni.

Come accennato in precedenza, enviro:bit viene fornito con il sensore di pressione, umidità e temperatura BME280, ma anche un sensore di luce e colore (vedi un'applicazione qui) e un microfono MEMS.

Il power:bit è una buona soluzione per alimentare il micro:bit e viene fornito con un interruttore on/off.

La cosa bella è che entrambi sono semplicemente cliccabili e utilizzabili, senza saldature, cavi, breadboard. Aggiungi l'enviro:bit al micro:bit, carica il codice nel micro:bit, usalo.

In questo caso ho usato micro, power e enviro:bit, li ho messi in una busta Ziploc, l'ho riposta in una busta di plastica trasparente a tenuta stagna per telefoni cellulari, pronta. Una soluzione molto veloce e ordinata. Guarda le immagini. Lo switch è abbastanza grande da poterlo utilizzare attraverso gli strati di protezione.

È stato testato in acqua, funzionava bene. Ad una profondità di circa 1,8 m il valore misurato era di circa 1,7 m. Non male per una soluzione veloce ed economica, ma lungi dall'essere perfetta. Ci vuole un po' di tempo per adattarsi, quindi potrebbe essere necessario rimanere a una certa profondità per circa 10-15 secondi.

Passaggio 8: versione della sonda con cavo e sensore

Questa in realtà è stata la prima idea che ho avuto per un misuratore di profondità micro:bit, l'ultima ad essere costruita.

Qui ho saldato il sensore BMP280 a 5 m di un cavo a 4 fili e ho posizionato un ponticello femmina all'altra estremità. Per proteggere il sensore dall'acqua, il cavo è stato fatto passare attraverso un tappo di sughero usato. Le estremità del tappo sono state sigillate con colla a caldo. Prima avevo fatto due tacche nel sughero, girandole tutt'intorno. Poi ho impacchettato il sensore in una palla di spugna, ci ho messo un palloncino attorno e ho fissato l'estremità del palloncino sul sughero (tacca inferiore). poi ho messo 3 pezzi di piombo da 40 g in un secondo palloncino, l'ho avvolto intorno al primo, i pesi posizionati sul lato esterno e ho fissato l'estremità del palloncino alla seconda tacca. L'aria è stata rimossa dal secondo pallone, quindi tutto è stato fissato con del nastro adesivo. Vedere le immagini, potrebbero seguire quelle più dettagliate.

I jumper sono stati collegati al micro:bit tramite un connettore edge, il dispositivo è stato acceso e la pressione di riferimento è stata impostata. Quindi la testa del sensore è stata rilasciata lentamente sul fondo della piscina (torre di salto di 10 m, profondità di circa 4,5 m).

Risultati:

Con mio grande stupore, ha funzionato anche con questo cavo lungo. D'altra parte, ma non sorprendentemente, l'errore di misurazione sembrava aumentare a pressioni più elevate e una profondità stimata di 4 m è stata riportata come circa 3 m.

Potenziali applicazioni:

Con alcune correzioni di errori, il dispositivo potrebbe essere utilizzato per misurare la profondità fino a circa 4 m.

In combinazione con un Arduino o un Raspberry Pi, questo potrebbe essere utilizzato per misurare e controllare il punto di riempimento di una piscina o di un serbatoio d'acqua, ad es. per evocare un avvertimento se i livelli dell'acqua vanno sopra o sotto determinate soglie.

Secondo classificato nella sfida di fitness all'aperto