A Micro: bit Dive-O-Meter: 8 steg (med bilder)

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

Sommaren är här, det är pooltid!

Ett bra tillfälle att ta dig själv och din micro: bit utanför till, och i det här fallet till och med, i poolen.

Micro: bit dive-o-meter som beskrivs här är en enkel DIY-djupmätare som låter dig mäta hur djup du är, eller var, dykning. Den består bara av en micro: bit, ett batteri eller LiPo, en kantkontakt för micro: bit, en BMP280 eller BME280 barometrisk trycksensor och några bygelkablar. Att använda Pimoroni enviro: bit gör saker allt enklare. Allt detta är packat i två lager av vattentäta genomskinliga plast- eller silikonpåsar, med några vikter till för att kompensera flytkraften.

Det är en tillämpning av mikro: bit trycksensorn som jag hade beskrivit i en tidigare instruerbar.

Du kan använda enheten e. g. för dykningstävlingar med vänner och familj, eller för att ta reda på hur djupt den dammen egentligen är. Jag testade den med den djupaste poolen i mitt grannskap och fann att den fungerar åtminstone till ett djup av 3,2 meter. Cirka fem meter är det teoretiska maxvärdet. Hittills har jag inte testat dess precision i någon detalj, men de rapporterade siffrorna låg åtminstone i det förväntade intervallet.

Några anmärkningar: Detta är inte avsett att vara ett verktyg för riktiga dykare. Din micro: bit skadas om den blir våt. Du använder detta instruerbart på egen risk.

Uppdatering 27 maj: Nu kan du hitta ett MakeCode HEX-skript som du kan ladda direkt till din micro: bit. Se steg 6. Uppdatera 13 juni: En Enviro: bit och en kabelversion tillagd. Se steg 7 och 8

Steg 1: Teorin bakom enheten

Vi lever på botten av ett hav av luft. Trycket här nere är cirka 1020 hPa (hectoPascal) eftersom vikten av luftkolonnens form här till rymden är cirka 1 kg per kvadratcentimeter.

Vattentätheten är mycket högre, eftersom en liter luft väger cirka 1,2 g och en liter vatten 1 kg, det vill säga cirka 800-faldigt. Så eftersom fallet i barometertryck är cirka 1 hPa för var 8: e meter i höjd, är tryckökningen 1 hPa för varje centimeter under vattenytan. På cirka 10 m djup är trycket 2000 hPa, eller två atmosfärer.

Trycksensorn som används här har ett mätområde mellan 750 och 1500 hPa vid en upplösning på cirka en hPa. Det betyder att vi kan mäta djup upp till 5 meter med en upplösning på cirka 1 cm.

Enheten skulle vara en djupmätare av Boyle Marriotte -typ. Monteringen är ganska enkel och beskrivs i ett senare steg. Sensorn använder I2C -protokollet, så en kantkontakt för micro: bit kommer till hands. Den mest kritiska delen är de vattentäta påsarna, eftersom all luftfuktighet kommer att skada mikrobit: sensorn eller batteriet. Eftersom lite luft kommer att fångas in i påsarna, hjälper tillägget av vikter att kompensera den flytande kraften.

Steg 2: Använda enheten

Skriptet, som visas i detalj vid ett senare steg, är en variant av ett manus som jag utvecklat tidigare för en tryckmätare. För att testa enheten kan du använda den enkla tryckkammare som beskrivs där.

För dykning visar det djupet i meter, beräknat från tryckmätningar, antingen som ett stapeldiagram i steg om 20 cm eller, på begäran, i siffror.

Med knappen A på micro: bit, kommer du att ställa in det aktuella trycket som referenstrycksvärde. För att bekräfta inmatningen blinkar matrisen en gång.

Du kan använda det här antingen för att se hur djupt du dyker eller för att spela in hur djupt du dök.

I det första fallet ställer du in det aktuella lufttrycket utanför som referens. I det andra fallet ställer du in trycket på den djupaste punkten där du var som tryckreferens, vilket sedan låter dig visa hur djup du har varit när du är tillbaka på ytan. Knapp B visar djupet, beräknat från tryckskillnaden, som ett numeriskt värde i meter.

Steg 3: Material som krävs

En mikro: bit. T.ex. på 13 GBP/16 Euro på Pimoroni UK/DE.

En kantkontakt (Kitronic eller Pimoroni), 5 GBP. Jag använde Kitronic -versionen.

En BMP/BME280 sensor. Jag använde en BMP280 -sensor från Banggood, 4,33 Euro för tre enheter.

Bygelkablar för anslutning av sensor och kantkontakt.

Ett utmärkt alternativ till kantkontakten/sensorkombinationen ovan kan vara Pimoroni enviro: bit (har inte testats nu, se sista steget).

Ett batteri eller LiPo för micro: bit.

