Mesureu la pressió amb el vostre micro: bit: 5 passos (amb imatges)

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

A continuació, es descriu un dispositiu fàcil de construir i econòmic per realitzar mesures de pressió i demostrar la llei de Boyle, utilitzant el bit micro: combinat amb el sensor de pressió / temperatura BMP280.

Tot i que aquesta combinació de xeringa / sensor de pressió ja s’ha descrit en un dels meus instructables anteriors, la combinació amb el micro: bit ofereix noves oportunitats, per exemple. per a projectes d’aula.

A més, el nombre de descripcions d’aplicacions en què s’utilitza el micro: bit en combinació amb un sensor impulsat per I2C fins ara és bastant limitat. Espero que aquesta instrucció pugui ser un punt de partida per a altres projectes.

El dispositiu permet realitzar mesures quantitatives de pressió d'aire i mostrar els resultats a la matriu de LEDs micro: bits o en un ordinador connectat, per a la posterior utilització de les funcions de monitor serial o plotter de l'IDE Arduino. A més, teniu una retroalimentació hàptica, ja que empenyeu o estireu el pistó de la xeringa vosaltres mateixos i sentireu la potència necessària.

Per defecte, la pantalla us permet estimar la pressió segons l'indicador de nivell que es mostra a la matriu de LED. El traçador sèrie de l’IDE Arduino permet fer el mateix, però amb una resolució molt millor (vegeu el vídeo). També hi ha solucions més elaborades, per exemple en l'idioma de processament. També podeu visualitzar els valors mesurats de pressió i temperatura a la matriu de LED després de prémer els botons A o B respectivament, però el monitor sèrie de l’Arduino IDE és molt més ràpid, cosa que permet mostrar valors gairebé en temps real.

Els costos totals i les habilitats tècniques necessàries per construir el dispositiu són força baixos, de manera que podria ser un bon projecte d’aula sota la supervisió d’un professor. A més, el dispositiu podria ser una eina per a projectes STEM amb enfocament a la física o utilitzat en altres projectes on una força o pes es transformi en un valor digital.

El principi es va utilitzar per construir un micro: bit dive-o-meter molt simple, un dispositiu per mesurar la profunditat que busseja.

Addenda 27-maig-2018:

Com que Pimoroni ha desenvolupat una biblioteca MakeCode per al sensor BMP280, això em va donar l'oportunitat de desenvolupar un script que s'utilitzarà per al dispositiu aquí descrit. L'escriptura i el fitxer HEX corresponent es poden trobar a l'últim pas d'aquesta instrucció. Per utilitzar-lo, només cal carregar el fitxer HEX al vostre micro: bit. No necessiteu programari especial i podeu utilitzar l'editor MakeCode en línia per editar l'script.

Pas 1: materials usats

• Un micro: bit, el meu de Pimoroni: 13,50 GBP
• Connector Kitronic Edge per micro: bit - mitjançant Pimoroni - 5 GBP, Nota: Pimorini ara ofereix un connector de vora compatible amb taulers anomenat pin: bit amb pins als ports I2C.
• Tires de capçalera de 2 x 2 pins
• Bateria o LiPo per al micro: bit (no necessari, però útil), cable de bateria amb interruptor (dito) - Pimoroni
• cables jumper per a la connexió de sensors al connector Edge
• cables de pont llarg (!) per al sensor, almenys tan llargs com la xeringa,, f / f o f / m
• Sensor de pressió i temperatura BMP280 - Banggood - 5 dòlars EUA per a tres unitats El rang de mesura d’aquest sensor és d’entre 550 i 1537 hPa.
• Xeringa de catèter de plàstic de 150 ml amb junta de goma - Amazon o botigues de ferreteria i jardí - aproximadament entre 2 i 3 dòlars EUA
• pistola de cola calenta / cola calenta
• soldador
• un ordinador amb l’IDE Arduino instal·lat

