Un micro-bit Dive-O-Meter: 8 passos (amb imatges)

2024 Autora: John Day | [email protected]. Última modificació: 2024-01-30 08:15

L’estiu ja és aquí, és temps de piscina!

Una bona oportunitat per portar-vos a vosaltres mateixos i al vostre micro: bit fora a la piscina i, en aquest cas, fins i tot a la piscina.

El micro-bit immersió-o-mesurador que es descriu aquí és un senzill indicador de profunditat de bricolatge que us permet mesurar la profunditat que esteu fent o que esteu fent. Consisteix només en un micro: bit, un paquet de bateries o LiPo, un connector de vora per al micro: bit, un sensor de pressió baromètrica BMP280 o BME280 i alguns cables de pont. L'ús de l'enviro Pimoroni: bit does fa que les coses siguin cada vegada més senzilles. Tot això està empaquetat en dues capes de bosses de plàstic o silicona transparents estancs, amb alguns pesos afegits per compensar la força de flotació.

És una aplicació del dispositiu de sensor de pressió micro: bits que havia descrit en una instrucció prèvia.

Podeu utilitzar el dispositiu e. g. per a competicions de busseig amb amics i familiars, o per conèixer la profunditat de l’estany. El vaig provar amb la piscina més profunda del meu barri i vaig comprovar que funciona com a mínim fins a una profunditat de 3,2 metres. Al voltant de cinc metres és el màxim teòric. Fins ara no he provat la seva precisió amb cap detall, però les xifres reportades estaven, com a mínim, dins del rang esperat.

Algunes observacions: no es pretén que sigui una eina per a bussejadors reals. El vostre micro: bit es danyarà si es mulla. Utilitzeu aquesta instrucció pel vostre compte i risc.

Actualització 27 de maig: ara podeu trobar un script HEC MakeCode que podeu carregar directament al vostre micro: bit. Vegeu el pas 6. Actualització del 13 de juny: S'ha afegit una versió Enviro: bit i una versió per cable. Vegeu els passos 7 i 8

Pas 1: la teoria darrere del dispositiu

Vivim al fons d’un oceà d’aire. La pressió aquí baix és d'aproximadament 1020 hPa (hectoPascal), ja que el pes de la columna d'aire que es forma aquí a l'espai és d'aproximadament 1 kg per centímetre quadrat.

La densitat d’aigua és molt més gran, ja que un litre d’aire pesa aproximadament 1,2 g i un litre d’aigua 1 kg, és a dir, aproximadament 800 vegades. Així doncs, com la caiguda de la pressió baromètrica és d’aproximadament 1 hPa per cada 8 metres d’alçada, el guany de pressió és d’1 hPa per cada centímetre per sota de la superfície de l’aigua. A una profunditat d’uns 10 m, la pressió és de 2000 hPa, o sigui, dues atmosferes.

El sensor de pressió utilitzat aquí té un rang de mesura entre 750 i 1500 hPa a una resolució d’aproximadament una hPa. Això significa que podem mesurar profunditats de fins a 5 metres a una resolució d’uns 1 cm.

El dispositiu seria un mesurador de profunditat tipus Boyle Marriotte. El seu muntatge és força senzill i es descriu en un pas posterior. El sensor utilitza el protocol I2C, de manera que resulta útil un connector de vora per al micro: bit. La part més crítica són les bosses estances, ja que qualsevol humitat danyarà el micro: bit, el sensor o la bateria. Com que hi haurà una mica d’aire atrapat dins de les bosses, l’addició de pesos ajuda a compensar la força de flotació.

Pas 2: utilitzar el dispositiu

El guió, tal com es mostra detalladament en un pas posterior, és una variació d’un guió que vaig desenvolupar anteriorment per a un mesurador de pressió. Per provar el dispositiu, podeu utilitzar la càmera de pressió simple que s’hi descriu.

