Mål trykk med din mikro: bit: 5 trinn (med bilder)

2024 Forfatter: John Day | [email protected]. Sist endret: 2024-01-30 11:24

Følgende instrukser beskriver en lett å bygge og billig enhet for å utføre trykkmålinger og demonstrere Boyles lov, ved hjelp av micro: bit i kombinasjon med BMP280 trykk-/temperatursensor.

Mens denne sprøyte/trykksensorkombinasjonen allerede er beskrevet i en av mine tidligere instrukser, gir kombinasjonen med micro: bit nye muligheter, f.eks. for prosjekter i klasserommet.

I tillegg er antallet beskrivelser av applikasjoner der micro: bit brukes i kombinasjon med en I2C -drevet sensor ganske begrenset så langt. Jeg håper at dette kan være et utgangspunkt for andre prosjekter.

Enheten gjør det mulig å utføre kvantitative lufttrykkmålinger og vise resultatene på mikro: bit LED -arrayet eller på en tilkoblet datamaskin for senere bruk av den serielle skjermen eller serielle plotterfunksjonene til Arduino IDE. I tillegg har du en haptisk tilbakemelding, ettersom du selv vil skyve eller trekke sprøytestempelet, og dermed føle den nødvendige kraften.

Som standard lar displayet deg estimere trykket med nivåindikatoren som vises på LED -matrisen. Seriell plotteren til Arduino IDE lar deg gjøre det samme, men med mye bedre oppløsning (se video). Mer detaljerte løsninger er også tilgjengelige, f.eks. på behandlingsspråket. Du kan også vise de presise måleverdiene for trykk og temperatur på LED -matrisen etter å ha trykket på henholdsvis A eller B -knappene, men den serielle skjermen til Arduino IDE er mye raskere, slik at du kan vise verdier i nær sanntid.

Totalkostnadene og de tekniske ferdighetene som kreves for å bygge enheten er ganske lave, så det kan være et fint klasseromsprosjekt under veiledning av en lærer. I tillegg kan enheten være et verktøy for STEM -prosjekter med fokus på fysikk eller brukes i andre prosjekter der en kraft eller vekt skal omdannes til en digital verdi.

Prinsippet ble brukt til å konstruere en veldig enkel micro: bit dykk-o-meter, en enhet for å måle hvor dypt du dykker.

Tillegg 27-mai-2018:

Siden Pimoroni har utviklet et MakeCode -bibliotek for BMP280 -sensoren, ga dette meg muligheten til å utvikle et skript som skal brukes for enheten som er beskrevet her. Skriptet og den tilhørende HEX-filen finnes i det siste trinnet i denne instruksjonsboken. For å bruke den, bare last HEX -filen til micro: bit. Du trenger ikke spesiell programvare, og du kan bruke den elektroniske MakeCode -redigereren for å redigere skriptet.

Trinn 1: brukte materialer

• En micro: bit, fikk min fra Pimoroni - 13,50 GBP
• Kitronic Edge Connector for micro: bit - via Pimoroni - 5 GBP, Bemerkning: Pimorini tilbyr nå en brødbrettvennlig kantkontakt kalt pin: bit med pins på I2C -portene.
• 2 x 2 -pins header strips
• Batteri eller LiPo for mikro: bit (ikke nødvendig, men nyttig), batterikabel med bryter (dito) - Pimoroni
• startkabler for tilkobling av sensorer til Edge -kontakt
• lange (!) startkabler for sensoren, minst like lang som sprøyten,, f/f eller f/m
• BMP280 trykk- og temperatursensor - Banggood - 5 US $ for tre enheter Måleområdet for denne sensoren er mellom 550 og 1537 hPa.
• 150 ml plastkatetersprøyte med gummipakning - Amazon eller jernvare- og hagebutikker - ca 2-3 US $
• varmt lim/varm limpistol
• loddejern
• en datamaskin med Arduino IDE installert

Trinn 2: Monteringsinstruksjoner

Loddehoder til BMP280 sensorutbrudd.

Lodd de to 2 -pins hodene til pin 19 og pin 20 -kontaktene på Edge -kontakten (se bildet).

Koble micro: bit til Edge -kontakten og datamaskinen.

Forbered programvare og micro: bit som beskrevet i Adafruit micro: bit instruksjonene. Les dem grundig.

Installer de nødvendige bibliotekene til Arduino IDE.

Åpne BMP280 -skriptet som er vedlagt i et senere trinn.

Koble sensoren til Edge -kontakten. GND til 0V, VCC til 3V, SCL til pin 19, SDA til pin 20.

Last opp skriptet til micro: bit.

Kontroller at sensoren gir rimelige data, trykkverdier bør være rundt 1020 hPa, vist på den serielle skjermen. I tilfelle må du først sjekke kabler og tilkoblinger, deretter installere programvare og rette.

