Un Micro: bit Dive-O-Meter: 8 pasos (con imágenes)

2024 Autor: John Day | [email protected]. Última modificación: 2024-01-30 08:43

¡El verano está aquí, es hora de la piscina!

Una buena oportunidad para llevarse a usted y a su micro: un poco al exterior y, en este caso, incluso a la piscina.

El micro: bit dive-o-meter que se describe aquí es un simple medidor de profundidad de bricolaje que le permite medir qué tan profundo está o estuvo buceando. Consiste solo en un micro: bit, una batería o LiPo, un conector de borde para el micro: bit, un sensor de presión barométrica BMP280 o BME280 y algunos cables de puente. El uso de Pimoroni enviro: bit does hace que las cosas sean cada vez más simples. Todo esto está empaquetado en dos capas de plástico transparente o bolsas de silicona herméticas, con algunos pesos agregados para compensar la fuerza de flotación.

Es una aplicación del dispositivo sensor de presión micro: bit que describí en un instructivo anterior.

Puede utilizar el dispositivo e. gramo. para competiciones de buceo con amigos y familiares, o para averiguar qué tan profundo es ese estanque. Lo probé usando la piscina más profunda de mi vecindario y descubrí que funciona al menos a una profundidad de 3,2 metros. Aproximadamente cinco metros es el máximo teórico. Hasta ahora no he probado su precisión en detalle, pero los números reportados estaban al menos en el rango esperado.

Algunas observaciones: Esto no pretende ser una herramienta para buceadores reales. Su micro: bit se dañará si se moja. Utilice este instructable bajo su propio riesgo.

Actualización 27 de mayo: ahora puede encontrar un script HEX de MakeCode que puede cargar directamente en su micro: bit. Vea el paso 6. Actualización 13 de junio: Se agregaron un Enviro: bit y una versión de cable. Vea los pasos 7 y 8

Paso 1: la teoría detrás del dispositivo

Vivimos en el fondo de un océano de aire. La presión aquí abajo es de aproximadamente 1020 hPa (hectoPascal) ya que el peso de la columna de aire que se forma aquí en el espacio es de aproximadamente 1 kg por centímetro cuadrado.

La densidad del agua es mucho mayor, ya que un litro de aire pesa aproximadamente 1,2 gy un litro de agua 1 kg, es decir, aproximadamente 800 veces. Entonces, como la caída de la presión barométrica es de aproximadamente 1 hPa por cada 8 metros de altura, la ganancia de presión es de 1 hPa por cada centímetro debajo de la superficie del agua. A una profundidad de aproximadamente 10 m, la presión es de 2000 hPa, o dos atmósferas.

El sensor de presión utilizado aquí tiene un rango de medición entre 750 y 1500 hPa con una resolución de aproximadamente un hPa. Esto significa que podemos medir profundidades de hasta 5 metros con una resolución de aproximadamente 1 cm.

El dispositivo sería un medidor de profundidad tipo Boyle Marriotte. Su montaje es bastante sencillo y se describe en un paso posterior. El sensor usa el protocolo I2C, por lo que un conector de borde para el micro: bit es útil. La parte más crítica son las bolsas herméticas, ya que la humedad dañará el micro: bit, el sensor o la batería. Como algo de aire quedará atrapado dentro de las bolsas, la adición de pesos ayuda a compensar la fuerza de flotación.

Paso 2: uso del dispositivo

El guión, como se muestra en detalle en un paso posterior, es una variación de un guión que desarrollé anteriormente para un medidor de presión. Para probar el dispositivo, puede utilizar la cámara de presión simple que se describe allí.

Para fines de buceo, muestra la profundidad en metros, calculada a partir de las mediciones de presión, ya sea como un gráfico de barras en pasos de 20 cm o, a pedido, en números.

Usando el botón A en el micro: bit, establecerá la presión actual como valor de presión de referencia. Para confirmar la entrada, la matriz parpadea una vez.

Puede usar esto para ver qué tan profundo está buceando o para registrar qué tan profundo estaba buceando.

En el primer caso, configure la presión del aire exterior actual como referencia. En el segundo caso, establezca la presión en el punto más profundo en el que se encuentre como referencia de presión, que luego le permite mostrar qué tan profundo ha estado cuando está de regreso en la superficie. El botón B muestra la profundidad, calculada a partir de la diferencia de presión, como un valor numérico en metros.

Paso 3: Materiales necesarios

Un micro: bit. P.ej. a 13 GBP / 16 Euro en Pimoroni UK / DE.