A efectes de busseig, mostra la profunditat en metres, calculada a partir de mesures de pressió, ja sigui com a gràfic de barres en passos de 20 cm o, a petició, en números.

Mitjançant el botó A del bit micro: definireu la pressió actual com a valor de pressió de referència. Per confirmar l'entrada, la matriu parpelleja una vegada.

Podeu fer servir això per veure fins a quin punt bussegeu o per registrar la profunditat que esteu fent.

En el primer cas, configureu la pressió actual de l'aire exterior com a referència. En el segon cas, configureu la pressió en el punt més profund on us trobareu com a referència de pressió, cosa que us permetrà mostrar la profunditat que heu tingut quan torneu a la superfície. El botó B mostra la profunditat, calculada a partir de la diferència de pressió, com a valor numèric en metres.

Pas 3: materials necessaris

Un micro: bit. Per exemple. a 13 GBP / 16 euros a Pimoroni UK / DE.

Un connector de vora (Kitronic o Pimoroni), 5 GBP. He utilitzat la versió Kitronic.

Un sensor BMP / BME280. Vaig utilitzar un sensor BMP280 de Banggood, 4,33 euros per a tres unitats.

Cables de pont per connectar el sensor i el connector de vora.

Una excel·lent alternativa a la combinació de connectors de vora / sensor anteriors podria ser Pimoroni enviro: bit (no provat ara, vegeu el darrer pas).

Un paquet de bateries o LiPo per al micro: bit.

Un cable d’alimentació amb interruptor (opcional però útil). Esborreu les bosses estances. Vaig fer servir una bossa de silicona per a un telèfon mòbil i una o dues bosses petites amb cremallera. Assegureu-vos que el material sigui prou gruixut perquè els passadors del connector de la vora no danyin les bosses.

Alguns pesos. He fet servir peces de pes de plom que s’utilitzen per pescar.

Arduino IDE i diverses biblioteques.

Pas 4: Muntatge

Instal·leu l'IDE Arduino i les biblioteques necessàries. Els detalls es descriuen aquí.