Pas 2: Instruccions de muntatge

Capçaleres de soldadura cap al trencament del sensor BMP280.

Soldeu els dos capçals de 2 pins als connectors pin 19 i pin 20 del connector Edge (vegeu la imatge).

Connecteu el bit micro: al connector Edge i a l'ordinador.

Prepareu el programari i el micro: bit tal com es descriu a les instruccions d'Adafruit micro: bit. Llegiu-los a fons.

Instal·leu les biblioteques necessàries a l'IDE Arduino.

Obriu l'script BMP280 adjunt en un pas posterior.

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

Pengeu l'script al micro: bit.

Comproveu que el sensor proporciona dades raonables; els valors de pressió haurien de ser al voltant de 1020 hPa, que es mostren al monitor sèrie. En el cas, comproveu primer els cables i les connexions, després la instal·lació del programari i correcte.

Apagueu micro: bit, traieu el sensor.

Feu passar els cables de pont llarg per la sortida de la xeringa. En cas que pugueu haver d'ampliar l'obertura. Aneu amb compte d’ometre que els cables es danyin.

Connecteu el sensor als cables del pont. Comproveu que les connexions siguin correctes i bones. Connecteu-vos al micro: bit.

Comproveu que el sensor funcioni correctament. Tirant amb cura dels cables, moveu el sensor cap a la part superior de la xeringa.

Introduïu l'èmbol i moveu-lo una mica més enllà de la posició de descans desitjada (100 ml).

Afegiu cola calenta al final de la sortida de la xeringa i torneu a moure l’èmbol una mica. Comproveu si la xeringa està tancada hermèticament, si no, afegiu-hi més cola calenta. Deixem refredar la cola calenta.

Comproveu de nou que el sensor funciona. Si moveu l'èmbol, els números del monitor sèrie i la pantalla del micro: bit haurien de canviar.

Si cal, podeu ajustar el volum de la xeringa estrenyent-lo a prop de la junta i moure l'èmbol.

Pas 3: una mica de teoria i algunes mesures pràctiques

Amb el dispositiu descrit aquí, podeu demostrar la correlació de compressió i pressió en experiments de física senzills. Com que la xeringa inclou una escala de "ml", fins i tot els experiments quantitatius són fàcils de realitzar.

La teoria que hi ha darrere: Segons la llei de Boyle, [Volum * Pressió] és un valor constant per a un gas a una temperatura determinada.

Això significa que si comprimeu un volum determinat de gas N-fold, és a dir, el volum final és 1 / N fold de l'original, la seva pressió augmentarà N-fold, com: P0 * V0 = P1 * V1 = contra t. Per obtenir més detalls, consulteu l'article de Wikipedia a les lleis del gas. A nivell del mar, la pressió baromètrica sol estar en el rang de 1010 hPa (hecto Pascal).

Així doncs, començant per un punt de repòs, per exemple, V0 = 100 ml i P0 = 1000 hPa, una compressió de l’aire a uns 66 ml (és a dir, V1 = 2/3 * V0) donarà lloc a una pressió d’uns 1500 hPa (P1 = 3/2 de P0). Tirar l’èmbol fins a 125 ml (5/4 vegades el volum) es tradueix en una pressió d’uns 800 hPa (pressió 4/5). Les mesures són increïblement precises per a un dispositiu tan senzill.

El dispositiu permet tenir una impressió tàctil directa de la força que es necessita per comprimir o expandir la quantitat d’aire relativament petita de la xeringa.

Però també podem fer alguns càlculs i comprovar-los experimentalment. Suposem que comprimim l’aire a 1500 hPa, a una pressió baromètrica basal de 1000 hPa. Per tant, la diferència de pressió és de 500 hPa, o 50.000 Pa. Per a la meva xeringa, el diàmetre (d) del pistó és d’uns 4 cm o 0,04 metres.

