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

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

Sommeren er her, det er bassengtid!

En god mulighet til å ta deg selv og din micro: bit utenfor til, og i dette tilfellet til og med inn i svømmebassenget.

Micro: bit dykk-o-meteren som er beskrevet her er en enkel DIY dybdemåler som lar deg måle hvor dypt du er, eller var, dykking. Den består bare av en micro: bit, en batteripakke eller LiPo, en kantkontakt for micro: bit, en BMP280 eller BME280 barometrisk trykksensor og noen hoppekabler. Å bruke Pimoroni enviro: bit gjør ting stadig enklere. Alt dette er pakket i to lag med vanntette klare plast- eller silikonposer, med noen vekter lagt til for å kompensere for oppdriftskraften.

Det er en applikasjon av mikro: bit trykksensorenheten jeg hadde beskrevet i en tidligere instruks.

Du kan bruke enheten e. g. for dykkekonkurranser med venner og familie, eller for å finne ut hvor dypt dammen egentlig er. Jeg testet det ved å bruke det dypeste bassenget i nabolaget mitt, og fant ut at det fungerer minst til en dybde på 3,2 meter. Omtrent fem meter er det teoretiske maksimumet. Så langt har jeg ikke testet presisjonen i noen detalj, men de rapporterte tallene var i det minste i det forventede området.

Noen kommentarer: Dette er ikke ment å være et verktøy for ekte dykkere. Din micro: bit blir skadet hvis den blir våt. Du bruker dette instruerbart på egen risiko.

Oppdatering 27. mai: Nå kan du finne et MakeCode HEX-script du kan laste direkte til micro: bit. Se trinn 6. Oppdater 13. juni: En Enviro: bit og en kabelversjon lagt til. Se trinn 7 og 8

Trinn 1: Teorien bak enheten

Vi lever på bunnen av et hav av luft. Trykket her nede er ca.

Vanntettheten er mye høyere, da en liter luftvekter er omtrent 1,2 g og en liter vann 1 kg, dvs. omtrent 800 ganger. Så ettersom fallet i barometrisk trykk er omtrent 1 hPa for hver åtte meter høyde, er trykkøkningen 1 hPa for hver centimeter under vannoverflaten. På en dybde på omtrent 10 m er trykket 2000 hPa, eller to atmosfærer.

Trykkføleren som brukes her har et måleområde mellom 750 og 1500 hPa ved en oppløsning på omtrent en hPa. Dette betyr at vi kan måle dybder opptil 5 meter med en oppløsning på ca 1 cm.

Enheten ville være en dybdemåler av typen Boyle Marriotte. Monteringen er ganske enkel og beskrevet i et senere trinn. Sensoren bruker I2C -protokollen, så en kantkontakt for micro: bit kommer godt med. Den mest kritiske delen er de vanntette posene, da fuktighet vil skade mikrobiten, sensoren eller batteriet. Ettersom litt luft vil bli fanget inne i posene, bidrar tilsetningen av vekter til å kompensere for den flytende kraften.

Trinn 2: Bruke enheten

Skriptet, som vist i detalj på et senere trinn, er en variant av et manus jeg utviklet tidligere for en trykkmåler. For å teste enheten kan du bruke det enkle trykkammeret som er beskrevet der.

For dykkerformål viser den dybden i meter, beregnet ut fra trykkmålinger, enten som et stolpediagram i trinn på 20 cm eller, på forespørsel, i tall.

Ved å bruke knappen A på micro: bit, angir du gjeldende trykk som referansetrykkverdi. For å bekrefte inntasting blinker matrisen en gang.

Du kan bruke dette enten for å se hvor dypt du dykker, eller for å registrere hvor dypt du dykket.

I det første tilfellet angir du gjeldende lufttrykk utenfor som referanse. I det andre tilfellet stiller du trykket på det dypeste punktet der du var som trykkreferanse, som deretter lar deg vise hvor dypt du har vært når du er tilbake på overflaten. Knapp B viser dybden, beregnet ut fra trykkforskjellen, som en numerisk verdi i meter.

Trinn 3: Nødvendig materiale

En mikro: bit. F.eks. på 13 GBP/16 Euro hos Pimoroni UK/DE.

En kantkontakt (Kitronic eller Pimoroni), 5 GBP. Jeg brukte Kitronic -versjonen.

En BMP/BME280 sensor. Jeg brukte en BMP280 -sensor fra Banggood, 4,33 Euro for tre enheter.

Jumperkabler for tilkobling av sensor og kantkontakt.

Et utmerket alternativ til kantkontakten/sensorkombinasjonen ovenfor kan være Pimoroni enviro: bit (ikke testet nå, se siste trinn).

En batteripakke eller LiPo for micro: bit.

En strømkabel med bryter (valgfritt, men nyttig). Tette vanntette poser. Jeg brukte en silikonpose til en mobiltelefon og en eller to små ziploc -poser. Sørg for at materialet er tykt nok, så pinnene på kantkontakten vil ikke skade posene.