(No és necessari per a l'script MakeCode.) Donat que utilitzeu el connector de vora Kitronik, soldeu els pins als ports I2C 19 i 20. Això no és necessari per al connector de vora Pimoroni. Soldeu la capçalera a la sortida del sensor i connecteu el sensor i el connector de vora mitjançant cables de pont. Connecteu VCC a 3V, GND a 0 V, SCL al port 19 i SDA al port 20. També podeu soldar els cables directament al brot. Connecteu el micro: bit al nostre ordinador mitjançant un cable USB. Obriu l'script proporcionat i feu-lo passar al micro: bit. Utilitzeu el monitor o el traçador sèrie, comproveu si el sensor proporciona dades raonables. Desconnecteu el micro: bit de l'ordinador. Connecteu la bateria o el LiPo al micro: bit. Premeu el botó B, llegiu el valor Premeu el botó A. Premeu el botó B, llegiu el valor. Col·loqueu el dispositiu en dues capes de bosses hermètiques, deixant només molt poc aire a les bosses. En el cas, col·loqueu un pes per compensar la força de flotabilitat. Comproveu si tot és estanc. Aneu a la piscina i jugueu.

Pas 5: l’escriptura MicroPython

El guió només pren el valor de pressió del sensor, el compara amb el valor de referència i calcula la profunditat a partir de la diferència. Per mostrar els valors com a gràfic de barres, es prenen la part sencera i la part restant del valor de profunditat. El primer defineix l'alçada de la línia. La resta es divideix en cinc contenidors, que sí que defineixen la longitud de les barres. El nivell superior és de 0 a 1 m, el més baix de 4 a 5 m. Com s’ha esmentat abans, en prémer el botó A s’estableix la pressió de referència, el botó B mostra la "profunditat relativa" en metres, que es mostra com a valor numèric. A hores d’ara, els valors negatius i positius es presenten com a gràfic de barres a la matriu de LEDs de la mateixa manera. No dubteu a optimitzar el script per a les vostres necessitats. Podeu deixar de silenciar certes línies per presentar els valors al monitor sèrie o al traçador de l'IDE Arduino. Per emular la funció, podeu construir el dispositiu que he descrit en una instrucció prèvia.

No he escrit la part del script que llegeix el sensor. No estic segur de la font, però vull donar les gràcies als autors. Qualsevol correcció o consell d’optimització és benvinguda.

#incloure

#include Adafruit_Microbit_Matrix microbit; #define BME280_ADDRESS 0x76 unsigned long int hum_raw, temp_raw, pres_raw; signat llarg 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; doble press_norm = 1015; // un valor inicial de doble profunditat; // profunditat calculada // -------------------------------------------- -------------------------------------------------- ---------------------- void setup () {uint8_t osrs_t = 1; // Mostreig excessiu de temperatura x 1 uint8_t osrs_p = 1; // Mostreig excessiu de pressió x 1 uint8_t osrs_h = 1; // Mostreig excessiu d’humitat x 1 mode uint8_t = 3; // Mode normal uint8_t t_sb = 5; // Tstandby 1000ms uint8_t filter = 0; // Filtra uint8_t spi3w_en = 0; // Desactivar SPI de 3 fils uint8_t ctrl_meas_reg = (osrs_t << 5) | (osrs_p << 2) | mode; uint8_t config_reg = (t_sb << 5) | (filtre << 2) | spi3w_en; uint8_t ctrl_hum_reg = osrs_h; pinMode (PIN_BUTTON_A, INPUT); pinMode (PIN_BUTTON_B, INPUT); Serial.begin (9600); // configurar la velocitat del port sèrie Serial.print ("Pressió [hPa]"); // capçalera per a la sortida sèrie Wire.begin (); writeReg (0xF2, ctrl_hum_reg); writeReg (0xF4, ctrl_meas_reg); writeReg (0xF5, config_reg); readTrim (); // microbit.begin (); // microbit.print ("x"); retard (1000); } // ----------------------------------------------- ---------------------------------------------- bucle buit () {double temp_act = 0,0, press_act = 0,0, hum_act = 0,0; signat llarg int temp_cal; unsigned long int press_cal, hum_cal; int N; int M; doble press_delta; // pressió relativa int profunditat_m; // profunditat en metres, part sencera doble profunditat_cm; // resta en cm readData (); // temp_cal = calibration_T (temp_raw); press_cal = calibration_P (pres_raw); // hum_cal = calibration_H (hum_raw); // temp_act = (doble) temp_cal / 100,0; press_act = (doble) press_cal / 100.0; // hum_act = (doble) hum_cal / 1024.0; microbit.clear (); // restableix la matriu LED // El botó A estableix el valor real com a referència (P zero) // El botó B mostra el valor actual com a profunditat en metres (calculat a partir de la diferència de pressió) si (! digitalRead (PIN_BUTTON_A)) {// estableix la pressió d’aire normal com zero press_norm = press_act; // microbit.print ("P0:"); // microbit.print (press_norm, 0); // microbit.print ("hPa"); microbit.fillScreen (LED_ON); // parpelleja una vegada per confirmar el retard (100); } else if (! digitalRead (PIN_BUTTON_B)) {// mostra la profunditat en metres microbit.print (profunditat, 2); microbit.print ("m"); // Serial.println (""); } else {// calcular la profunditat a partir de la diferència de pressió press_delta = (press_act - press_norm); // calcular la profunditat de pressió relativa = (press_delta / 100); // profunditat en metres depth_m = int (abs (profunditat)); // profunditat im metres profunditat_cm = (abs (profunditat) - profunditat_m); // restant / * // utilitzat per al desenvolupament Serial.println (profunditat); Serial.println (profunditat_m); Serial.println (cm_ profunditat); * / // Passos per al gràfic de barres if (profunditat_cm> 0,8) {// estableix la longitud de les barres (N = 4); } else if (profunditat_cm> 0,6) {(N = 3); } else if (profunditat_cm> 0,4) {(N = 2); } else if (profunditat_cm> 0,2) {(N = 1); } else {(N = 0); }

if (depth_m == 4) {// set level == meter

(M = 4); } else if (depth_m == 3) {(M = 3); } else if (profunditat_m == 2) {(M = 2); } else if (depth_m == 1) {(M = 1); } else {(M = 0); // fila superior} / * // s'utilitza amb finalitats de desenvolupament Serial.print ("m:"); Serial.println (profunditat_m); Serial.print ("cm:"); Serial.println (cm_ profunditat); Serial.print ("M:"); Serial.println (M); // a efectes de desenvolupament Serial.print ("N:"); Serial.println (N); // amb finalitats de desenvolupament retard (500); * / // dibuixar bargraph microbit.drawLine (0, M, N, M, LED_ON); }

// enviar valor al port sèrie per al traçador

Serial.print (press_delta); // dibuixar línies indicadores i corregir l'interval mostrat Serial.print ("\ t"); Serial.print (0); Serial.print ("\ t"); Serial.print (-500); Serial.print ("\ t"); Serial.println (500); retard (500); // Mesura dues vegades per segon} // ----------------------------------------- -------------------------------------------------- -------------------------------------------------- -------- // es requereix el següent per al sensor bmp / bme280, mantingueu-lo tal com és buit readTrim () {uint8_t data [32], i = 0; // Corregiu 2014 / Wire.beginTransmission (BME280_ADDRESS); Wire.write (0x88); Wire.endTransmission (); Wire.requestFrom (BME280_ADDRESS, 24); // Corregiu 2014 / while (Wire.available ()) {data = Wire.read (); i ++; } Wire.beginTransmission (BME280_ADDRESS); // Afegeix 2014 / Wire.write (0xA1); // Afegeix 2014 / Wire.endTransmission (); // Afegeix 2014 / Wire.requestFrom (BME280_ADDRESS, 1); // Afegeix 2014 / data = Wire.read (); // Afegeix 2014 / i ++; // Afegeix 2014 / Wire.beginTransmission (BME280_ADDRESS); Wire.write (0xE1); Wire.endTransmission (); Wire.requestFrom (BME280_ADDRESS, 7); // Corregiu 2014 / while (Wire.available ()) {data = Wire.read (); i ++; } dig_T1 = (dades [1] << 8) | dades [0]; dig_P1 = (dades [7] << 8) | dades [6]; dig_P2 = (dades [9] << 8) | dades [8]; dig_P3 = (dades [11] << 8) | dades [10]; dig_P4 = (dades [13] << 8) | dades [12]; dig_P5 = (dades [15] << 8) | dades [14]; dig_P6 = (dades [17] << 8) | dades [16]; dig_P7 = (dades [19] << 8) | dades [18]; dig_T2 = (dades [3] << 8) | dades [2]; dig_T3 = (dades [5] << 8) | dades [4]; dig_P8 = (dades [21] << 8) | dades [20]; dig_P9 = (dades [23] << 8) | dades [22]; dig_H1 = dades [24]; dig_H2 = (dades [26] << 8) | dades [25]; dig_H3 = dades [27]; dig_H4 = (dades [28] << 4) | (0x0F i dades [29]); dig_H5 = (dades [30] 4) & 0x0F); // Fix 2014 / dig_H6 = data [31]; // Corregiu 2014 /} void writeReg (uint8_t reg_address, uint8_t data) {Wire.beginTransmission (BME280_ADDRESS); Wire.write (adreça_reg); Wire.write (dades); Wire.endTransmission (); } void readData () {int i = 0; dades uint32_t [8]; Wire.beginTransmission (BME280_ADDRESS); Wire.write (0xF7); Wire.endTransmission (); Wire.requestFrom (BME280_ADDRESS, 8); while (Wire.available ()) {data = Wire.read (); i ++; } pres_raw = (dades [0] << 12) | (dades [1] 4); temp_raw = (dades [3] << 12) | (dades [4] 4); hum_raw = (dades [6] 3) - ((signat int llarg) dig_T1 11; var2 = (((((adc_T >> 4) - ((signat int llarg) dig_T1)) * ((adc_T >> 4) - ((signat int llarg) dig_T1))) >> 12) * ((signat int llarg) dig_T3)) >> 14; t_fine = var1 + var2; T = (t_fine * 5 + 128) >> 8; retorna T; } unsigned long int calibration_P (firm long int adc_P) {firm long int var1, var2; unsigned long int P; var1 = (((firm long int) t_fine) >> 1) - (firm long int) 64000; var2 = (((var1 >> 2) * (var1 >> 2)) >> 11) * ((signat int llarg) dig_P6); var2 = var2 + ((var1 * ((signat int llarg) dig_P5)) 2) + (((signat int llarg) dig_P4) 2) * (var1 >> 2)) >> 13)) >> 3) + ((((signat int llarg) dig_P2) * var1) >> 1)) >> 18; var1 = (((((32768 + var1)) * ((int llarg signat) dig_P1)) >> 15); if (var1 == 0) {return 0; } P = (((int llarg sense signar) (((int llarg signat) 1048576) -adc_P) - (var2 >> 12))) * 3125; if (P <0x80000000) {P = (P << 1) / ((unsigned long int) var1); } else {P = (P / (int llarg sense signar) var1) * 2; } var1 = (((signat int llarg) dig_P9) * ((signat int llarg) (((P >> 3) * (P >> 3)) >> 13))) >> 12; var2 = (((int llarg signat) (P >> 2)) * ((int llarg signat) dig_P8)) >> 13; P = (int llarg sense signar) ((int llarg signat) P + ((var1 + var2 + dig_P7) >> 4)); retorn P; } unsigned long int calibration_H (signat long int adc_H) {signat long int v_x1; v_x1 = (t_fine - ((signat int llarg) 76800)); v_x1 = ((((((adc_H << 14) - (((signat int llarg) dig_H4) 15) * (((((((v_x1 * ((signat int llarg) dig_H6)) >> 10) * (((v_x1 * ((int llarg signat) dig_H3)) >> 11) + ((int llarg signat) 32768))) >> 10) + ((int llarg signat) 2097152)) * ((int llarg signat) dig_H2) + 8192) >> 14)); v_x1 = (v_x1 - ((((((v_x1 >> 15) * (v_x1 >> 15)) >> 7) * ((signat int llarg) dig_H1)) >> 4)); v_x1 = (v_x1 419430400? 419430400: v_x1); return (int llarg sense signar) (v_x1 >> 12);

Pas 6: una simplificació important: el codi MakeCode / JavaScript

Al maig de 2018, Pimoroni ha llançat l'enviro: bit, que inclou un sensor de pressió / humitat / temperatura BME280, un sensor de llum i color TCS3472 i un micròfon MEMS. A més, ofereixen una biblioteca JavaScript per a l’editor MakeCode i una biblioteca MicroPython per a aquests sensors.

He estat utilitzant la seva biblioteca MakeCode per desenvolupar scripts per al meu dispositiu. Adjunt trobareu els fitxers hexadecimals corresponents, que podeu copiar directament al vostre micro: bit.

A continuació trobareu el codi JavaScript corresponent. Les proves a la piscina van funcionar bé amb una versió anterior del guió, de manera que suposo que també funcionaran. A més de la versió bàsica de gràfics de barres, també hi ha una versió de mirada (X) i una versió en L, destinades a facilitar la lectura, sobretot en condicions de poca llum. Tria la que prefereixis.

deixem Columna = 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 (Meter> = 400) {Fila = 4} else if (Meter> = 300) {Fila = 3} else if (Meter> = 200) {Fila = 2} else if (Meter> = 100) {Fila = 1} else {Fila = 0} stay = Meter - Fila * 100 if (restar> = 80) {Columna = 4} else if (restar> = 60) {Columna = 3} else if (restar> = 40) {Columna = 2} else if (stay> = 20) {Column = 1} else {Column = 0} for (let ColA = 0; ColA <= Column; ColA ++) {led.plot (C olA, Fila)} basic.pause (500)}})

