Mät tryck med din mikro: bit: 5 steg (med bilder)

2024 Författare: John Day | [email protected]. Senast ändrad: 2024-01-30 12:46

Följande instruerbara beskriver en lätt att bygga och billig enhet för att utföra tryckmätningar och demonstrera Boyles lag, med hjälp av micro: bit i kombination med BMP280 tryck/temperatursensor.

Medan denna spruta/trycksensorkombination redan har beskrivits i en av mina tidigare instruktioner, erbjuder kombinationen med micro: bit nya möjligheter, t.ex. för klassrumsprojekt.

Dessutom är antalet beskrivningar av applikationer där mikro: bit används i kombination med en I2C driven sensor hittills ganska begränsat. Jag hoppas att denna instruerbara kan vara en utgångspunkt för andra projekt.

Enheten gör det möjligt att utföra kvantitativa lufttrycksmätningar och visa resultaten på micro: bit LED -arrayen eller på en ansluten dator för senare med hjälp av den seriella bildskärmen eller serieplotterfunktionerna i Arduino IDE. Dessutom har du en haptisk feedback, eftersom du själv kommer att trycka eller dra i sprutans kolv och därmed känna den nödvändiga kraften.

Som standard kan du uppskatta trycket med nivåindikatorn som visas på LED -matrisen. Med serieplotteren på Arduino IDE kan du göra detsamma, men med mycket bättre upplösning (se video). Mer genomarbetade lösningar finns också tillgängliga, t.ex. på bearbetningsspråket. Du kan också visa de exakta uppmätta värdena för tryck och temperatur på LED -matrisen efter att ha tryckt på A respektive B -knapparna, men den seriella bildskärmen för Arduino IDE är mycket snabbare, så att värden kan visas i nästan realtid.

Totala kostnader och de tekniska färdigheter som krävs för att bygga enheten är ganska låga, så det kan vara ett trevligt klassrumsprojekt under överinseende av en lärare. Dessutom kan enheten vara ett verktyg för STEM -projekt med fokus på fysik eller användas i andra projekt där en kraft eller vikt ska omvandlas till ett digitalt värde.

Principen användes för att konstruera en mycket enkel micro: bit dive-o-meter, en enhet för att mäta hur djupt du dyker.

Tillägg 27-maj-2018:

Eftersom Pimoroni har utvecklat ett MakeCode -bibliotek för BMP280 -sensorn, gav detta mig möjlighet att utveckla ett skript som ska användas för den enhet som beskrivs här. Skriptet och motsvarande HEX-fil finns i det sista steget i denna instruerbara. För att använda den, ladda bara HEX -filen till din micro: bit. Inget behov av speciell programvara, och du kan använda online MakeCode -redigeraren för att redigera manuset.

Steg 1: Använda material

• En micro: bit, fick min från Pimoroni - 13,50 GBP
• Kitronic Edge Connector för micro: bit - via Pimoroni - 5 GBP, Anmärkning: Pimorini erbjuder nu en brödbräda -vänlig kantkontakt som heter pin: bit med pins på I2C -portarna.
• 2 x 2 -stifts huvudremsor
• Batteri eller LiPo för mikro: bit (inte nödvändigt, men användbart), batterikabel med strömbrytare (dito) - Pimoroni
• bygelkablar för anslutning av sensorer till Edge -kontakt
• långa (!) bygelkablar för sensorn, minst lika lång som sprutan,, f/f eller f/m
• BMP280 tryck- och temperaturgivare - Banggood - 5 US $ för tre enheter Mätområdet för denna sensor är mellan 550 och 1537 hPa.
• 150 ml plastkateterspruta med gummipackning - Amazon eller hårdvaru- och trädgårdsbutiker - cirka 2-3 US $
• varmt lim/varm limpistol
• lödkolv
• en dator med Arduino IDE installerat

Steg 2: Monteringsanvisningar

Lödhuvuden till sensorutbrottet BMP280.

Löd de två 2 -stiftshuvudena på stift 19 och stift 20 -kontakterna på Edge -kontakten (se bild).

Anslut micro: bit till Edge -kontakten och din dator.

Förbered programvara och micro: bit enligt beskrivningen i Adafruit micro: bit instruktionerna. Läs dem noga.

Installera de nödvändiga biblioteken till Arduino IDE.

Öppna BMP280 -skriptet som bifogas i ett senare steg.

Anslut sensorn till Edge -kontakten. GND till 0V, VCC till 3V, SCL till stift 19, SDA till stift 20.