Ara podeu calcular la força necessària per mantenir el pistó en aquesta posició. Donat P = F / A (la pressió és força dividida per àrea), o transformat F = P * A. La unitat SI de força és "Newton" N, per a la longitud "Metre" m, i 1 Pa és 1 N per metre quadrat. Per a un pistó rodó, l'àrea es pot calcular utilitzant A = ((d / 2) ^ 2) * pi, que dóna 0,00125 metres quadrats per a la meva xeringa. Tan

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

A la Terra, 1 N es correlaciona amb un pes de 100 gr, de manera que 63 N són iguals a mantenir un pes de 6,3 kg.

Es pot comprovar fàcilment mitjançant una escala. Premeu la xeringa amb l'èmbol a la bàscula, fins que s'assoleixi una pressió d'aproximadament 1500 hPa, i després llegiu la bàscula. O premeu fins que la bàscula mostri uns 6-7 kg i, a continuació, premeu el botó "A" i llegiu el valor que es mostra a la matriu LED del micro: bit. Com va resultar, l'estimació basada en els càlculs anteriors no va ser dolenta. Una pressió lleugerament superior a 1500 hPa es correlaciona amb un "pes" visualitzat d'aproximadament 7 kg en una escala corporal (vegeu les imatges). També podeu canviar aquest concepte i utilitzar el dispositiu per construir una bàscula digital senzilla basada en mesures de pressió.

Tingueu en compte que el límit superior del sensor és d'aproximadament 1540 hPa, de manera que no es pot mesurar la pressió superior a aquesta i pot danyar-lo.

A més de propòsits educatius, també es pot utilitzar el sistema per a algunes aplicacions del món real, ja que permet mesurar quantitativament les forces que intenten moure l'èmbol d'una manera o d'una altra. Per tant, podríeu mesurar un pes col·locat sobre l'èmbol o una força d'impacte que colpejava sobre l'èmbol. O bé construïu un commutador que activi una llum o un brunzidor o que reprodueixi un so després d’assolir un determinat valor llindar. O podríeu construir un instrument musical que canviés la freqüència en funció de la força de la força aplicada al pistó. O utilitzeu-lo com a controlador de jocs. Utilitzeu la vostra imaginació i jugueu.

Pas 4: l’escriptura MicroPython

Adjunt trobareu el meu script BMP280 per al micro: bit. És un derivat d'un script BMP / BME280 que vaig trobar en algun lloc del lloc web Banggood, combinat amb la biblioteca Microbit d'Adafruit. El primer us permet utilitzar el sensor Banggood, el segon simplifica la manipulació de la pantalla LED 5x5. El meu agraïment es dirigeix als desenvolupadors de tots dos.

Per defecte, l'script mostra els resultats de les mesures de pressió en 5 passos a la pantalla LED 5x5 del micro: bit, cosa que permet veure els canvis amb poc retard. Els valors precisos es poden visualitzar en paral·lel al monitor sèrie Arduino IDE o es pot mostrar un gràfic més detallat al traçador seral de l'IDE Arduino.

Si premeu el botó A, es mostraran els valors de pressió mesurats a la matriu de LED 5x5 del micro: bit. Si premeu el botó B, es mostraran els valors de temperatura. Tot i que això permet llegir les dades precises, alenteix significativament els cicles de mesura.

Estic segur que hi ha maneres molt més elegants de programar les tasques i millorar el guió. Qualsevol ajuda és benvinguda.

#include xxx