Slå av micro: bit, fjern sensoren.

Før de lange startkablene gjennom utløpet på sprøyten. I tilfelle du må utvide åpningen. Vær forsiktig med å utelate at kablene blir skadet.

Koble sensoren til startkablene. Kontroller at tilkoblingene er riktige og gode. Koble til micro: bit.

Kontroller at sensoren fungerer som den skal. Trekk forsiktig i kablene, flytt sensoren til toppen av sprøyten.

Sett inn stempelet og flytt det litt lenger enn ønsket hvilestilling (100 ml).

Tilsett varmt lim på enden av sprøyteutløpet og flytt stemplet litt tilbake. Kontroller om sprøyten er lukket lufttett, ellers tilsett mer varmt lim. La avkjøle det varme limet.

Kontroller igjen at sensoren fungerer. Hvis du flytter stemplet, bør tallene i den serielle skjermen og micro: bit -skjermen endres.

Om nødvendig kan du justere volumet i sprøyten ved å klemme den nær pakningen og flytte stemplet.

Trinn 3: Litt teori og noen praktiske målinger

Med enheten beskrevet her, kan du demonstrere sammenhengen mellom kompresjon og trykk i enkle fysikkeksperimenter. Siden sprøyten kommer med en "ml" -skala på den, er selv kvantitative eksperimenter enkle å utføre.

Teorien bak: I henhold til Boyles lov er [Volum * Trykk] en konstant verdi for en gass ved en gitt temperatur.

Dette betyr at hvis du komprimerer et gitt volum gass N-fold, dvs. at sluttvolumet er 1/N ganger originalen, vil trykket stige N-ganger, som: P0*V0 = P1*V1 = cons t. For mer informasjon, ta en titt på Wikipedia -artikkelen om gasslover. Ved havnivå er barometertrykket vanligvis i området 1010 hPa (hekto Pascal).

Så starter ved en hvilepunkter på f.eks. V0 = 100 ml og P0 = 1000 hPa, en komprimering av luften til ca 66 ml (dvs. V1 = 2/3 * V0) vil resultere i et trykk på omtrent 1500 hPa (P1 = 3/2 av P0). Å trekke stempelet til 125 ml (5/4 ganger volum) resulterer i et trykk på omtrent 800 hPa (4/5 trykk). Målingene er forbausende presise for en så enkel enhet.

Enheten lar deg få et direkte haptisk inntrykk av hvor mye kraft som kreves for å komprimere eller utvide den relativt lille mengden luft i sprøyten.

Men vi kan også utføre noen beregninger og kontrollere dem eksperimentelt. Anta at vi komprimerer luften til 1500 hPa, ved et basal barometrisk trykk på 1000 hPa. Så trykkforskjellen er 500 hPa, eller 50 000 Pa. For sprøyten min er diameteren (d) på stempelet omtrent 4 cm eller 0,04 meter.

Nå kan du beregne kraften som kreves for å holde stemplet i den posisjonen. Gitt P = F/A (Trykk er kraft delt på område), eller transformert F = P*A. SI -enheten for kraft er "Newton" N, for lengden "Meter" m, og 1 Pa er 1N per kvadratmeter. For et rundt stempel kan området beregnes ved hjelp av A = ((d/2)^2)*pi, som gir 0,00125 kvadratmeter for sprøyten min. Så

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

På Jorden korrelerer 1 N med en vekt på 100 gr, så 63 N er lik å holde en vekt på 6,3 kg.

Dette kan enkelt kontrolleres ved hjelp av en skala. Skyv sprøyten med stempelet på vekten til et trykk på ca 1500 hPa er nådd, og les deretter skalaen. Eller trykk til skalaen viser omtrent 6-7 kg, trykk deretter på "A" -knappen og les verdien som vises på micro: bitens LED-matrise. Som det viste seg, var estimatet basert på beregningene ovenfor ikke dårlig. Et trykk litt over 1500 hPa korrelerte med en vist "vekt" på omtrent 7 kg på en kroppsvekt (se bilder). Du kan også snu dette konseptet og bruke enheten til å bygge en enkel digital skala basert på trykkmålinger.

Vær oppmerksom på at den øvre grensen for sensoren er omtrent 1540 hPa, så ethvert trykk over dette kan ikke måles og kan skade sensoren.

Ved siden av utdanningsformål kan man også bruke systemet til noen virkelige applikasjoner, ettersom det gjør det mulig å kvantitativt måle krefter som prøver å bevege stempelet på en eller annen måte. Så du kan måle en vekt plassert på stempelet eller en slagkraft som treffer på stempelet. Eller bygg en bryter som aktiverer et lys eller en summer eller spiller en lyd etter at en viss terskelverdi er nådd. Eller du kan bygge et musikkinstrument som endrer frekvensen avhengig av kraften som brukes på stempelet. Eller bruk den som en spillkontroller. Bruk fantasien og spill!