En strömkabel med strömbrytare (valfritt men användbart). Tydda vattentäta påsar. Jag använde en silikonficka för en mobiltelefon och en eller två små ziplocpåsar. Se till att materialet är tillräckligt tjockt så att stiften på kantkontakten inte skadar påsarna.

Några vikter. Jag använde bitar av blyvikt som används för fiske.

Arduino IDE och flera bibliotek.

Steg 4: Montering

Installera Arduino IDE och de nödvändiga biblioteken. Detaljer beskrivs här.

(Krävs inte för MakeCode -skriptet.) Eftersom du använder Kitronik -kantkontakten, lödstift till I2C -portarna 19 & 20. Detta krävs inte för Pimoroni -kantkontakten. Löd huvudet till sensorn bryt ut och anslut sensor och kantkontakt med hjälp av bygelkablar. Anslut VCC till 3V, GND till 0 V, SCL till port 19 och SDA till port 20. Alternativt löd kablarna direkt till brytningen. Anslut micro: bit till vår dator med en USB -kabel. Öppna det medföljande skriptet och blinka det till micro: bit. Använd seriell bildskärm eller plotter, kontrollera om sensorn ger rimliga data. Koppla bort micro: bit från din dator. Anslut batteriet eller LiPo till micro: bit. Tryck på knapp B, läs värdet Tryck på knapp A. Tryck på knapp B, läs värdet. Placera enheten i två lager av lufttäta påsar och lämna endast mycket lite luft i påsarna. Lägg i så fall en vikt för att kompensera flytkraften. Kontrollera om allt är vattentätt. Gå till poolen och spela.

Steg 5: MicroPython -skriptet

Skriptet tar bara tryckvärdet från sensorn, jämför det med referensvärdet och beräknar sedan djupet från skillnaden. För att visa värdena som ett stapeldiagram tas heltalet och resten av djupvärdet. Den första definierar höjden på linjen. Resten är uppdelad i fem fack, som definierar längden på staplarna. Den övre nivån är 0 - 1 m, den lägsta 4-5 m. Som nämnts tidigare, trycker du på knapp A för att ställa in referenstrycket, knapp B visar det "relativa djupet" i meter, visat som ett numeriskt värde. Vid det här laget presenteras negativa och positiva värden som stapeldiagram på LED -matrisen på samma sätt. Känn dig fri att optimera skriptet för dina behov. Du kan koppla bort vissa rader för att presentera värdena på den seriella bildskärmen eller plotteren för Arduino IDE. För att efterlikna funktionen kan du bygga den enhet som jag beskrev i en tidigare instruktion.

Jag har inte skrivit den del av manuset som läser sensorn. Jag är inte säker på källan, men jag vill tacka författarna. Eventuella korrigeringar eller tips för optimering är välkomna.

#omfatta

#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; dubbel tryck_norm = 1015; // ett startvärde dubbel djup; // beräknat djup // -------------------------------------------- ---------------------------------------------------------- ---------------------- 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); // ställ in serieportens hastighet Serial.print ("Tryck [hPa]"); // rubrik för seriell utmatning 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 () {dubbel 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; int M; dubbel tryck_delta; // relativt tryck int djup_m; // djup i meter, heltal del dubbel djup_cm; // resten i cm 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 // Knapp A anger det faktiska värdet som referens (P noll) // Knapp B visar aktuellt värde som djup i meter (beräknat från tryckskillnad) om (! digitalRead (PIN_BUTTON_A)) {// ställ in normalt lufttryck som noll press_norm = press_act; // microbit.print ("P0:"); // microbit.print (press_norm, 0); // microbit.print ("hPa"); microbit.fillScreen (LED_ON); // blinka en gång för att bekräfta fördröjning (100); } annat om (! digitalRead (PIN_BUTTON_B)) {// visa djup i meter microbit.print (djup, 2); microbit.print ("m"); // Serial.println (""); } annat {// beräkna djup från tryckskillnad press_delta = (press_act - press_norm); // beräkna relativt tryckdjup = (press_delta/100); // djup i meter djup_m = int (abs (djup)); // djup im meter djup_cm = (abs (djup) - djup_m); // resten /* // används för utveckling Serial.println (djup); Serial.println (djup_m); Serial.println (djup_cm); */ // Steg för stapeldiagram om (djup_cm> 0,8) {// inställd längd på staplar (N = 4); } annars if (djup_cm> 0,6) {(N = 3); } annars if (djup_cm> 0,4) {(N = 2); } annars if (djup_cm> 0,2) {(N = 1); } annat {(N = 0); }