Un conector de borde (Kitronic o Pimoroni), 5 GBP. Usé la versión de Kitronic.

Un sensor BMP / BME280. Usé un sensor BMP280 de Banggood, 4,33 euros por tres unidades.

Cables de puente para conectar el sensor y el conector de borde.

Una excelente alternativa a la combinación de conector de borde / sensor anterior podría ser Pimoroni enviro: bit (no probado por ahora, vea el último paso).

Un paquete de baterías o LiPo para el micro: bit.

Un cable de alimentación con un interruptor (opcional pero útil). Bolsas estancas transparentes. Usé una bolsa de silicona para un teléfono móvil y una o dos bolsas ziploc pequeñas. Asegúrese de que el material sea lo suficientemente grueso para que las clavijas del conector del borde no dañen las bolsas.

Algunos pesos. Usé trozos de plomo que se usan para pescar.

Arduino IDE y varias bibliotecas.

Paso 4: Montaje

Instale el IDE de Arduino y las bibliotecas necesarias. Los detalles se describen aquí.

(No es necesario para el script MakeCode). Dado que utiliza el conector de borde Kitronik, suelde los pines a los puertos I2C 19 y 20. Esto no es necesario para el conector de borde Pimoroni. Suelde el cabezal a la ruptura del sensor y conecte el sensor y el conector de borde con cables de puente. Conecte VCC a 3V, GND a 0 V, SCL al puerto 19 y SDA al puerto 20. Alternativamente, suelde los cables directamente a la conexión. Conectamos el micro: bit a nuestro ordenador mediante un cable USB. Abra la secuencia de comandos proporcionada y actualícela en micro: bit. Utilice el monitor en serie o el trazador, compruebe si el sensor proporciona datos razonables. Desconecte el micro: bit de su computadora. Conecte la batería o LiPo al micro: bit. Presione el botón B, lea el valor Presione el botón A. Presione el botón B, lea el valor. Coloque el dispositivo en dos capas de bolsas herméticas, dejando muy poco aire en las bolsas. En caso de que coloque un peso para compensar la fuerza de flotabilidad. Comprueba si todo es estanco. Ve a la piscina y juega.

Paso 5: el script de MicroPython

El script simplemente toma el valor de presión del sensor, lo compara con el valor de referencia y luego calcula la profundidad a partir de la diferencia. Para mostrar los valores como un gráfico de barras, se toman la parte entera y restante del valor de profundidad. El primero define la altura de la línea. El resto se divide en cinco contenedores, que definen la longitud de las barras. El nivel superior es de 0 a 1 m, el más bajo de 4 a 5 m. Como se mencionó anteriormente, al presionar el botón A se establece la presión de referencia, el botón B muestra la "profundidad relativa" en metros, que se muestra como un valor numérico. Por ahora, los valores negativos y positivos se presentan como gráficos de barras en la matriz de LED de la misma manera. Siéntase libre de optimizar el script para sus necesidades. Puede activar el sonido de ciertas líneas para presentar los valores en el monitor en serie o en el trazador del IDE de Arduino. Para emular la función, puede construir el dispositivo que describí en un instructivo anterior.

No he escrito la parte del script que lee el sensor. No estoy seguro de la fuente, pero me gusta agradecer a los autores. Cualquier corrección o sugerencia de optimización es bienvenida.

#incluir