Noen vekter. Jeg brukte stykker blyvekt som brukes til fiske.

Arduino IDE, og flere biblioteker.

Trinn 4: Montering

Installer Arduino IDE og de nødvendige bibliotekene. Detaljer er beskrevet her.

(Ikke nødvendig for MakeCode -skriptet.) Siden du bruker Kitronik -kantkontakten, må loddestifter til I2C -portene 19 og 20. Dette er ikke nødvendig for Pimoroni -kantkontakten. Lodd overskriften til sensoren bryter ut og koble sensor og kantkontakt ved hjelp av jumperkabler. Koble VCC til 3V, GND til 0 V, SCL til port 19 og SDA til port 20. Alternativt loddes kablene direkte til utbruddet. Koble micro: bit til datamaskinen vår med en USB -kabel. Åpne det medfølgende skriptet og blits det til micro: bit. Bruk seriell skjerm eller plotter, sjekk om sensoren gir rimelige data. Koble micro: bit fra datamaskinen. Koble batteriet eller LiPo til micro: bit. Trykk på knappen B, les verdien Trykk på knappen A. Trykk på knappen B, les verdien. Plasser enheten i to lag med lufttette poser, og la det være veldig lite luft i posene. I tilfelle, legg en vekt for å kompensere oppdriftskraften. Sjekk om alt er vanntett. Gå til bassenget og lek.

Trinn 5: MicroPython -skriptet

Skriptet tar bare trykkverdien fra sensoren, sammenligner den med referanseverdien, og beregner deretter dybden fra differansen. For å vise verdiene som et stolpediagram, tas heltall og resten av dybdeverdien. Den første definerer høyden på linjen. Resten er delt inn i fem binger, som definerer lengden på stengene. Det øverste nivået er 0 - 1 m, det laveste 4-5 m. Som nevnt før, trykker du på knapp A for å angi referansetrykk, knapp B viser "relativ dybde" i meter, vist som en numerisk verdi. Nå er negative og positive verdier presentert som søylediagram på LED -matrisen på samme måte. Føl deg fri til å optimalisere skriptet for dine behov. Du kan slå på lyden for visse linjer for å vise verdiene på den serielle skjermen eller plotteren til Arduino IDE. For å etterligne funksjonen kan du bygge enheten jeg beskrev i en tidligere instruksjon.

Jeg har ikke skrevet delen av manuset som leser sensoren. Jeg er ikke sikker på kilden, men jeg takker forfatterne. Eventuelle korreksjoner eller tips for optimalisering er velkomne.

#inkludere

#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; dobbelt trykk_norm = 1015; // en startverdi dobbel dybde; // beregnet dybde // -------------------------------------------- -------------------------------------------------- ---------------------- void setup () {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); // angi seriell porthastighet Serial.print ("Trykk [hPa]"); // header for seriell utgang 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 () {dobbel 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; int M; dobbelt trykk_delta; // relativ trykk int dybde_m; // dybde i meter, heltall del dobbel dybde_cm; // resten i cm 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 // Knapp A angir faktisk verdi som referanse (P null) // Knapp B viser gjeldende verdi som dybde i meter (beregnet ut fra trykkforskjell) hvis (! digitalRead (PIN_BUTTON_A)) {// sett normalt lufttrykk som null press_norm = press_act; // microbit.print ("P0:"); // microbit.print (trykk_norm, 0); // microbit.print ("hPa"); microbit.fillScreen (LED_ON); // blink en gang for å bekrefte forsinkelse (100); } annet hvis (! digitalRead (PIN_BUTTON_B)) {// vis dybde i meter microbit.print (dybde, 2); microbit.print ("m"); // Serial.println (""); } annet {// beregne dybde fra trykkforskjell press_delta = (press_act - press_norm); // beregne relativ trykkdybde = (press_delta/100); // dybde i meter depth_m = int (abs (dybde)); // dybde im meter depth_cm = (abs (dybde) - dybde_m); // resten /* // brukt til utvikling Serial.println (dybde); Serial.println (depth_m); Serial.println (depth_cm); */ // Trinn for søylediagram hvis (dybde_cm> 0,8) {// angi lengde på stolper (N = 4); } annet hvis (dybde_cm> 0,6) {(N = 3); } annet hvis (dybde_cm> 0,4) {(N = 2); } annet hvis (dybde_cm> 0,2) {(N = 1); } annet {(N = 0); }