Pas 7: la versió Enviro: bit

Mentrestant, vaig rebre l'enviro: bit (20 GBP) i la potència: bit (6 GBP), tots dos de Pimoroni.

Com es va esmentar abans, l'enviro: bit ve amb el sensor de pressió, humitat i temperatura BME280, però també un sensor de llum i color (vegeu una aplicació aquí) i un micròfon MEMS.

El poder: bit és una bona solució per alimentar el micro: bit i ve amb un interruptor d’encès / apagat.

El millor és que tots dos són només fer clic i utilitzar, sense soldadura, cables, taulers de suport. Afegiu l'enviro: bit al micro: bit, carregueu el codi al micro: bit, utilitzeu-lo.

En aquest cas, he utilitzat micro, power i enviro: bit, els he posat en una bossa Ziploc, els he posat en una bossa de plàstic transparent per a telèfons mòbils, llesta. Una solució molt ràpida i ordenada. Veure les imatges. El commutador és prou gran per utilitzar-lo a través de les capes de protecció.

S'ha provat en aigua, funcionava bé. A una profunditat d’uns 1,8 m, el valor mesurat era d’uns 1,7 m. No està gens malament per a una solució ràpida i econòmica, però lluny de ser perfecta. Es triga un temps a ajustar-se, de manera que és possible que hagueu de romandre a una certa profunditat durant uns 10-15 segons.