if (djup_m == 4) {// inställd nivå == meter

(M = 4); } annars if (djup_m == 3) {(M = 3); } annars if (djup_m == 2) {(M = 2); } annars if (djup_m == 1) {(M = 1); } annat {(M = 0); // övre raden} /* // används för utvecklingsändamål Serial.print ("m:"); Serial.println (djup_m); Serial.print ("cm:"); Serial.println (djup_cm); Serial.print ("M:"); Serial.println (M); // för utvecklingsändamål Serial.print ("N:"); Serial.println (N); // för utvecklingsändamål fördröjning (500); */ // rita stapeldiagram microbit.drawLine (0, M, N, M, LED_ON); }

// skicka värde till serieport för plotter

Serial.print (press_delta); // rita indikatorlinjer och fixa visat intervall Serial.print ("\ t"); Serial.print (0); Serial.print ("\ t"); Serial.print (-500); Serial.print ("\ t"); Serial.println (500); fördröjning (500); // Mät två 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] 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; returnera 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 6: En större förenkling: MakeCode/JavaScript -koden

I maj 2018 släppte Pimoroni enviro: bit, som levereras med en BME280 tryck-/fukt-/temperatursensor, en TCS3472 ljus- och färgsensor och en MEMS -mikrofon. Dessutom erbjuder de ett JavaScript -bibliotek för MakeCode -redigeraren och ett MicroPython -bibliotek för dessa sensorer.

Jag har använt deras MakeCode -bibliotek för att utveckla skript för min enhet. Bifogad hittar du de hex -filer som du kan kopiera direkt till din micro: bit.

Nedan hittar du motsvarande JavaScript -kod. Testning i poolen fungerade bra med en tidigare version av manuset, så jag antar att de kommer att fungera också. Förutom den grundläggande, bargrafiska versionen, finns det också en hårkorsversion (X) och en L-version, avsedd att göra läsningen enklare, särskilt under svagt ljus. Välj den du föredrar.

låt kolumn = 0

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

Steg 7: Enviro: bitversionen

Under tiden fick jag enviro: bit (20 GBP) och power: bit (6 GBP), båda från Pimoroni.

Som nämnts tidigare kommer enviro: bit med BME280 tryck-, fukt- och temperatursensor, men också en ljus- och färgsensor (se en applikation här) och en MEMS -mikrofon.

Power: bit är en bra lösning för att driva micro: bit och levereras med en på/av -omkopplare.

Det fina är att det bara är klick och användning, ingen lödning, kablar, brödbrädor. Lägg till enviro: bit i micro: bit, ladda koden till micro: bit, använd den.

I det här fallet använde jag micro, power och enviro: bit, placerade dem i en Ziploc -väska, lade den i en klar vattentät plastpåse för mobiltelefoner, klar. En mycket snabb och snygg lösning. Se bilderna. Brytaren är tillräckligt stor för att använda den genom skyddslagen.

Den har testats i vatten, fungerade bra. På ett djup av cirka 1,8 m var det uppmätta värdet cirka 1,7 m. Inte så illa för en snabb och billig lösning, men långt ifrån perfekt. Det tar ett tag att justera, så du kan behöva stanna på ett visst djup i cirka 10-15 sekunder.

Steg 8: Kabel- och sensorsondversion

Detta var faktiskt den första idén jag hade för en micro: bit djupmätare, den sista som skulle byggas.

Här lödde jag BMP280-sensorn till 5 m av en 4-tråds kabel och placerade honbygel i andra änden. För att skydda sensorn från vatten, leddes kabeln genom en begagnad vinkork. Korkens ändar förseglades med varmt lim. Innan jag hade klippt två hack i korken, båda gick runt det. Sedan packade jag in sensorn i en svampboll, placerade en ballong runt den och fixerade ballongens ände på korken (nedre hack). sedan placerade jag 3 40 g bitar blyvikter i en andra ballong, lindade den runt den första, vikterna placerade på utsidan och fixerade ballongens ände vid det andra hacket. Luften togs bort från den andra ballongen, sedan fixerades allt med gaffatejp. Se bilder, mer detaljerade kan följa.

Hopparna var anslutna till micro: bit via en kantkontakt, enheten slogs på och referenstrycket var inställt. Sedan släpptes sensorhuvudet långsamt till botten av poolen (10 m hopptorn, cirka 4,5 m djupt).

Resultat:

Till min förvåning fungerade det även med denna långa kabel. Å andra sidan, men inte överraskande, tycktes mätfelet bli större vid högre tryck och ett uppskattat djup på 4 m rapporterades som cirka 3 m.

Potentiella tillämpningar:

Med några felkorrigeringar kan enheten användas för att mäta djupet till cirka 4 m.

I kombination med en Arduino eller Raspberry Pi kan detta användas för att mäta och kontrollera fyllningspunkten för en pool eller vattentank, t.ex. att framkalla en varning om vattennivåerna går över eller under vissa trösklar.

Tvåa i Outdoor Fitness Challenge