Trinn 4: MicroPython -skriptet

Vedlagt finner du BMP280 -skriptet mitt for micro: bit. Det er en derivat av et BMP/BME280 -skript jeg fant et sted på Banggood -nettstedet, kombinert med Adafruit's Microbit -bibliotek. Den første lar deg bruke Banggood -sensoren, den andre forenkler håndteringen av 5x5 LED -skjermen. Min takk går til utviklerne av begge.

Som standard viser skriptet resultatene av trykkmålinger i 5 trinn på micro: bits 5x5 LED -display, slik at du kan se endringer med liten forsinkelse. De presise verdiene kan vises parallelt på Arduino IDE seriell skjerm, eller en mer detaljert graf kan vises seriell plotter for Arduino IDE.

Hvis du trykker på A -knappen, vises de målte trykkverdiene på micro: bits 5x5 LED -array. Hvis du trykker på B -knappen, vises temperaturverdiene. Selv om dette gjør det mulig å lese de nøyaktige dataene, reduseres målesyklusene betydelig.

Jeg er sikker på at det er mye mer elegante måter å programmere oppgavene og forbedre skriptet. All hjelp er velkommen.

#inkludere xxx

#inkludere Adafruit_Microbit_Matrix mikrobit; #define BME280_ADDRESS 0x76 unsigned long int hum_raw, temp_raw, pres_raw; signert 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; // beholdere for målte verdier int verdi0; int verdi1; int verdi2; int verdi3; int verdi4; // ------------------------------------------------ -------------------------------------------------- ------------------ ugyldig oppsett () {uint8_t osrs_t = 1; // Temperaturoversampling x 1 uint8_t osrs_p = 1; // Trykkoversampling x 1 uint8_t osrs_h = 1; // Fuktighetsoversampling x 1 uint8_t modus = 3; // Normal modus uint8_t t_sb = 5; // Tstandby 1000ms uint8_t filter = 0; // Filtrer av uint8_t spi3w_en = 0; // 3-leder SPI Deaktiver uint8_t ctrl_meas_reg = (osrs_t << 5) | (osrs_p << 2) | modus; 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 [grader C]"); // Serial.print ("\ t"); Serial.print ("Trykk [hPa]"); // header Wire.begin (); writeReg (0xF2, ctrl_hum_reg); writeReg (0xF4, ctrl_meas_reg); writeReg (0xF5, config_reg); readTrim (); // microbit.begin (); // microbit.print ("x"); forsinkelse (1000); } // ----------------------------------------------- -------------------------------------------------- -------- void loop () {double temp_act = 0.0, press_act = 0.0, hum_act = 0.0; signert long int temp_cal; usignert lang int press_cal, hum_cal; int N; // angi terskelverdier for LED -matrisedisplay, i hPa dobbel max_0 = 1100; dobbel max_1 = 1230; dobbel max_2 = 1360; dobbel max_3 = 1490; readData (); temp_cal = kalibrering_T (temp_raw); press_cal = calibration_P (pres_raw); hum_cal = kalibrering_H (hum_raw); temp_act = (dobbel) temp_cal / 100,0; press_act = (double) press_cal / 100.0; hum_act = (double) hum_cal / 1024.0; microbit.clear (); // tilbakestill LED -matrise /* Serial.print ("TRYKK:"); Serial.println (press_act); Serial.print ("hPa"); Serial.print ("TEMP:"); Serial.print ("\ t"); Serial.println (temp_act); */ if (! digitalRead (PIN_BUTTON_B)) {// visning av verdier i tall forsinker måling av sirkler microbit.print ("T:"); microbit.print (temp_act, 1); microbit.print ("'C"); // Serial.println (""); } annet hvis (! digitalRead (PIN_BUTTON_A)) {microbit.print ("P:"); microbit.print (press_act, 0); microbit.print ("hPa"); } annet {// viser trykkverdier som piksler eller linjer i et bestemt nivå // 5 trinn: 1490 hPa // terskler definert av max_n -verdiene hvis (press_act> max_3) {(N = 0); // øvre rad} ellers hvis (trykk_akt> maks_2) {(N = 1); } annet hvis (press_act> max_1) {(N = 2); } annet hvis (press_act> max_0) {(N = 3); } annet {(N = 4); // grunnrad} // Serial.println (N); // for utviklingsformål // microbit.print (N); // som linje // microbit.drawLine (N, 0, 0, 4, LED_ON); // skift verdier til neste linje verdi4 = verdi3; verdi3 = verdi2; verdi2 = verdi1; verdi1 = verdi0; verdi0 = N; // tegne bilde, kolonne for kolonne mikrobit.drawPixel (0, verdi0, LED_ON); // som Pixel: kolonne, rad. 0, 0 venstre øvre hjørne mikrobit.drawPixel (1, verdi1, LED_ON); microbit.drawPixel (2, verdi2, LED_ON); microbit.drawPixel (3, verdi3, LED_ON); microbit.drawPixel (4, verdi4, LED_ON); } // sende data til seriell skjerm og seriell plotter // Serial.println (press_act); // send verdi (er) til serieport for numerisk visning, valgfritt