#include Adafruit_Microbit_Matrix microbit; #define BME280_ADDRESS 0x76 unsigned long int hum_raw, temp_raw, pres_raw; firmado largo 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 profundidad; // profundidad calculada // -------------------------------------------- -------------------------------------------------- ---------------------- configuración vacía () {uint8_t osrs_t = 1; // Sobremuestreo de temperatura x 1 uint8_t osrs_p = 1; // Sobremuestreo de presión x 1 uint8_t osrs_h = 1; // Sobremuestreo de humedad x 1 uint8_t mode = 3; // Modo normal uint8_t t_sb = 5; // Tstandby 1000ms uint8_t filter = 0; // Filtrar uint8_t spi3w_en = 0; // Deshabilitar SPI de 3 cables uint8_t ctrl_meas_reg = (osrs_t << 5) | (osrs_p << 2) | modo; uint8_t config_reg = (t_sb << 5) | (filtro << 2) | spi3w_en; uint8_t ctrl_hum_reg = osrs_h; pinMode (PIN_BUTTON_A, ENTRADA); pinMode (PIN_BUTTON_B, ENTRADA); Serial.begin (9600); // establece la velocidad del puerto serie Serial.print ("Presión [hPa]"); // encabezado para salida en serie Wire.begin (); writeReg (0xF2, ctrl_hum_reg); writeReg (0xF4, ctrl_meas_reg); writeReg (0xF5, config_reg); readTrim (); // microbit.begin (); // microbit.print ("x"); retraso (1000); } // ----------------------------------------------- ---------------------------------------------- bucle vacío () {doble temp_act = 0.0, press_act = 0.0, hum_act = 0.0; firmado largo int temp_cal; unsigned long int press_cal, hum_cal; int N; int M; double press_delta; // presión relativa int profundidad_m; // profundidad en metros, parte entera double depth_cm; // resto en cm readData (); // temp_cal = calibración_T (temp_raw); press_cal = calibración_P (pres_raw); // hum_cal = calibración_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 (); // restablecer la matriz de LED // El botón A establece el valor real como referencia (P cero) // El botón B muestra el valor actual como profundidad en metros (calculado a partir de la diferencia de presión) if (! digitalRead (PIN_BUTTON_A)) {// establece la presión de aire normal como cero press_norm = press_act; // microbit.print ("P0:"); // microbit.print (press_norm, 0); // microbit.print ("hPa"); microbit.fillScreen (LED_ON); // parpadea una vez para confirmar el retraso (100); } else if (! digitalRead (PIN_BUTTON_B)) {// muestra la profundidad en metros microbit.print (profundidad, 2); microbit.print ("m"); // Serial.println (""); } else {// calcular la profundidad a partir de la diferencia de presión press_delta = (press_act - press_norm); // calcular la profundidad de presión relativa = (press_delta / 100); // profundidad en metros depth_m = int (abs (profundidad)); // profundidad en metros profundidad_cm = (abs (profundidad) - profundidad_m); // resto / * // utilizado para el desarrollo Serial.println (profundidad); Serial.println (profundidad_m); Serial.println (profundidad_cm); * / // Pasos para el gráfico de barras if (depth_cm> 0.8) {// establece la longitud de las barras (N = 4); } más si (profundidad_cm> 0,6) {(N = 3); } más si (profundidad_cm> 0.4) {(N = 2); } si no (profundidad_cm> 0,2) {(N = 1); } más {(N = 0); }