Pas 8: versió de la sonda del cable i del sensor

Aquesta va ser en realitat la primera idea que es va tenir per a un micro: mesurador de profunditat de bits, l'última que es va construir.

Aquí vaig soldar el sensor BMP280 a 5 m d’un cable de 4 fils i vaig col·locar el pont femení a l’altre extrem. Per protegir el sensor de l'aigua, el cable es feia passar per un tap de vi usat. Els extrems del suro es van segellar amb cola calenta. Abans havia tallat dues osques al suro, totes dues anant al seu voltant. Després vaig empaquetar el sensor en una bola d’esponja, hi vaig col·locar un globus al voltant i vaig fixar l’extrem del globus al suro (osca inferior). després vaig col·locar 3 peces de 40 g de peses de plom en un segon globus, les vaig embolicar al voltant del primer, les peses es van col·locar al costat exterior i vaig fixar l’extrem del globus a la segona osca. L’aire es va treure del segon globus i tot es va arreglar amb cinta adhesiva. Vegeu imatges, potser se seguiran més detallades.

Els ponts es van connectar al micro: bit mitjançant un connector de vora, es va encendre el dispositiu i es va configurar la pressió de referència. Després, el cap del sensor es va alliberar lentament fins al fons de la piscina (torre de salt de 10 m, aproximadament 4,5 m de profunditat).

Resultats:

Per a la meva sorpresa, funcionava fins i tot amb aquest llarg cable. D'altra banda, però no sorprèn, l'error de mesura semblava ser més gran a pressions més altes, i es va informar que una profunditat estimada de 4 m era d'aproximadament 3 m.

Aplicacions potencials:

Amb algunes correccions d'errors, es pot utilitzar el dispositiu per mesurar la profunditat fins a uns 4 m.

Juntament amb un Arduino o Raspberry Pi, es podria utilitzar per mesurar i controlar el punt d’ompliment d’una piscina o dipòsit d’aigua, per exemple. per evocar un avís si els nivells de l'aigua superen o baixen certs llindars.

Subcampió del Outdoor Fitness Challenge