Mida la presión con su micro: bit: 5 pasos (con imágenes)

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

El siguiente instructivo describe un dispositivo económico y fácil de construir para realizar mediciones de presión y demostrar la ley de Boyle, usando el micro: bit en combinación con el sensor de presión / temperatura BMP280.

Mientras que esta combinación de jeringa / sensor de presión ya se describió en uno de mis instructivos anteriores, la combinación con micro: bit ofrece nuevas oportunidades, p. Ej. para proyectos de salón de clases.

Además, el número de descripciones de aplicaciones en las que el micro: bit se utiliza en combinación con un sensor impulsado por I2C es bastante limitado hasta ahora. Espero que este instructable pueda ser un punto de partida para otros proyectos.

El dispositivo permite realizar mediciones cuantitativas de presión de aire y mostrar los resultados en la matriz de LED de micro: bit o en una computadora conectada, para más tarde utilizando el monitor en serie o las funciones de plotter en serie del Arduino IDE. Además, tiene una retroalimentación háptica, ya que usted mismo empujará o tirará del émbolo de la jeringa y, de este modo, sentirá la potencia requerida.

De forma predeterminada, la pantalla le permite estimar la presión mediante el indicador de nivel que se muestra en la matriz de LED. El plotter serial del Arduino IDE permite hacer lo mismo, pero con mucha mejor resolución (ver video). También hay disponibles soluciones más elaboradas, p. Ej. en el idioma de procesamiento. También puede mostrar los valores medidos precisos de presión y temperatura en la matriz de LED después de presionar los botones A o B respectivamente, pero el monitor en serie del Arduino IDE es mucho más rápido, lo que permite mostrar valores casi en tiempo real.

Los costos totales y las habilidades técnicas requeridas para construir el dispositivo son bastante bajos, por lo que podría ser un buen proyecto en el aula bajo la supervisión de un maestro. Además, el dispositivo podría ser una herramienta para proyectos STEM con enfoque en la física o usarse en otros proyectos donde una fuerza o peso se transformará en un valor digital.

El principio se utilizó para construir un micro: bit dive-o-meter muy simple, un dispositivo para medir qué tan profundo estás buceando.

Anexo 27 de mayo de 2018:

Como Pimoroni ha desarrollado una biblioteca MakeCode para el sensor BMP280, esto me dio la oportunidad de desarrollar un script para usar con el dispositivo que se describe aquí. El script y el archivo HEX correspondiente se pueden encontrar en el último paso de este instructivo. Para usarlo, simplemente cargue el archivo HEX en su micro: bit. No es necesario ningún software especial y puede utilizar el editor MakeCode en línea para editar el script.

Paso 1: Materiales usados

• Un micro: bit, obtuve el mío de Pimoroni - 13,50 GBP
• Conector de borde Kitronic para micro: bit - a través de Pimoroni - 5 GBP, Observación: Pimorini ahora ofrece un conector de borde compatible con la placa de pruebas llamado pin: bit con pines en los puertos I2C.
• 2 tiras de encabezado de 2 pines
• Batería o LiPo para el micro: bit (no es necesario, pero útil), cable de batería con interruptor (dito) - Pimoroni
• cables de puente para la conexión de sensores al conector Edge
• cables de puente largos (!) para el sensor, al menos tan largos como la jeringa, f / fo f / m
• Sensor de presión y temperatura BMP280 - Banggood - 5 US $ por tres unidades El rango de medición para este sensor es entre 550 y 1537 hPa.
• Jeringa de catéter de plástico de 150 ml con junta de goma - Amazon o ferreterías y tiendas de jardinería - entre 2 y 3 dólares estadounidenses
• pistola de pegamento caliente / pegamento caliente
• soldador
• una computadora con el IDE de Arduino instalado

Paso 2: instrucciones de montaje

Suelde los cabezales a la ruptura del sensor BMP280.

Suelde los dos cabezales de 2 pines a los conectores de la clavija 19 y la clavija 20 del conector Edge (ver imagen).

Conecte el micro: bit al conector Edge y a su computadora.

Prepare el software y micro: bit como se describe en las instrucciones micro: bit de Adafruit. Léelos detenidamente.

Instale las bibliotecas necesarias en el IDE de Arduino.

Abra el script BMP280 adjunto en un paso posterior.

Conecte el sensor al conector Edge. GND a 0V, VCC a 3V, SCL al pin 19, SDA al pin 20.

Sube el script al micro: bit.

Verifique que el sensor proporcione datos razonables, los valores de presión deben estar alrededor de 1020 hPa, que se muestran en el monitor en serie. Por si acaso, compruebe primero los cables y las conexiones, luego la instalación del software y corrija.

Apague el micro: bit, retire el sensor.

Pase los cables de puente largos a través de la salida de la jeringa. En caso de que tenga que ensanchar la abertura. Tenga cuidado de omitir que los cables se dañen.

Conecte el sensor a los cables de puente. Verifique que las conexiones sean correctas y buenas. Conéctese al micro: bit.

Verifique que el sensor esté funcionando correctamente. Tirando con cuidado de los cables, mueva el sensor a la parte superior de la jeringa.