if (depth_m == 4) {// establecer el nivel == metro

(M = 4); } más si (profundidad_m == 3) {(M = 3); } más si (profundidad_m == 2) {(M = 2); } más si (profundidad_m == 1) {(M = 1); } más {(M = 0); // fila superior} / * // se utiliza con fines de desarrollo Serial.print ("m:"); Serial.println (profundidad_m); Serial.print ("cm:"); Serial.println (profundidad_cm); Serial.print ("M:"); Serial.println (M); // para fines de desarrollo Serial.print ("N:"); Serial.println (N); // para fines de desarrollo, retraso (500); * / // dibujar gráfico de barras microbit.drawLine (0, M, N, M, LED_ON); }

// enviar valor al puerto serie para trazador

Serial.print (press_delta); // dibuja líneas indicadoras y arregla el rango mostrado Serial.print ("\ t"); Serial.print (0); Serial.print ("\ t"); Serial.print (-500); Serial.print ("\ t"); Serial.println (500); retraso (500); // Mide dos veces por segundo} // ----------------------------------------- -------------------------------------------------- -------------------------------------------------- -------- // se requiere lo siguiente para el sensor bmp / bme280, manténgalo como vacío readTrim () {uint8_t data [32], i = 0; // Arreglar 2014 / Wire.beginTransmission (BME280_ADDRESS); Wire.write (0x88); Wire.endTransmission (); Wire.requestFrom (BME280_ADDRESS, 24); // Arreglar 2014 / while (Wire.available ()) {data = Wire.read (); i ++; } Wire.beginTransmission (BME280_ADDRESS); // Agregar 2014 / Wire.write (0xA1); // Agregar 2014 / Wire.endTransmission (); // Agregar 2014 / Wire.requestFrom (BME280_ADDRESS, 1); // Agregar 2014 / data = Wire.read (); // Agregar 2014 / i ++; // Agregar 2014 / Wire.beginTransmission (BME280_ADDRESS); Wire.write (0xE1); Wire.endTransmission (); Wire.requestFrom (BME280_ADDRESS, 7); // Arreglar 2014 / while (Wire.available ()) {data = Wire.read (); i ++; } dig_T1 = (datos [1] << 8) | datos [0]; dig_P1 = (datos [7] << 8) | datos [6]; dig_P2 = (datos [9] << 8) | datos [8]; dig_P3 = (datos [11] << 8) | datos [10]; dig_P4 = (datos [13] << 8) | datos [12]; dig_P5 = (datos [15] << 8) | datos [14]; dig_P6 = (datos [17] << 8) | datos [16]; dig_P7 = (datos [19] << 8) | datos [18]; dig_T2 = (datos [3] << 8) | datos [2]; dig_T3 = (datos [5] << 8) | datos [4]; dig_P8 = (datos [21] << 8) | datos [20]; dig_P9 = (datos [23] << 8) | datos [22]; dig_H1 = datos [24]; dig_H2 = (datos [26] << 8) | datos [25]; dig_H3 = datos [27]; dig_H4 = (datos [28] << 4) | (0x0F y datos [29]); dig_H5 = (datos [30] 4) & 0x0F); // Arreglar 2014 / dig_H6 = data [31]; // Arreglar 2014 /} void writeReg (uint8_t reg_address, uint8_t data) {Wire.beginTransmission (BME280_ADDRESS); Wire.write (reg_address); Wire.write (datos); Wire.endTransmission (); } vacío readData () {int i = 0; uint32_t datos [8]; Wire.beginTransmission (BME280_ADDRESS); Wire.write (0xF7); Wire.endTransmission (); Wire.requestFrom (BME280_ADDRESS, 8); while (Wire.available ()) {datos = Wire.read (); i ++; } pres_raw = (datos [0] << 12) | (datos [1] 4); temp_raw = (datos [3] << 12) | (datos [4] 4); hum_raw = (data [6] 3) - ((sign long int) dig_T1 11; var2 = (((((adc_T >> 4) - ((sign long int) dig_T1)) * ((adc_T >> 4) - ((int largo con signo) dig_T1))) >> 12) * ((int largo con signo) dig_T3)) >> 14; t_fine = var1 + var2; T = (t_fine * 5 + 128) >> 8; return T; } unsigned long int calibración_P (igned long int adc_P) {igned long int var1, var2; unsigned long int P; var1 = (((sign long int) t_fine) >> 1) - (sign long int) 64000; var2 = (((var1 >> 2) * (var1 >> 2)) >> 11) * ((int largo con signo) dig_P6); var2 = var2 + ((var1 * ((int largo con signo) dig_P5)) 2) + (((int largo con signo) dig_P4) 2) * (var1 >> 2)) >> 13)) >> 3) + ((((int largo con signo) dig_P2) * var1) >> 1)) >> 18; var1 = ((((32768 + var1)) * ((int largo con signo) dig_P1)) >> 15); if (var1 == 0) {return 0; } P = (((unsigned long int) (((sign 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 = (((int largo con signo) dig_P9) * ((int largo con signo) (((P >> 3) * (P >> 3)) >> 13))) >> 12; var2 = (((int largo con signo) (P >> 2)) * ((int largo con signo) dig_P8)) >> 13; P = (unsigned long int) ((sign long int) P + ((var1 + var2 + dig_P7) >> 4)); return P; } unsigned long int calibracion_H (firmado long int adc_H) {firmado long int v_x1; v_x1 = (t_fine - ((con signo largo int) 76800)); v_x1 = (((((adc_H << 14) - (((int largo con signo) dig_H4) 15) * ((((((v_x1 * ((int largo con signo) dig_H6)) >> 10) * (((v_x1 * ((int largo con signo) dig_H3)) >> 11) + ((int largo con signo) 32768))) >> 10) + ((int largo con signo) 2097152)) * ((int largo con signo) dig_H2) + 8192) >> 14)); v_x1 = (v_x1 - (((((v_x1 >> 15) * (v_x1 >> 15)) >> 7) * ((int largo con signo) dig_H1)) >> 4)); v_x1 = (v_x1 419430400? 419430400: v_x1); return (unsigned long int) (v_x1 >> 12);

Paso 6: Una simplificación importante: el código MakeCode / JavaScript

En mayo de 2018, Pimoroni lanzó el enviro: bit, que viene con un sensor de presión / humedad / temperatura BME280, un sensor de luz y color TCS3472 y un micrófono MEMS. Además, ofrecen una biblioteca JavaScript para el editor MakeCode y una biblioteca MicroPython para estos sensores.

He estado usando su biblioteca MakeCode para desarrollar scripts para mi dispositivo. Adjunto encontrará los archivos hexadecimales correspondientes, que puede copiar directamente a su micro: bit.

A continuación, encontrará el código JavaScript correspondiente. Las pruebas en el grupo funcionaron bien con una versión anterior del script, así que supongo que también funcionarán. Además de la versión básica con gráfico de barras, también hay una versión en forma de cruz (X) y una versión L, destinadas a facilitar la lectura, especialmente en condiciones de poca luz. Elija el que prefiera.

let Column = 0

let Meter = 0 dejar permanecer = 0 dejar Row = 0 dejar Delta = 0 dejar Ref = 0 dejar 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 ("" + Fila + "." + permanecer + "m") basic.pause (200) basic.clearScreen ()} else {Is = envirobit.getPressure () Delta = Is - Ref Meter = Math.abs (Delta) if (Meter> = 400) {Row = 4} else if (Meter> = 300) {Row = 3} else if (Meter> = 200) {Row = 2} else if (Meter> = 100) {Fila = 1} más {Fila = 0} permanecer = Medidor - Fila * 100 if (permanecer> = 80) {Columna = 4} else if (permanecer> = 60) {Columna = 3} else if (permanecer> = 40) {Columna = 2} else if (permanecer> = 20) {Column = 1} else {Column = 0} for (let ColA = 0; ColA <= Column; ColA ++) {led.plot (C olA, Fila)} basic.pause (500)}})

