Meet druk met u mikro: bietjie: 5 stappe (met foto's)

2024 Outeur: John Day | [email protected]. Laas verander: 2024-01-30 07:27

Die volgende instruksies beskryf 'n maklik om te bou en goedkoop toestel om drukmetings uit te voer en Boyle se wet te demonstreer met behulp van die micro: bit in kombinasie met die BMP280 druk/temperatuur sensor.

Terwyl hierdie kombinasie van spuit/druksensor reeds in een van my vorige instruksies beskryf is, bied die kombinasie met die micro: bit nuwe geleenthede, bv. vir klaskamerprojekte.

Boonop is die aantal beskrywings van toepassings waarin die micro: bit gebruik word in kombinasie met 'n I2C -aangedrewe sensor tot dusver taamlik beperk. Ek hoop dat hierdie instruksies 'n beginpunt vir ander projekte kan wees.

Met die toestel kan u kwantitatiewe lugdrukmetings uitvoer en die resultate op die mikro: bit LED -skikking of op 'n gekoppelde rekenaar vertoon, om later die seriële monitor of seriële plotterfunksies van die Arduino IDE te gebruik. Daarbenewens het u 'n haptiese terugvoer, aangesien u self die suier van die spuit sal stoot of trek, en hierdeur die nodige krag voel.

Standaard kan u op die skerm die druk bepaal deur die vlakaanwyser op die LED -matriks. Met die seriële plotter van die Arduino IDE kan u dieselfde doen, maar met 'n baie beter resolusie (sien video). Meer uitgebreide oplossings is ook beskikbaar, bv. in die verwerkingstaal. U kan ook die presiese gemete waardes van druk en temperatuur op die LED -matriks vertoon nadat u op die A- of B -knoppies gedruk het, maar die seriële monitor van die Arduino IDE is baie vinniger, waardeur dit in werklike tyd in staat is om waardes te vertoon.

Die totale koste en die tegniese vaardighede wat nodig is om die toestel te bou, is redelik laag, dus dit kan 'n aangename klaskamerprojek wees onder toesig van 'n onderwyser. Boonop kan die toestel 'n hulpmiddel wees vir STEM -projekte met die fokus op fisika of gebruik word in ander projekte waar 'n krag of gewig in 'n digitale waarde omskep moet word.

Die beginsel is gebruik om 'n baie eenvoudige micro: bit duik-meter te bou, 'n toestel om te meet hoe diep jy duik.

Bylae 27-Mei-2018:

Aangesien Pimoroni 'n MakeCode -biblioteek vir die BMP280 -sensor ontwikkel het, het dit my die geleentheid gebied om 'n script te ontwikkel wat gebruik kan word vir die toestel wat hier beskryf word. Die script en die ooreenstemmende HEX-lêer kan gevind word in die laaste stap van hierdie instruksies. Laai die HEX -lêer net na u micro: bit om dit te gebruik. Spesiale sagteware is nie nodig nie, en u kan die aanlyn MakeCode -redakteur gebruik om die teks te redigeer.

Stap 1: Gebruikte materiaal

• 'N Micro: bit, het myne by Pimoroni gekry - 13,50 GBP
• Kitronic Edge Connector vir micro: bit - via Pimoroni - 5 GBP, Opmerking: Pimorini bied nou 'n broodbordvriendelike randverbinder genaamd pin: bit met penne op die I2C -poorte.
• 2 x 2 -pen kopstroke
• Battery of LiPo vir die mikro: bietjie (nie nodig nie, maar nuttig), batterykabel met skakelaar (dito) - Pimoroni
• jumper kabels vir die aansluiting van sensors aan Edge connector
• lang (!) springkabels vir die sensor, ten minste so lank as die spuit,, f/f of f/m
• BMP280 druk- en temperatuursensor - Banggood - 5 US $ vir drie eenhede Die meetbereik vir hierdie sensor is tussen 550 en 1537 hPa.
• 150 ml plastiek kateterspuit met rubber pakking - Amazon- of hardeware- en tuinwinkels - ongeveer 2-3 Amerikaanse dollars
• warm gom/warm gom pistool
• soldeerbout
• 'n rekenaar met die Arduino IDE geïnstalleer

Stap 2: Monteerinstruksies

Soldeerkoppe na die uitbreek van die BMP280 -sensor.

Soldeer die twee 2 -pen -koppe aan die pen 19 en pen 20 -verbindings van die Edge -aansluiting (sien prent).

Koppel die micro: bit aan die Edge -aansluiting en u rekenaar.

Berei sagteware en micro: bit voor soos beskryf in die Adafruit micro: bit instruksies. Lees hulle deeglik deur.

Installeer die vereiste biblioteke op die Arduino IDE.

Maak die BMP280 -script oop wat in 'n latere stap aangeheg is.

Koppel die sensor aan die Edge -aansluiting. GND tot 0V, VCC tot 3V, SCL na pen 19, SDA tot pen 20.

Laai die script op na die micro: bit.

Kontroleer of die sensor redelike gegewens verskaf, die drukwaardes moet ongeveer 1020 hPa wees, wat op die seriële monitor vertoon word. Kontroleer eers kabels en verbindings, dan sagteware -installasie en maak dit reg.

Skakel micro: bit uit, verwyder sensor.

Dra die kabels met lang spring deur die uitlaat van die spuit. As u die opening moet vergroot. Wees versigtig om weg te laat dat die kabels beskadig raak.

Koppel die sensor aan die springkabels. Kontroleer of die verbindings korrek en goed is. Koppel aan die micro: bit.

Kontroleer of die sensor korrek werk. Trek die kabels versigtig na die bokant van die spuit.

Plaas die suier en beweeg dit 'n entjie verder as die verlangde rusposisie (100 ml).

Voeg warm gom aan die einde van die spuituitlaat en skuif die suier 'n bietjie terug. Kontroleer of die spuit lugdig is, anders voeg nog warm gom by. Laat die warm gom afkoel.

Kyk weer of die sensor werk. As u die suier beweeg, moet die getalle in die seriële monitor en die mikro: bit se skerm verander.

Indien nodig, kan u die volume in die spuit verstel deur dit naby die pakking te druk en die suier te beweeg.

Stap 3: 'n bietjie teorie en 'n paar praktiese metings

Met die apparaat wat hier beskryf word, kan u die korrelasie van kompressie en druk demonstreer in eenvoudige fisika -eksperimente. Aangesien die spuit 'n "ml" -skaal bevat, is selfs kwantitatiewe eksperimente maklik om uit te voer.

Die teorie daaragter: Volgens Boyle se wet is [Volume * Druk] 'n konstante waarde vir 'n gas by 'n gegewe temperatuur.

Dit beteken dat as u 'n gegewe volume gas N-vou saamdruk, d.w.s. die finale volume 1/N vou van die oorspronklike is, sal die druk N-voudig styg, soos: P0*V0 = P1*V1 = nadele t. Vir meer besonderhede, kyk na die Wikipedia -artikel oor gaswette. Op seevlak is die barometriese druk gewoonlik tussen 1010 hPa (hekto Pascal).

Dus begin by 'n ruspunte van bv. V0 = 100 ml en P0 = 1000 hPa, 'n kompressie van die lug tot ongeveer 66 ml (dws V1 = 2/3 * V0) sal 'n druk van ongeveer 1500 hPa (P1 = 3/2 van P0) tot gevolg hê. Deur die suier tot 125 ml (5/4 voudige volume) te trek, lei dit tot 'n druk van ongeveer 800 hPa (4/5 druk). Die metings is verstommend presies vir so 'n eenvoudige toestel.

Met die toestel kan u 'n direkte haptiese indruk hê van hoeveel krag nodig is om die relatief klein hoeveelheid lug in die spuit saam te pers of uit te brei.

Maar ons kan ook 'n paar berekeninge uitvoer en dit eksperimenteel kontroleer. Gestel ons pers die lug tot 1500 hPa, by 'n basale barometriese druk van 1000 hPa. Die drukverskil is dus 500 hPa, oftewel 50, 000 Pa. Vir my spuit is die deursnee (d) van die suier ongeveer 4 cm of 0,04 meter.

Nou kan u die krag bereken wat nodig is om die suier in die posisie te hou. Gegee P = F/A (druk is krag gedeel deur oppervlakte), of getransformeer F = P*A. Die SI -eenheid vir krag is "Newton" N, vir lengte "Meter" m, en 1 Pa is 1N per vierkante meter. Vir 'n ronde suier kan die oppervlakte bereken word met A = ((d/2)^2)*pi, wat 0,00125 vierkante meter vir my spuit gee. So

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

Op aarde korreleer 1 N met 'n gewig van 100 gr, dus is 63 N gelyk aan die gewig van 6,3 kg.

Dit kan maklik met 'n skaal nagegaan word. Druk die spuit met die suier op die weegskaal totdat 'n druk van ongeveer 1500 hPa bereik is, en lees dan die weegskaal. Of druk totdat die skaal ongeveer 6-7 kg vertoon, druk dan op die "A" -knoppie en lees die waarde wat op die micro: bit se LED-matriks verskyn. Soos dit blyk, was die skatting op grond van die bogenoemde berekeninge nie sleg nie. 'N Druk effens hoër as 1500 hPa korreleer met 'n gewig van ongeveer 7 kg op 'n liggaamsskaal (sien prente). U kan hierdie konsep ook omdraai en die toestel gebruik om 'n eenvoudige digitale skaal te bou wat gebaseer is op drukmetings.

Let daarop dat die boonste limiet vir die sensor ongeveer 1540 hPa is, sodat enige druk hierbo nie gemeet kan word nie en die sensor kan beskadig.

Behalwe vir opvoedkundige doeleindes, kan 'n mens die stelsel ook vir sommige werklike toepassings gebruik, aangesien dit kragte kwantitatief kan meet wat probeer om die suier op die een of ander manier te beweeg. U kan dus 'n gewig meet wat op die suier geplaas word, of 'n slagkrag wat op die suier tref. Of bou 'n skakelaar wat 'n lig of 'n zoemer aktiveer of 'n geluid speel nadat 'n sekere drempelwaarde bereik is. Of u kan 'n musiekinstrument bou wat die frekwensie verander, afhangende van die sterkte wat op die plunjer toegepas word. Of gebruik dit as 'n spelbeheerder. Gebruik u verbeelding en speel!

Stap 4: Die MicroPython -skrip

Hierby vind u my BMP280 -script vir die micro: bit. Dit is 'n afleiding van 'n BMP/BME280 -skrif wat ek êrens op die Banggood -webwerf gevind het, gekombineer met Adafruit se Microbit -biblioteek. Met die eerste kan u die Banggood -sensor gebruik, en die tweede vergemaklik die hantering van die 5x5 LED -skerm. My dank gaan aan die ontwikkelaars van albei.

Die script vertoon standaard die resultate van drukmetings in 5 stappe op die 5 x 5 LED -skerm van die micro: bit, sodat veranderinge met min vertraging gesien kan word. Die presiese waardes kan parallel op die Arduino IDE -seriële monitor vertoon word, of 'n meer gedetailleerde grafiek kan die serale plotter van die Arduino IDE vertoon word.

As u op die A -knoppie druk, word die gemete drukwaardes op die micro: bit se 5x5 LED -skikking vertoon. As u op die B -knoppie druk, word die temperatuurwaardes vertoon. Alhoewel dit die akkurate data kan lees, word die metingsiklusse aansienlik vertraag.

Ek is seker dat daar baie meer elegante maniere is om die take te programmeer en die script te verbeter. Enige hulp is welkom.

#sluit xxx in

#sluit Adafruit_Microbit_Matrix mikrobit in; #define BME280_ADDRESS 0x76 ongetekende lang int hum_raw, temp_raw, pres_raw; onderteken lang 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; // houers vir gemete waardes int waarde0; int waarde1; int waarde2; int waarde3; int waarde4; // ------------------------------------------------ -------------------------------------------------- ------------------ nietige opstelling () {uint8_t osrs_t = 1; // Temperatuur oormonster x 1 uint8_t osrs_p = 1; // Druk oormonster x 1 uint8_t osrs_h = 1; // Vogsamersampling x 1 uint8_t mode = 3; // Normale modus uint8_t t_sb = 5; // Tstandby 1000ms uint8_t filter = 0; // Filter uint8_t spi3w_en = 0 af; // 3-draads SPI Deaktiveer uint8_t ctrl_meas_reg = (osrs_t << 5) | (osrs_p << 2) | wyse; 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 ("Temperatuur [deg C]"); // Serial.print ("\ t"); Serial.print ("Druk [hPa]"); // kop Wire.begin (); writeReg (0xF2, ctrl_hum_reg); writeReg (0xF4, ctrl_meas_reg); writeReg (0xF5, config_reg); readTrim (); // microbit.begin (); // microbit.print ("x"); vertraging (1000); } // ----------------------------------------------- -------------------------------------------------- -------- leemte lus () {double temp_act = 0.0, press_act = 0.0, hum_act = 0.0; ondertek lang int temp_cal; ongetekende long int press_cal, hum_cal; int N; // stel drempelwaardes vir LED -matriksvertoning, in hPa dubbel max_0 = 1100; dubbel max_1 = 1230; dubbel max_2 = 1360; dubbel max_3 = 1490; readData (); temp_cal = kalibrasie_T (temp_raw); press_cal = calibration_P (pres_raw); hum_cal = kalibrasie_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 (); // herstel LED -matriks /* Serial.print ("PERS:"); Serial.println (pers_akt); Serial.print ("hPa"); Serial.print ("TEMP:"); Serial.print ("\ t"); Serial.println (temp_act); */ if (! digitalRead (PIN_BUTTON_B)) {// vertoon van waardes in getalle vertraag die meting van sirkels microbit.print ("T:"); microbit.print (temp_act, 1); microbit.print ("'C"); // Serial.println (""); } anders as (! digitalRead (PIN_BUTTON_A)) {microbit.print ("P:"); microbit.print (pers_akt, 0); microbit.print ("hPa"); } anders {// drukwaardes as pixels of lyne op 'n sekere vlak // 5 stappe: 1490 hPa // drempels gedefinieer deur die max_n waardes as (press_act> max_3) {(N = 0); // boonste ry} anders as (druk_akt> maks_2) {(N = 1); } anders as (druk_akt> maks_1) {(N = 2); } anders as (druk_akt> maks_0) {(N = 3); } anders {(N = 4); // basisry} // Serial.println (N); // vir ontwikkelingsdoeleindes // microbit.print (N); // as Line // microbit.drawLine (N, 0, 0, 4, LED_ON); // skuif waardes na volgende reël waarde4 = waarde3; waarde3 = waarde2; waarde2 = waarde1; waarde1 = waarde0; waarde0 = N; // teken prent, kolom vir kolom mikrobit.drawPixel (0, waarde0, LED_ON); // as Pixel: kolom, ry. 0, 0 linker boonste hoek mikrobit.drawPixel (1, waarde1, LED_ON); microbit.drawPixel (2, waarde2, LED_ON); microbit.drawPixel (3, waarde3, LED_ON); microbit.drawPixel (4, waarde4, LED_ON); } // stuur data na seriële monitor en seriële plotter // Serial.println (press_act); // stuur waarde (s) na die seriële poort vir numeriese vertoning, opsioneel

Serial.print (pers_akt); // stuur waarde na die seriële poort vir plotter

// teken aanwyserlyne en herstel die vertoonde reeks Serial.print ("\ t"); Reeks.afdruk (600); Serial.print ("\ t"); Serial.print (1100), Serial.print ("\ t"); Serial.println (1600); vertraging (200); // Meet drie keer per sekonde} // ----------------------------------------- -------------------------------------------------- -------------------------------------------------- - // die volgende is nodig vir die bmp/bme280-sensor, hou dit leeg as dit leeg is readTrim () {uint8_t data [32], i = 0; // Fix 2014/Wire.beginTransmission (BME280_ADDRESS); Wire.write (0x88); Wire.endTransmission (); Wire.requestFrom (BME280_ADDRESS, 24); // Herstel 2014/while (Wire.available ()) {data = Wire.read (); ek ++; } Wire.beginTransmissie (BME280_ADDRESS); // Voeg 2014/Wire.write (0xA1) by; // Voeg 2014/Wire.endTransmission () by; // Voeg 2014/Wire.requestFrom (BME280_ADDRESS, 1) by; // Voeg 2014 by/data = Wire.read (); // Voeg 2014/i ++ by; // Voeg 2014/Wire.beginTransmission (BME280_ADDRESS) by; Wire.write (0xE1); Wire.endTransmission (); Wire.requestFrom (BME280_ADDRESS, 7); // Herstel 2014/while (Wire.available ()) {data = Wire.read (); ek ++; } 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); // Herstel 2014/dig_H6 = data [31]; // Los 2014/} leegte skryfReg (uint8_t reg_address, uint8_t data) op {Wire.beginTransmission (BME280_ADDRESS); Wire.write (reg_adres); Wire.write (data); Wire.endTransmission (); }

leegte leesData ()

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

getekende lang int kalibrasie_T (onderteken lang int adc_T)

{onderteken lang int var1, var2, T; var1 = ((((adc_T >> 3) - ((onderteken lang int) dig_T1 11; var2 = (((((adc_T >> 4) - ((onderteken lang int) dig_T1)) * ((adc_T >> 4) - ((onderteken lang int) dig_T1))) >> 12) * ((onderteken lang int) dig_T3)) >> 14; t_fine = var1 + var2; T = (t_fine * 5 + 128) >> 8; terugkeer T;} ongetekende lang int kalibrasie_P (onderteken lang int adc_P) {onderteken lang int var1, var2; ongetekende lang int P; var1 = (((ondertekende lang int) t_fine) >> 1) - (onderteken lang int) 64000; var2 = (((var1 >> 2) * (var1 >> 2)) >> 11) * ((onderteken lang int) dig_P6); var2 = var2 + ((var1 * ((onderteken lang int) dig_P5)) 2) + (((onderteken lang int) dig_P4) 2) * (var1 >> 2)) >> 13)) >> 3) + (((((ondertekende lang int) dig_P2) * var1) >> 1)) >> 18; var1 = ((((32768+var1))*((onderteken lang int) dig_P1)) >> 15); as (var1 == 0) {opgawe 0; } P = (((ongetekende lang int) (((ondertekende lang int) 1048576) -adc_P)-(var2 >> 12))))*3125; as (P <0x80000000) {P = (P << 1) / ((ongetekende lang int) var1); } anders {P = (P / (ongetekende lang int) var1) * 2; } var1 = (((ondertekende lang int) dig_P9) * ((onderteken lang int) (((P >> 3) * (P >> 3)) >> 13))) >> 12; var2 = (((onderteken lang int) (P >> 2)) * ((onderteken lang int) dig_P8)) >> 13; P = (ongeteken lang int) ((onderteken lang int) P + ((var1 + var2 + dig_P7) >> 4)); terugkeer P; } ongetekende lang int kalibrasie_H (onderteken lang int adc_H) {onderteken lang int v_x1; v_x1 = (t_fine - ((onderteken lang int) 76800)); v_x1 = (((((adc_H << 14) -(((onderteken lang int) dig_H4) 15) * ((((((v_x1 * ((onderteken lang int) dig_H6)) >> 10) * (((v_x1 * ((onderteken lang int) dig_H3)) >> 11) + ((onderteken lang int) 32768))) >> 10) + ((onderteken lang int) 2097152)) * ((onderteken lang int) dig_H2) + 8192) >> 14)); v_x1 = (v_x1 - (((((v_x1 >> 15) * (v_x1 >> 15)) >> 7) * ((onderteken lang int) dig_H1)) >> 4)); v_x1 = (v_x1 419430400? 419430400: v_x1); opgawe (ongetekende lang int) (v_x1 >> 12);}

Stap 5: MakeCode/JavaScript -skrifte

Pimoroni het onlangs die enviro: bit vrygestel, met 'n BMP280 -druksensor, 'n lig-/kleursensor en 'n MEMS -mikrofoon. Hulle bied ook 'n MicroPython en 'n MakeCode/JavaScript -biblioteek aan.

Ek het later gebruik om 'n MakeCode -script vir die druksensor te skryf. Die ooreenstemmende hex -lêer kan direk na u micro: bit gekopieer word. Die kode word hieronder vertoon en kan gewysig word met die aanlyn MakeCode -redakteur.

Dit is 'n variasie van die draaiboek vir die micro: bit duik-o-meter. Dit toon standaard die drukverskil as 'n staafgrafiek. Deur op knoppie A te druk, stel die verwysingsdruk in; druk op knoppie B toon die verskil tussen die werklike en die verwysingsdruk in hPa.

Benewens die basiese strepieskode -weergawe, vind u ook 'n "X", 'n kruishaar -weergawe en 'n "L" -weergawe, wat bedoel is om die lees makliker te maak.

laat Kolom = 0

laat bly = 0 laat Ry = 0 laat Meter = 0 laat Delta = 0 laat Ref = 0 laat 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)} anders as (input.buttonIsPressed (Button. B)) {basic.showString ("" + Delta + "hPa") basic.pause (200) basic.clearScreen ()} anders {Is = envirobit.getPressure () Delta = Is - Ref Meter = Math.abs (Delta) as (Meter> = 400) {Ry = 4} anders as (Meter> = 300) {Ry = 3} anders as (Meter> = 200) {Ry = 2} anders as (Meter> = 100) {Ry = 1} anders {Ry = 0} bly = Meter - Ry * 100 as (bly> = 80) {Kolom = 4} anders as (bly> = 60) {Kolom = 3} anders as (bly> = 40) {Kolom = 2 } anders as (bly> = 20) {Kolom = 1} anders {Kolom = 0} vir (laat ColA = 0; ColA <= Kolom; ColA ++) {led.plot (ColA, Ry)} basic.pause (500)}})