Inserte el émbolo y muévalo un poco más allá de la posición de reposo deseada (100 ml).

Agregue pegamento caliente al final de la salida de la jeringa y mueva el émbolo un poco hacia atrás. Compruebe si la jeringa está cerrada herméticamente; de lo contrario, agregue más pegamento caliente. Deje enfriar el pegamento termofusible.

Verifique nuevamente que el sensor esté funcionando. Si mueve el émbolo, los números en el monitor de serie y la pantalla del micro: bit deberían cambiar.

Si es necesario, puede ajustar el volumen de la jeringa apretándola cerca de la junta y moviendo el émbolo.

Paso 3: un poco de teoría y algunas medidas prácticas

Con el dispositivo que se describe aquí, puede demostrar la correlación de la compresión y la presión en sencillos experimentos de física. Como la jeringa viene con una escala de "ml", incluso los experimentos cuantitativos son fáciles de realizar.

La teoría detrás de esto: según la ley de Boyle, [Volumen * Presión] es un valor constante para un gas a una temperatura determinada.

Esto significa que si comprime un volumen dado de gas N veces, es decir, el volumen final es 1 / N veces del original, su presión aumentará N veces, como: P0 * V0 = P1 * V1 = cons t. Para obtener más detalles, consulte el artículo de Wikipedia sobre leyes de gas. A nivel del mar, la presión barométrica suele estar en el rango de 1010 hPa (hecto Pascal).

Entonces, comenzando en puntos de reposo de, por ejemplo, V0 = 100 ml y P0 = 1000 hPa, una compresión del aire a aproximadamente 66 ml (es decir, V1 = 2/3 * V0) dará como resultado una presión de aproximadamente 1500 hPa (P1 = 3/2 de P0). Al tirar del émbolo a 125 ml (volumen 5/4 veces) se obtiene una presión de aproximadamente 800 hPa (presión 4/5). Las medidas son asombrosamente precisas para un dispositivo tan simple.

El dispositivo le permite tener una impresión háptica directa de cuánta fuerza se requiere para comprimir o expandir la cantidad relativamente pequeña de aire en la jeringa.

Pero también podemos realizar algunos cálculos y verificarlos experimentalmente. Suponga que comprimimos el aire a 1500 hPa, a una presión barométrica basal de 1000 hPa. Entonces la diferencia de presión es 500 hPa, o 50, 000 Pa. Para mi jeringa, el diámetro (d) del pistón es de aproximadamente 4 cm o 0.04 metros.

Ahora puede calcular la fuerza necesaria para mantener el pistón en esa posición. Dado P = F / A (la presión es la fuerza dividida por el área), o F = P * A transformada. La unidad SI para la fuerza es "Newton" N, para la longitud "Metro" my 1 Pa es 1N por metro cuadrado. Para un pistón redondo, el área se puede calcular usando A = ((d / 2) ^ 2) * pi, lo que da 0.00125 metros cuadrados para mi jeringa. Entonces

50, 000 Pa * 0.00125 m ^ 2 = 63 N.

En la Tierra, 1 N se correlaciona con un peso de 100 gr, por lo que 63 N equivalen a sostener un peso de 6,3 kg.

Esto se puede comprobar fácilmente con una escala. Empuje la jeringa con el émbolo en la escala, hasta alcanzar una presión de aproximadamente 1500 hPa, luego lea la escala. O presione hasta que la báscula muestre alrededor de 6-7 kg, luego presione el botón "A" y lea el valor que se muestra en la matriz de LED del micro: bit. Al final resultó que, la estimación basada en los cálculos anteriores no fue mala. Una presión ligeramente superior a 1500 hPa se correlacionó con un "peso" mostrado de aproximadamente 7 kg en una báscula corporal (ver imágenes). También puede cambiar este concepto y usar el dispositivo para construir una báscula digital simple basada en mediciones de presión.

Tenga en cuenta que el límite superior para el sensor es de aproximadamente 1540 hPa, por lo que cualquier presión por encima de esta no se puede medir y puede dañar el sensor.

Además de los propósitos educativos, también se puede usar el sistema para algunas aplicaciones del mundo real, ya que permite medir cuantitativamente las fuerzas que intentan mover el émbolo de una forma u otra. Por lo tanto, podría medir un peso colocado sobre el émbolo o una fuerza de impacto que golpea el émbolo. O construya un interruptor que active una luz o un timbre o reproduzca un sonido después de que se alcance un cierto valor de umbral. O puede construir un instrumento musical que cambie la frecuencia dependiendo de la fuerza aplicada al émbolo. O utilícelo como controlador de juegos. ¡Use su imaginación y juegue!

Paso 4: el script de MicroPython

Adjunto encontrará mi script BMP280 para el micro: bit. Es un derivado de un script BMP / BME280 que encontré en algún lugar del sitio web de Banggood, combinado con la biblioteca Microbit de Adafruit. El primero le permite usar el sensor Banggood, el segundo simplifica el manejo de la pantalla LED de 5x5. Mi agradecimiento a los desarrolladores de ambos.