Ladda upp skriptet till micro: bit.

Kontrollera att sensorn ger rimliga data, tryckvärden bör vara cirka 1020 hPa, som visas på den seriella monitorn. Kontrollera först kablar och anslutningar, sedan installation av programvara och korrigera.

Stäng av micro: bit, ta bort sensorn.

Dra de långa bygelkablarna genom sprutans uttag. Om du kan behöva vidga öppningen. Var försiktig så att kablarna skadas.

Anslut sensorn till bygelkablarna. Kontrollera att anslutningarna är korrekta och bra. Anslut till micro: bit.

Kontrollera att sensorn fungerar korrekt. Dra försiktigt i kablarna, flytta sensorn till toppen av sprutan.

Sätt i kolven och flytta den lite längre än önskad viloläge (100 ml).

Lägg till varmt lim i slutet av sprutans utlopp och flytta kolven lite tillbaka. Kontrollera om sprutan är stängd lufttät, annars tillsätt mer varmt lim. Låt svalna det heta limet.

Kontrollera igen att sensorn fungerar. Om du flyttar kolven bör siffrorna i den seriella bildskärmen och mikro: bitens display ändras.

Om det behövs kan du justera volymen i sprutan genom att klämma den nära packningen och flytta kolven.

Steg 3: Lite teori och några praktiska mätningar

Med den enhet som beskrivs här kan du demonstrera korrelationen mellan komprimering och tryck i enkla fysikförsök. Eftersom sprutan har en "ml" -skala på den är även kvantitativa experiment enkla att utföra.

Teorin bakom: Enligt Boyles lag är [Volym * tryck] ett konstant värde för en gas vid en given temperatur.

Detta betyder att om du komprimerar en given volym gas N-faldig, dvs den slutliga volymen är 1/N gånger originalet, kommer dess tryck att stiga N-faldigt, som: P0*V0 = P1*V1 = cons t. För mer information, ta en titt på Wikipedia -artikeln om gaslagar. Vid havsnivå ligger barometertrycket vanligtvis i intervallet 1010 hPa (hekto Pascal).

Så att börja vid en vilopunkter på t.ex. V0 = 100 ml och P0 = 1000 hPa, en kompression av luften till cirka 66 ml (dvs V1 = 2/3 * V0) kommer att resultera i ett tryck på cirka 1500 hPa (P1 = 3/2 av P0). Att dra kolven till 125 ml (5/4 gånger volym) resulterar i ett tryck på cirka 800 hPa (4/5 tryck). Mätningarna är förvånansvärt exakta för en så enkel enhet.

Enheten låter dig få ett direkt haptiskt intryck av hur mycket kraft som krävs för att komprimera eller expandera den relativt lilla mängden luft i sprutan.

Men vi kan också utföra några beräkningar och kontrollera dem experimentellt. Antag att vi komprimerar luften till 1500 hPa, vid ett basalt barometertryck på 1000 hPa. Så tryckskillnaden är 500 hPa, eller 50 000 Pa. För min spruta är kolvens diameter (d) cirka 4 cm eller 0,04 meter.

Nu kan du beräkna kraften som krävs för att hålla kolven i det läget. Med tanke på P = F/A (trycket är kraft dividerat med område), eller transformerat F = P*A. SI -enheten för kraft är "Newton" N, för längden "Meter" m, och 1 Pa är 1N per kvadratmeter. För en rund kolv kan ytan beräknas med A = ((d/2)^2)*pi, vilket ger 0,00125 kvadratmeter för min spruta. Så

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

På Jorden korrelerar 1 N till en vikt på 100 gr, så 63 N är lika med att hålla en vikt på 6,3 kg.

Detta kan enkelt kontrolleras med hjälp av en skala. Skjut sprutan med kolven på vågen tills ett tryck på cirka 1500 hPa har uppnåtts, läs sedan vågen. Eller tryck tills vågen visar ca 6-7 kg, tryck sedan på "A" -knappen och läs värdet som visas på micro: bitens LED-matris. Som det visade sig var uppskattningen baserad på ovanstående beräkningar inte dålig. Ett tryck något över 1500 hPa korrelerade till en visad "vikt" på cirka 7 kg på en kroppsskala (se bilder). Du kan också vända på detta koncept och använda enheten för att bygga en enkel digital skala baserad på tryckmätningar.

Observera att den övre gränsen för sensorn är cirka 1540 hPa, så tryck ovanför detta kan inte mätas och kan skada sensorn.