if (depth_m == 4) {// angitt nivå == meter

(M = 4); } annet hvis (deep_m == 3) {(M = 3); } annet hvis (deep_m == 2) {(M = 2); } annet hvis (deep_m == 1) {(M = 1); } annet {(M = 0); // øvre rad} /* // brukt til utviklingsformål Serial.print ("m:"); Serial.println (depth_m); Serial.print ("cm:"); Serial.println (depth_cm); Serial.print ("M:"); Serial.println (M); // for utviklingsformål Serial.print ("N:"); Serial.println (N); // for utviklingshensyn forsinkelse (500); */ // tegne stolpediagramm mikrobit.drawLine (0, M, N, M, LED_ON); }

// send verdi til serieport for plotter

Serial.print (trykk_delta); // tegne indikatorlinjer og fikse det viste området Serial.print ("\ t"); Serial.print (0); Serial.print ("\ t"); Serial.print (-500); Serial.print ("\ t"); Serial.println (500); forsinkelse (500); // Mål to 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] 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; returner 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 6: En stor forenkling: MakeCode/JavaScript -koden

I mai 2018 ga Pimoroni ut miljøet: bit, som følger med en BME280 trykk-/fuktighets-/temperatursensor, en TCS3472 lys- og fargesensor og en MEMS -mikrofon. I tillegg tilbyr de et JavaScript -bibliotek for MakeCode -editoren og et MicroPython -bibliotek for disse sensorene.

Jeg har brukt MakeCode -biblioteket til å utvikle skript for enheten min. Vedlagt finner du de tilhørende hex -filene, som du kan kopiere direkte til din micro: bit.

Nedenfor finner du den tilsvarende JavaScript -koden. Testing i bassenget fungerte bra med en tidligere versjon av skriptet, så jeg antar at de også vil fungere. I tillegg til den grunnleggende, stolpediagramversjonen, er det også en trådkorsversjon (X) og en L-versjon, beregnet på å gjøre lesingen lettere, spesielt under dårlige lysforhold. Velg den du foretrekker.

la kolonne = 0

la Meter = 0 la forbli = 0 la Row = 0 la Delta = 0 la Ref = 0 la 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)} annet hvis (input.buttonIsPressed (Button. B)) {basic.showString ("" + Rad + "." + forbli + "m") basic.pause (200) basic.clearScreen ()} annet {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} 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 (C olA, rad)} grunnleggende. pause (500)}})

Trinn 7: Enviro: bit -versjonen

I mellomtiden mottok jeg enviro: bit (20 GBP) og power: bit (6 GBP), begge fra Pimoroni.

Som nevnt tidligere kommer enviro: bit med BME280 trykk-, fuktighets- og temperatursensor, men også en lys- og fargesensor (se en applikasjon her) og en MEMS -mikrofon.

Power: bit er en fin løsning for å drive micro: bit og kommer med en av/på -bryter.

Det flotte er at det bare er klikk og bruk, ingen lodding, kabler, brødbrett. Legg til enviro: bit i micro: bit, last inn koden til micro: bit, bruk den.

I dette tilfellet brukte jeg micro, power og enviro: bit, la dem i en Ziploc -pose, la den i en klar vanntett plastpose for mobiltelefoner, klar. En veldig rask og ryddig løsning. Se bildene. Bryteren er stor nok til å bruke den gjennom beskyttelseslagene.

Den er testet i vann, fungerte bra. På en dybde på ca 1,8 m var måleverdien ca 1,7 m. Ikke så ille for en rask og billig løsning, men langt fra å være perfekt. Det tar litt tid å justere, så du må kanskje holde deg på en viss dybde i omtrent 10-15 sekunder.

Trinn 8: Kabel- og sensorprobeversjon

Dette var faktisk den første ideen jeg hadde for en micro: bit dybdemåler, den siste som ble bygget.

Her loddet jeg BMP280-sensoren til 5m av en 4-leder kabel og plasserte hunhopper i den andre enden. For å beskytte sensoren mot vann ble kabelen ført gjennom en brukt vinkork. Endene på korken ble forseglet med varmt lim. Før jeg hadde kuttet to hakk i korken, gikk begge rundt den. Deretter pakket jeg sensoren i en svampkule, plasserte en ballong rundt den og festet enden av ballongen på korken (nedre hakk). så la jeg 3 40 g stykker blyvekter i en andre ballong, viklet den rundt den første, vekter plassert på yttersiden og festet enden av ballongen i det andre hakk. Luften ble fjernet fra den andre ballongen, deretter ble alt fikset med tape. Se bilder, mer detaljerte kan følge.

Hopperne ble koblet til micro: bit via en kantkontakt, enheten ble slått på og referansetrykket ble satt. Deretter ble sensorhodet løsnet sakte til bunnen av bassenget (10 m hoppetårn, omtrent 4,5 m dypt).

Resultater:

Til min forbauselse fungerte det selv med denne lange kabelen. På den annen side, men ikke overraskende, syntes målefeilen å bli større ved høyere trykk, og en estimert dybde på 4 m ble rapportert til omtrent 3 m.

Potensielle applikasjoner:

Med noen feilkorrigeringer kan enheten brukes til å måle dybden til omtrent 4 m.

I forbindelse med en Arduino eller Raspberry Pi kan dette brukes til å måle og kontrollere fyllingspunktet til et basseng eller vanntank, f.eks. for å fremkalle en advarsel hvis vannstandene går over eller under visse terskler.

Runner Up i Outdoor Fitness Challenge