Serial.print (press_act); // send verdi til serieport for plotter

// tegne indikatorlinjer og fikse det viste området Serial.print ("\ t"); Serial.print (600); Serial.print ("\ t"); Serial.print (1100), Serial.print ("\ t"); Serial.println (1600); forsinkelse (200); // Mål tre ganger i sekundet} // ----------------------------------------- -------------------------------------------------- -------------------------------------------------- - // følgende er nødvendig for bmp/bme280-sensoren, behold det som det er ugyldig readTrim () {uint8_t data [32], i = 0; // Fix 2014/Wire.beginTransmission (BME280_ADDRESS); Wire.write (0x88); Wire.endTransmission (); Wire.requestFrom (BME280_ADDRESS, 24); // Rett opp 2014/while (Wire.available ()) {data = Wire.read (); i ++; } Wire.beginTransmission (BME280_ADDRESS); // Legg til 2014/Wire.write (0xA1); // Legg til 2014/Wire.endTransmission (); // Legg til 2014/Wire.requestFrom (BME280_ADDRESS, 1); // Legg til 2014/data = Wire.read (); // Legg til 2014/i ++; // Legg til 2014/Wire.beginTransmission (BME280_ADDRESS); Wire.write (0xE1); Wire.endTransmission (); Wire.requestFrom (BME280_ADDRESS, 7); // Rett opp 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); // Fix 2014/dig_H6 = data [31]; // Fix 2014/} void writeReg (uint8_t reg_address, uint8_t data) {Wire.beginTransmission (BME280_ADDRESS); Wire.write (reg_adresse); 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); mens (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]; }

signert long int kalibrering_T (signert long int adc_T)

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

Trinn 5: MakeCode/JavaScript -skript

Pimoroni har nylig gitt ut enviro: bit, som kommer med en BMP280 trykksensor, en lys/fargesensor og en MEMS mikrofon. De tilbyr også et MicroPython og et MakeCode/JavaScript -bibliotek.

Jeg brukte den senere til å skrive et MakeCode -skript for trykksensoren. Den tilhørende hex -filen kan kopieres direkte til din micro: bit. Koden vises nedenfor og kan endres ved hjelp av online MakeCode -editoren.

Det er en variant av manuset for micro: bit dive-o-meter. Som standard viser den trykkforskjellen som et søylediagram. Ved å trykke på knapp A angir referansetrykket, trykk på knapp B viser forskjellen mellom det faktiske og referansetrykket i hPa.

I tillegg til den grunnleggende strekkodeversjonen finner du også en "X", hårkorsversjon og en "L" -versjon, som skal gjøre lesingen lettere.

la kolonne = 0

la forbli = 0 la rad = 0 la Meter = 0 la Delta = 0 la Ref = 0 la Is = 0 Er = 1012 basic.showLeds (` # # # # # #.. # #. #. # #… # # # # # # # `) Ref = 1180 basic.clearScreen () basic.forever (() => {basic.clearScreen () if (input.buttonIsPressed (Button. A)) {Ref = envirobit.getPressure () basic.showLeds (` #. #. #. #. #. # # # # # #. #. #. #. #`) basic.pause (1000)} annet hvis (input.buttonIsPressed (Button. B)) {basic.showString ("" + Delta + "hPa") basic.pause (200) basic.clearScreen ()} annet {Is = envirobit.getPressure () Delta = Is - Ref Meter = Math.abs (Delta) if (Meter> = 400) {Rad = 4} annet hvis (Meter> = 300) {Rad = 3} annet hvis (Meter> = 200) {Rad = 2} annet hvis (Meter> = 100) {Rad = 1} annet {Rad = 0} gjenstår = Meter - Rad * 100 hvis (forbli> = 80) {Kolonne = 4} annet hvis (forbli> = 60) {Kolonne = 3} annet hvis (forbli> = 40) {Kolonne = 2 } annet hvis (forbli> = 20) {Kolonne = 1} annet {Kolonne = 0} for (la ColA = 0; ColA <= Kolonne; ColA ++) {led.plot (ColA, rad)} basic.pause (500)}})