Förutom utbildningsändamål kan man också använda systemet för vissa verkliga tillämpningar, eftersom det gör det möjligt att kvantitativt mäta krafter som försöker flytta kolven på ett eller annat sätt. Så du kan mäta en vikt som placeras på kolven eller en slagkraft som träffar kolven. Eller bygg en switch som aktiverar ett ljus eller en summer eller spelar ett ljud efter att ett visst tröskelvärde uppnåtts. Eller så kan du bygga ett musikinstrument som ändrar frekvensen beroende på kraftstyrkan som appliceras på kolven. Eller använd den som en spelkontroll. Använd din fantasi och spela!

Steg 4: MicroPython -skriptet

Bifogat hittar du mitt BMP280 -skript för micro: bit. Det är ett derivat av ett BMP/BME280 -skript jag hittade någonstans Banggood -webbplatsen, kombinerat med Adafruit's Microbit -bibliotek. Den första låter dig använda Banggood -sensorn, den andra förenklar hanteringen av 5x5 LED -skärmen. Mitt tack går till utvecklarna av båda.

Som standard visar skriptet resultaten av tryckmätningar i fem steg på micro: bitens 5x5 LED -display, så att du kan se förändringar med liten fördröjning. De exakta värdena kan visas parallellt på Arduino IDE -seriemonitorn, eller en mer detaljerad graf kan visas seriell plotter för Arduino IDE.

Om du trycker på A -knappen visas de uppmätta tryckvärdena på micro: bitens 5x5 LED -array. Om du trycker på B -knappen visas temperaturvärdena. Även om detta gör det möjligt att läsa exakta data, saktar mätcyklerna avsevärt.

Jag är säker på att det finns mycket mer eleganta sätt att programmera uppgifterna och förbättra manuset. All hjälp är välkommen.

#inkludera xxx

#inkludera Adafruit_Microbit_Matrix mikrobit; #define BME280_ADDRESS 0x76 osignerad long int hum_raw, temp_raw, pres_raw; signerad 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; // behållare för mätvärden int värde0; int värde1; int värde2; int värde3; int värde4; // ------------------------------------------------ ---------------------------------------------------------- ------------------ void setup () {uint8_t osrs_t = 1; // Temperaturöverprovtagning x 1 uint8_t osrs_p = 1; // Överprovning av tryck x 1 uint8_t osrs_h = 1; // Fuktöversampling x 1 uint8_t -läge = 3; // Normalt läge uint8_t t_sb = 5; // Tstandby 1000ms uint8_t filter = 0; // Filtrera bort uint8_t spi3w_en = 0; // 3-tråds SPI Inaktivera uint8_t ctrl_meas_reg = (osrs_t << 5) | (osrs_p << 2) | läge; uint8_t config_reg = (t_sb << 5) | (filter << 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 ("Temperatur [deg C]"); // Serial.print ("\ t"); Serial.print ("Tryck [hPa]"); // header Wire.begin (); writeReg (0xF2, ctrl_hum_reg); writeReg (0xF4, ctrl_meas_reg); writeReg (0xF5, config_reg); readTrim (); // microbit.begin (); // microbit.print ("x"); fördröjning (1000); } // ----------------------------------------------- ---------------------------------------------------------- -------- void loop () {double temp_act = 0.0, press_act = 0.0, hum_act = 0.0; signerad long int temp_cal; osignerad long int press_cal, hum_cal; int N; // ställ in tröskelvärden för LED -matrisdisplay, i hPa dubbel max_0 = 1100; dubbel max_1 = 1230; dubbel max_2 = 1360; dubbel max_3 = 1490; readData (); temp_cal = kalibrering_T (temp_raw); press_cal = kalibrering_P (pres_raw); hum_cal = kalibrering_H (hum_raw); temp_act = (dubbel) temp_cal / 100,0; press_act = (dubbel) press_cal / 100.0; hum_act = (dubbel) hum_cal / 1024.0; microbit.clear (); // återställ LED -matris /* Serial.print ("TRYCK:"); Serial.println (press_act); Serial.print ("hPa"); Serial.print ("TEMP:"); Serial.print ("\ t"); Serial.println (temp_act); */ if (! digitalRead (PIN_BUTTON_B)) {// visning av värden i siffror fördröjer mätning av cirklar microbit.print ("T:"); microbit.print (temp_act, 1); microbit.print ("'C"); // Serial.println (""); } annars om (! digitalRead (PIN_BUTTON_A)) {microbit.print ("P:"); microbit.print (press_act, 0); microbit.print ("hPa"); } annat {// visar tryckvärden som pixlar eller linjer i en viss nivå // 5 steg: 1490 hPa // trösklar definierade av max_n -värdena om (press_act> max_3) {(N = 0); // övre rad} annars om (press_act> max_2) {(N = 1); } annars if (press_act> max_1) {(N = 2); } annars if (press_act> max_0) {(N = 3); } annat {(N = 4); // basrad} // Serial.println (N); // för utvecklingsändamål // microbit.print (N); // som Line // microbit.drawLine (N, 0, 0, 4, LED_ON); // skifta värden till nästa rad värde4 = värde3; värde3 = värde2; värde2 = värde1; värde1 = värde0; värde0 = N; // rita bild, kolumn för kolumn mikrobit.drawPixel (0, värde0, LED_ON); // som Pixel: kolumn, rad. 0, 0 vänster övre hörnet mikrobit.drawPixel (1, värde1, LED_ON); microbit.drawPixel (2, värde2, LED_ON); microbit.drawPixel (3, värde3, LED_ON); microbit.drawPixel (4, värde4, LED_ON); } // skicka data till seriell bildskärm och seriell plotter // Serial.println (press_act); // skicka värde (er) till serieport för numerisk visning, valfritt