#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; // contenidors per a valors mesurats valor int 0; valor int1; valor int2; valor int3; valor int4; // ------------------------------------------------ -------------------------------------------------- ------------------ 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); // Serial.println ("Temperatura [grau C]"); // Serial.print ("\ t"); Serial.print ("Pressió [hPa]"); // capçalera Wire.begin (); writeReg (0xF2, ctrl_hum_reg); writeReg (0xF4, ctrl_meas_reg); writeReg (0xF5, config_reg); readTrim (); // microbit.begin (); // microbit.print ("x"); retard (1000); } // ----------------------------------------------- -------------------------------------------------- -------- void loop () {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; // estableix valors llindars per a visualització de matriu de LED, en hPa doble màxim_0 = 1100; doble màxim_1 = 1230; doble màxim_2 = 1360; doble màxim_3 = 1490; 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 (); // restablir la matriu 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 valors en números retarda la mesura dels cercles 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 {// mostrant valors de pressió com a píxels o línies en un nivell determinat // 5 passos: 1490 hPa // llindars definits pels valors 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); } else {(N = 4); // fila base} // Serial.println (N); // a efectes de desenvolupament // microbit.print (N); // com a línia // microbit.drawLine (N, 0, 0, 4, LED_ON); // canvia els valors a la següent línia valor 4 = valor3; valor3 = valor2; valor2 = valor1; valor1 = valor0; valor0 = N; // dibuixar imatge, columna per columna microbit.drawPixel (0, valor0, LED_ON); // com a píxel: columna, fila. 0, 0 cantonada superior esquerra microbit.drawPixel (1, valor1, LED_ON); microbit.drawPixel (2, valor2, LED_ON); microbit.drawPixel (3, valor3, LED_ON); microbit.drawPixel (4, valor4, LED_ON); } // enviar dades al monitor serial i al plotter en sèrie // Serial.println (press_act); // enviar valors al port sèrie per a la visualització numèrica, opcional

Serial.print (press_act); // enviar valor al port sèrie per al traçador

// dibuixar línies indicadores i corregir l'interval mostrat Serial.print ("\ t"); Serial.print (600); Serial.print ("\ t"); Serial.print (1100), Serial.print ("\ t"); Serial.println (1600); retard (200); // Mesura tres vegades per segon} // ---------------------------------------- -------------------------------------------------- -------------------------------------------------- - // es requereix el següent per al sensor bmp / bme280, mantingueu-lo com a 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] << 8) | dades [7]; }

long long calibrated_T signat (int long signat adc_T)

{sign long int var1, var2, T; var1 = (((((adc_T >> 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; retorn T;} calibratge int llarg sense signar_P (signat llarg int adc_P) {signat llarg int var1, var2; sense signar llarg int P; var1 = (((signat llarg int) t_fine) >> 1) - (signat llarg int) 64000; var2 = (((var1 >> 2) * (var1 >> 2)) >> 11) * ((signat llarg int) dig_P6); var2 = var2 + ((var1 * ((signat llarg int) 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 * ((signat int llarg) dig_H3)) >> 11) + ((signat int llarg) 32768))) >> 10) + ((signat int llarg) 2097152)) * ((signat int llarg) 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 5: MakeCode / Scripts de JavaScript

Pimoroni ha llançat recentment l'enviro: bit, que ve amb un sensor de pressió BMP280, un sensor de llum / color i un micròfon MEMS. També ofereixen una biblioteca MicroPython i una biblioteca MakeCode / JavaScript.

Vaig utilitzar el posterior per escriure un script MakeCode per al sensor de pressió. El fitxer hexadecimal corresponent es pot copiar directament al vostre micro: bit. El codi es mostra a continuació i es pot modificar mitjançant l'editor MakeCode en línia.

És una variació del guió per al micro: bit dive-o-meter. Per defecte, mostra la diferència de pressió com a gràfic de barres. En prémer el botó A es defineix la pressió de referència, en prémer el botó B es mostra la diferència entre la pressió real i la de referència en hPa.

A més de la versió bàsica de codi de barres, també trobareu una versió "X", una mirada i una versió "L", destinades a facilitar la lectura.

deixem Columna = 0

deixem = 0 deixem Fila = 0 deixem Metre = 0 deixem Delta = 0 deixem Ref = 0 deixem 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 (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 (ColA, Row)} basic.pause (500)}})