De forma predeterminada, el script muestra los resultados de las mediciones de presión en 5 pasos en la pantalla LED de 5x5 del micro: bit, lo que permite ver los cambios con poca demora. Los valores precisos se pueden mostrar en paralelo en el monitor serial Arduino IDE, o se puede mostrar un gráfico más detallado en el trazador seral del Arduino IDE.

Si presiona el botón A, los valores de presión medidos se muestran en la matriz de LED de 5x5 del micro: bit. Si presiona el botón B, se muestran los valores de temperatura. Si bien esto permite leer los datos precisos, ralentiza significativamente los ciclos de medición.

Estoy seguro de que hay formas mucho más elegantes de programar las tareas y mejorar el guión. Cualquier ayuda es bienvenida.

#include xxx

#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; // contenedores para valores medidos int value0; int value1; int value2; int value3; int value4; // ------------------------------------------------ -------------------------------------------------- ------------------ 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); // Serial.println ("Temperatura [grados C]"); // Serial.print ("\ t"); Serial.print ("Presión [hPa]"); // encabezado 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; // establecer valores de umbral para la pantalla de matriz LED, en hPa double max_0 = 1100; doble max_1 = 1230; doble max_2 = 1360; doble max_3 = 1490; 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 / * Serial.print ("PRESS:"); Serial.println (press_act); Serial.print ("hPa"); Serial.print ("TEMP:"); Serial.print ("\ t"); Serial.println (temp_act); * / if (! digitalRead (PIN_BUTTON_B)) {// mostrar valores en números retrasa los círculos de medición microbit.print ("T:"); microbit.print (temp_act, 1); microbit.print ("'C"); // Serial.println (""); } else if (! digitalRead (PIN_BUTTON_A)) {microbit.print ("P:"); microbit.print (press_act, 0); microbit.print ("hPa"); } else {// mostrando los valores de presión como píxeles o líneas en un cierto nivel // 5 pasos: 1490 hPa // umbrales definidos por los valores max_n if (press_act> max_3) {(N = 0); // fila superior} else if (press_act> max_2) {(N = 1); } else if (press_act> max_1) {(N = 2); } else if (press_act> max_0) {(N = 3); } más {(N = 4); // fila base} // Serial.println (N); // con fines de desarrollo // microbit.print (N); // como Línea // microbit.drawLine (N, 0, 0, 4, LED_ON); // cambia los valores a la siguiente línea value4 = value3; valor3 = valor2; valor2 = valor1; valor1 = valor0; valor0 = N; // dibujar imagen, columna por columna microbit.drawPixel (0, value0, LED_ON); // como Pixel: columna, fila. 0, 0 esquina superior izquierda microbit.drawPixel (1, value1, LED_ON); microbit.drawPixel (2, valor2, LED_ON); microbit.drawPixel (3, valor3, LED_ON); microbit.drawPixel (4, valor4, LED_ON); } // enviar datos al monitor serial y al plotter serial // Serial.println (press_act); // enviar valor (es) al puerto serie para visualización numérica, opcional

Serial.print (press_act); // enviar valor al puerto serie para trazador

// dibuja líneas indicadoras y arregla el rango mostrado Serial.print ("\ t"); Impresión de serie (600); Serial.print ("\ t"); Serial.print (1100), Serial.print ("\ t"); Serial.println (1600); retraso (200); // Mide tres 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 = (datos [6] << 8) | datos [7]; }

firmado largo int calibracion_T (firmado largo int adc_T)

{int largo con signo var1, var2, T; var1 = ((((adc_T >> 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 = (((igned long int) t_fine) >> 1) - (firmado 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 5: Scripts MakeCode / JavaScript

Pimoroni ha lanzado recientemente el enviro: bit, que viene con un sensor de presión BMP280, un sensor de luz / color y un micrófono MEMS. También ofrecen una biblioteca MicroPython y MakeCode / JavaScript.

Usé el último para escribir un script MakeCode para el sensor de presión. El archivo hexadecimal correspondiente se puede copiar directamente a su micro: bit. El código se muestra a continuación y puede modificarse utilizando el editor MakeCode en línea.

Es una variación del guión del micro: bit dive-o-meter. De forma predeterminada, muestra la diferencia de presión como un gráfico de barras. Al presionar el botón A se establece la presión de referencia, al presionar el botón B se muestra la diferencia entre la presión real y la de referencia en hPa.

Además de la versión básica de código de barras, también encontrará una versión "X", en forma de cruz y una versión "L", destinadas a facilitar la lectura.

let Column = 0

dejar permanecer = 0 dejar Row = 0 dejar Meter = 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 ("" + Delta + "hPa") basic.pause (200) basic.clearScreen ()} else {Is = envirobit.getPressure () Delta = Is - Ref Meter = Math.abs (Delta) if (Medidor> = 400) {Fila = 4} else if (Medidor> = 300) {Fila = 3} else if (Medidor> = 200) {Fila = 2} else if (Medidor> = 100) {Fila = 1} else {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 (ColA, Row)} pausa.básica (500)}})