Serial.print (press_act); // skicka värde till serieport för plotter

// rita indikatorlinjer och fixa visat intervall Serial.print ("\ t"); Serial.print (600); Serial.print ("\ t"); Serial.print (1100), Serial.print ("\ t"); Serial.println (1600); fördröjning (200); // Mät tre gånger per sekund} // ---------------------------------------- ---------------------------------------------------------- ---------------------------------------------------------- - // följande krävs för bmp/bme280-sensorn, behåll som det är ogiltigt readTrim () {uint8_t data [32], i = 0; // Fixa 2014/Wire.beginTransmission (BME280_ADDRESS); Wire.write (0x88); Wire.endTransmission (); Wire.requestFrom (BME280_ADDRESS, 24); // Fixa 2014/while (Wire.available ()) {data = Wire.read (); i ++; } Wire.beginTransmission (BME280_ADDRESS); // Lägg till 2014/Wire.write (0xA1); // Lägg till 2014/Wire.endTransmission (); // Lägg till 2014/Wire.requestFrom (BME280_ADDRESS, 1); // Lägg till 2014/data = Wire.read (); // Lägg till 2014/i ++; // Lägg till 2014/Wire.beginTransmission (BME280_ADDRESS); Wire.write (0xE1); Wire.endTransmission (); Wire.requestFrom (BME280_ADDRESS, 7); // Fixa 2014/while (Wire.available ()) {data = Wire.read (); i ++; } dig_T1 = (data [1] << 8) | data [0]; dig_P1 = (data [7] << 8) | data [6]; dig_P2 = (data [9] << 8) | data [8]; dig_P3 = (data [11] << 8) | data [10]; dig_P4 = (data [13] << 8) | data [12]; dig_P5 = (data [15] << 8) | data [14]; dig_P6 = (data [17] << 8) | data [16]; dig_P7 = (data [19] << 8) | data [18]; dig_T2 = (data [3] << 8) | data [2]; dig_T3 = (data [5] << 8) | data [4]; dig_P8 = (data [21] << 8) | data [20]; dig_P9 = (data [23] << 8) | data [22]; dig_H1 = data [24]; dig_H2 = (data [26] << 8) | data [25]; dig_H3 = data [27]; dig_H4 = (data [28] << 4) | (0x0F & data [29]); dig_H5 = (data [30] 4) & 0x0F); // Fixa 2014/dig_H6 = data [31]; // Fixa 2014/} void writeReg (uint8_t reg_address, uint8_t data) {Wire.beginTransmission (BME280_ADDRESS); Wire.write (reg_adress); Wire.write (data); Wire.endTransmission (); }

void readData ()

{int i = 0; uint32_t data [8]; Wire.beginTransmission (BME280_ADDRESS); Wire.write (0xF7); Wire.endTransmission (); Wire.requestFrom (BME280_ADDRESS, 8); medan (Wire.available ()) {data = Wire.read (); i ++; } pres_raw = (data [0] << 12) | (data [1] 4); temp_raw = (data [3] << 12) | (data [4] 4); hum_raw = (data [6] << 8) | data [7]; }

signerad long int kalibrering_T (signerad long int adc_T)