Paso 7: La versión de Enviro: bit

Mientras tanto, recibí el enviro: bit (20 GBP) y el power: bit (6 GBP), ambos de Pimoroni.

Como se mencionó anteriormente, el enviro: bit viene con el sensor de presión, humedad y temperatura BME280, pero también con un sensor de luz y color (ver una aplicación aquí) y un micrófono MEMS.

El power: bit es una buena solución para alimentar el micro: bit y viene con un interruptor de encendido / apagado.

Lo mejor es que ambos son solo hacer clic y usar, sin soldaduras, cables, placas de prueba. Agregue el enviro: bit al micro: bit, cargue su código al micro: bit, úselo.

En este caso usé micro, power y enviro: bit, los coloqué en una bolsa Ziploc, lo coloqué en una bolsa de plástico transparente hermética para teléfonos móviles, listo. Una solución muy rápida y ordenada. Vea las fotos. El interruptor es lo suficientemente grande para usarlo a través de las capas de protección.

Ha sido probado en agua, estaba funcionando bien. A una profundidad de aproximadamente 1,8 m, el valor medido fue de aproximadamente 1,7 m. No está mal para una solución rápida y barata, pero está lejos de ser perfecta. Se necesita un tiempo para adaptarse, por lo que es posible que deba permanecer a cierta profundidad durante unos 10-15 segundos.

Paso 8: Versión de sonda de sensor y cable

En realidad, esta fue la primera idea que se tuvo para un micro: medidor de profundidad de bits, el último en construirse.

Aquí soldé el sensor BMP280 a 5 m de un cable de 4 hilos y coloqué un puente hembra en el otro extremo. Para proteger el sensor del agua, el cable se pasó a través de un corcho de vino usado. Los extremos del corcho se sellaron con pegamento caliente. Antes había cortado dos muescas en el corcho, ambos rodeándolo. Luego empaqueté el sensor en una bola de esponja, coloqué un globo alrededor y fijé el extremo del globo en el corcho (muesca inferior). luego coloqué 3 piezas de 40 g de pesas de plomo en un segundo globo, lo envolví alrededor del primero, las pesas se colocaron en el lado exterior y fijé el extremo del globo en la segunda muesca. Se quitó el aire del segundo globo, luego se fijó todo con cinta adhesiva. Vea las imágenes, pueden aparecer otras más detalladas.

Los puentes se conectaron al micro: bit a través de un conector de borde, el dispositivo se encendió y se estableció la presión de referencia. Luego, la cabeza del sensor se soltó lentamente hasta el fondo de la piscina (torre de salto de 10 m, aproximadamente 4,5 m de profundidad).

Resultados:

Para mi asombro, funcionó incluso con este cable largo. Por otro lado, aunque no es sorprendente, el error de medición pareció aumentar a presiones más altas, y se informó que una profundidad estimada de 4 m era de aproximadamente 3 m.

Aplicaciones potenciales:

Con algunas correcciones de errores, el dispositivo podría usarse para medir la profundidad hasta aproximadamente 4 m.

Junto con un Arduino o Raspberry Pi, esto podría usarse para medir y controlar el punto de llenado de una piscina o tanque de agua, por ejemplo. para evocar una advertencia si los niveles de agua superan o están por debajo de ciertos umbrales.

Finalista en el desafío de fitness al aire libre