{signerad lång int var1, var2, T; var1 = ((((adc_T >> 3) - ((signerad lång int) dig_T1 11; var2 = (((((adc_T >> 4) - ((signerad lång int) dig_T1)) * ((adc_T >> 4) - ((signerad lång int) dig_T1))) >> 12) * ((signerad lång int) dig_T3)) >> 14; t_fine = var1 + var2; T = (t_fine * 5 + 128) >> 8; retur T;} osignerad lång int kalibrering_P (signerad lång int adc_P) {signerad lång int var1, var2; osignerad lång int P; var1 = (((signerad lång int) t_fine) >> 1) - (signerad lång int) 64000; var2 = (((var1 >> 2) * (var1 >> 2)) >> 11) * ((signerad lång int) dig_P6); var2 = var2 + ((var1 * ((signerad lång int) dig_P5)) 2) + ((((signerad lång int) dig_P4) 2) * (var1 >> 2)) >> 13)) >> 3) + ((((signerad lång int) dig_P2) * var1) >> 1)) >> 18; var1 = ((((32768+var1))*((signerad lång int) dig_P1)) >> 15); if (var1 == 0) {return 0; } P = (((osignerad lång int) (((signerad lång int) 1048576) -adc_P)-(var2 >> 12))))*3125; if (P <0x80000000) {P = (P << 1) / ((unsigned long int) var1); } annat {P = (P / (unsigned long int) var1) * 2; } var1 = (((signerad lång int) dig_P9) * ((signerad lång int) (((P >> 3) * (P >> 3)) >> 13))) >> 12; var2 = (((signerad lång int) (P >> 2)) * ((signerad lång int) dig_P8)) >> 13; P = (osignerad lång int) ((signerad lång int) P + ((var1 + var2 + dig_P7) >> 4)); retur P; } osignerad lång int kalibrering_H (signerad lång int adc_H) {signerad lång int v_x1; v_x1 = (t_fine - ((signerad lång int) 76800)); v_x1 = (((((adc_H << 14) -(((signerad lång int) dig_H4) 15) * ((((((v_x1 * ((signerad lång int) dig_H6)) >> 10) * (((v_x1 * ((signerad lång int) dig_H3)) >> 11) + ((signerad lång int) 32768))) >> 10) + ((signerad lång int) 2097152)) * ((signerad lång int) dig_H2) + 8192) >> 14)); v_x1 = (v_x1 - (((((v_x1 >> 15) * (v_x1 >> 15)) >> 7) * ((signerad lång int) dig_H1)) >> 4)); v_x1 = (v_x1 419430400? 419430400: v_x1); retur (osignerad lång int) (v_x1 >> 12);}

Steg 5: MakeCode/JavaScript -skript

Pimoroni har nyligen släppt enviro: bit, som levereras med en BMP280 trycksensor, en ljus/färg sensor och en MEMS mikrofon. De erbjuder också ett MicroPython och ett MakeCode/JavaScript -bibliotek.

Jag använde det senare för att skriva ett MakeCode -skript för trycksensorn. Motsvarande hex -fil kan kopieras direkt till din micro: bit. Koden visas nedan och kan ändras med MakeCode -redigeraren online.

Det är en variant av manuset för micro: bit dive-o-meter. Som standard visas tryckskillnaden som ett stapeldiagram. Genom att trycka på knapp A ställer man in referenstrycket, genom att trycka på knapp B visas skillnaden mellan det faktiska och referenstrycket i hPa.

Förutom den grundläggande streckkodversionen hittar du också en "X", hårkorsversion och en "L" -version, avsedd att göra läsningen enklare.

låt kolumn = 0

låt kvar = 0 låt Rad = 0 låt Meter = 0 låt Delta = 0 låt Ref = 0 låt 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)} annars om (input.buttonIsPressed (Button. B)) {basic.showString ("" + Delta + "hPa") basic.pause (200) basic.clearScreen ()} annars {Is = envirobit.getPressure () Delta = Is - Ref Meter = Math.abs (Delta) if (Mätare> = 400) {Rad = 4} annat om (Mätare> = 300) {Rad = 3} annat om (Mätare> = 200) {Rad = 2} annat om (Mätare> = 100) {Rad = 1} annars {rad = 0} kvar = mätare - rad * 100 om (förbli> = 80) {kolumn = 4} annat om (förbli> = 60) {kolumn = 3} annat om (kvarstå> = 40) {kolumn = 2 } annars om (förbli> = 20) {Kolumn = 1} annat {Kolumn = 0} för (låt ColA = 0; ColA <= Kolumn; ColA ++) {led.plot (ColA, rad)} basic.pause (500)}})