Micro: bit Dive-O-Meter: 8 soļi (ar attēliem)

2024 Autors: John Day | [email protected]. Pēdējoreiz modificēts: 2024-01-30 10:57

Vasara ir klāt, tās baseina laiks!

Laba iespēja aizvest sevi un savu mikro: iekost ārā uz peldbaseinu un šajā gadījumā pat uz baseinu.

Šeit aprakstītais mikro: bitu niršanas mērītājs ir vienkāršs DIY dziļuma mērītājs, kas ļauj izmērīt niršanas dziļumu. Tas sastāv tikai no micro: bit, akumulatora bloka vai LiPo, malas savienotāja micro: bit, BMP280 vai BME280 barometriskā spiediena sensora un dažiem džemperu kabeļiem. Izmantojot Pimoroni vidi: bitu, lietas kļūst arvien vienkāršākas. Tas viss ir iepakots divos ūdensnecaurlaidīgu caurspīdīgu plastmasas vai silikona maisiņu slāņos, pievienojot dažus svarus, lai kompensētu peldošo spēku.

Tas ir mikrobitu spiediena sensora ierīces pielietojums, kuru es aprakstīju iepriekšējā instrukcijā.

Ierīci var izmantot e. g. niršanas sacensībām ar draugiem un ģimeni vai lai uzzinātu, cik dziļi tas dīķis patiesībā atrodas. Es to pārbaudīju, izmantojot visdziļāko baseinu manā apkārtnē, un atklāju, ka tas darbojas vismaz 3,2 metru dziļumā. Apmēram pieci metri ir teorētiskais maksimums. Līdz šim es neesmu pārbaudījis tā precizitāti sīkāk, bet ziņotie skaitļi bija vismaz gaidītajā diapazonā.

Dažas piezīmes: Tas nav domāts kā instruments īstiem ūdenslīdējiem. Jūsu mikro: uzgalis tiks sabojāts, ja tas kļūs slapjš. Jūs izmantojat šo pamācību uz savu risku.

Atjauninājums 27. maijs: Tagad jūs varat atrast MakeCode HEX skriptu, kuru varat ielādēt tieši savā micro: bit. Skatiet 6. darbību. Atjaunināt 13. jūniju: pievienots Enviro: bits un kabeļa versija. Skatiet 7. un 8. darbību

1. darbība: teorija aiz ierīces

Mēs dzīvojam gaisa okeāna dibenā. Spiediens šeit ir aptuveni 1020 hPa (hectoPascal), jo gaisa kolonnas svars šeit līdz telpai ir aptuveni 1 kg uz kvadrātcentimetru.

Ūdens blīvums ir daudz lielāks, jo viens litrs gaisa sver aptuveni 1,2 g un viens litrs ūdens 1 kg, t.i., aptuveni 800 reizes. Tā kā barometriskā spiediena kritums ir aptuveni 1 hPa uz katriem 8 metriem augstumā, spiediena pieaugums ir 1 hPa uz katru centimetru zem ūdens virsmas. Apmēram 10 m dziļumā spiediens ir 2000 hPa jeb divas atmosfēras.

Šeit izmantotā spiediena sensora mērījumu diapazons ir no 750 līdz 1500 hPa ar izšķirtspēju aptuveni viena hPa. Tas nozīmē, ka mēs varam izmērīt dziļumu līdz 5 metriem ar aptuveni 1 cm izšķirtspēju.

Ierīce būtu Boyle Marriotte tipa dziļuma mērītājs. Tās montāža ir diezgan vienkārša un aprakstīta vēlāk. Sensors izmanto I2C protokolu, tāpēc parocīgs ir micro: bit malas savienotājs. Vissvarīgākā daļa ir ūdensnecaurlaidīgie maisiņi, jo jebkurš mitrums sabojās mikro: bitu, sensoru vai akumulatoru. Tā kā maisiņos tiks iesprostots nedaudz gaisa, svaru pievienošana palīdz kompensēt peldošo spēku.

2. darbība: ierīces lietošana

Skripts, kā detalizēti parādīts vēlāk, ir skripta variants, ko es iepriekš izstrādāju spiediena mērītājam. Lai pārbaudītu ierīci, varat izmantot tur aprakstīto vienkāršo spiediena kameru.

Niršanas nolūkos tas parāda dziļumu metros, kas aprēķināts pēc spiediena mērījumiem, vai nu kā joslu diagramma 20 cm pakāpēs, vai pēc pieprasījuma - skaitļos.

Izmantojot pogu micro: bit, jūs iestatīsit pašreizējo spiedienu kā atsauces spiediena vērtību. Lai apstiprinātu ievadīšanu, matrica vienu reizi mirgo.

Jūs varat to izmantot, lai redzētu, cik dziļi jūs nirjat, vai lai ierakstītu, cik dziļi nirāt.

Pirmajā gadījumā par atsauci iestatiet pašreizējo ārējā gaisa spiedienu. Otrajā gadījumā iestatiet spiedienu dziļākajā vietā, kur atrodaties, kā spiediena atskaiti, kas pēc tam ļauj jums parādīt, cik dziļi esat atgriezies uz virsmas. Poga B parāda dziļumu, kas aprēķināts no spiediena starpības, kā skaitlisku vērtību metros.

3. darbība. Nepieciešamie materiāli

Mikro: bits. Piem. par 13 GBP/16 eiro Pimoroni UK/DE.

Malas savienotājs (Kitronic vai Pimoroni), 5 GBP. Es izmantoju Kitronic versiju.

BMP/BME280 sensors. Es izmantoju BMP280 sensoru no Banggood, 4,33 eiro par trim vienībām.

Jumper kabeļi, lai savienotu sensoru un malu savienotāju.

Lieliska alternatīva iepriekšminētajai malu savienotāja/sensora kombinācijai varētu būt Pimoroni enviro: bit (pagaidām nav pārbaudīts, skatīt pēdējo soli).

Akumulators vai LiPo micro: bit.

Strāvas kabelis ar slēdzi (pēc izvēles, bet noderīgi). Notīriet ūdensnecaurlaidīgos maisus. Es izmantoju silikona maisiņu mobilajam tālrunim un vienu vai divus mazus ziploc maisiņus. Pārliecinieties, vai materiāls ir pietiekami biezs, tāpēc malas savienotāja tapas nesabojās somas.

Daži svari. Es izmantoju svina svara gabalus, kurus izmanto zvejai.

Arduino IDE un vairākas bibliotēkas.

4. solis: montāža

Instalējiet Arduino IDE un nepieciešamās bibliotēkas. Sīkāka informācija ir aprakstīta šeit.

(Nav nepieciešams MakeCode skriptam.) Ņemot vērā Kitronik malu savienotāju, lodējiet tapas pie I2C portiem 19 un 20. Tas nav nepieciešams Pimoroni malu savienotājam. Lodējiet galveni pie sensora un izjauciet un savienojiet sensoru un malas savienotāju, izmantojot savienojuma kabeļus. Pievienojiet VCC 3V, GND līdz 0V, SCL - 19.portam un SDA - 20.portam. Alternatīvi lodējiet kabeļus tieši pie pārtraukuma. Savienojiet micro: bit ar mūsu datoru, izmantojot USB kabeli. Atveriet piedāvāto skriptu un atlaidiet to uz micro: bit. Izmantojiet seriālo monitoru vai ploteri, pārbaudiet, vai sensors sniedz saprātīgus datus. Atvienojiet micro: bit no datora. Pievienojiet akumulatoru vai LiPo micro: bit. Nospiediet pogu B, izlasiet vērtību Nospiediet pogu A. Nospiediet pogu B, nolasiet vērtību. Ievietojiet ierīci divos hermētisku maisiņu slāņos, atstājot maisiņos tikai ļoti maz gaisa. Gadījumā, novietojiet svaru, lai kompensētu peldspējas spēku. Pārbaudiet, vai viss ir ūdensnecaurlaidīgs. Dodieties uz baseinu un spēlējiet.

5. darbība: MicroPython skripts

Skripts vienkārši ņem spiediena vērtību no sensora, salīdzina to ar atsauces vērtību un pēc tam aprēķina dziļumu no starpības. Lai parādītu vērtības kā joslu diagrammu, tiek ņemts dziļuma vērtības vesels skaitlis un atlikusī daļa. Pirmais nosaka līnijas augstumu. Pārējā daļa ir sadalīta piecās tvertnēs, kas nosaka stieņu garumu. Augšējais līmenis ir 0 - 1 m, zemākais 4 - 5 m. Kā minēts iepriekš, nospiežot pogu A, tiek iestatīts atsauces spiediens, poga B parāda "relatīvo dziļumu" metros, parādot to kā skaitlisku vērtību. Līdz šim negatīvās un pozitīvās vērtības LED matricā tiek parādītas kā joslu diagramma. Jūtieties brīvi, lai optimizētu skriptu savām vajadzībām. Varat atslēgt atsevišķu rindu skaņu, lai parādītu vērtības Arduino IDE sērijas monitorā vai ploterī. Lai atdarinātu funkciju, varat izveidot ierīci, kuru aprakstīju iepriekšējā instrukcijā.

Es neesmu uzrakstījis skripta daļu, kurā tiek lasīts sensors. Es neesmu pārliecināts par avotu, bet man patīk pateikties autoriem. Visi labojumi vai ieteikumi par optimizāciju ir laipni gaidīti.

#iekļaut

#iekļaut Adafruit_Microbit_Matrix mikrobit; #define BME280_ADDRESS 0x76 unsigned long int hum_raw, temp_raw, pres_raw; parakstīts garš 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; divreiz nospiediet_norm = 1015; // sākuma vērtības dubultā dziļums; // aprēķinātais dziļums // -------------------------------------------- -------------------------------------------------- ---------------------- void setup () {uint8_t osrs_t = 1; // Temperatūras pārmērīga paraugu ņemšana x 1 uint8_t osrs_p = 1; // Spiediena pārmērīga paraugu ņemšana x 1 uint8_t osrs_h = 1; // Mitruma pārmērīga paraugu ņemšana x 1 uint8_t režīms = 3; // Normālais režīms uint8_t t_sb = 5; // Gaidīšanas gaidīšanas režīms 1000ms uint8_t filter = 0; // Izfiltrēt uint8_t spi3w_en = 0; // 3 vadu SPI Atspējot uint8_t ctrl_meas_reg = (osrs_t << 5) | (osrs_p << 2) | režīms; uint8_t config_reg = (t_sb << 5) | (filtrs << 2) | spi3w_en; uint8_t ctrl_hum_reg = osrs_h; pinMode (PIN_BUTTON_A, INPUT); pinMode (PIN_BUTTON_B, INPUT); Sērijas sākums (9600); // iestatīt seriālā porta ātrumu Serial.print ("Spiediens [hPa]"); // sērijas izvades galvene Wire.begin (); writeReg (0xF2, ctrl_hum_reg); writeReg (0xF4, ctrl_meas_reg); writeReg (0xF5, config_reg); readTrim (); // microbit.begin (); // microbit.print ("x"); kavēšanās (1000); } // ----------------------------------------------- ---------------------------------------------- void loop () {dubultā temp_act = 0.0, press_act = 0.0, hum_act = 0.0; parakstīts garš int temp_cal; neparakstīts garš int press_cal, hum_cal; int N; int M; dubultā prese_delta; // relatīvais spiediens int dziļums_m; // dziļums metros, vesela skaitļa daļa dubultā dziļums_cm; // atlikums cm readData (); // temp_cal = calibration_T (temp_raw); press_cal = calibration_P (pres_raw); // hum_cal = calibration_H (hum_raw); // temp_act = (dubultā) temp_cal / 100.0; press_act = (dubultā) press_cal / 100.0; // hum_act = (dubultā) hum_cal / 1024,0; microbit.clear (); // atiestatīt LED matricu // Poga A nosaka faktisko vērtību kā atsauci (P nulle) // Poga B parāda pašreizējo vērtību kā dziļumu metros (aprēķina pēc spiediena starpības), ja (! digitalRead (PIN_BUTTON_A)) {// iestatīts normāls gaisa spiediens kā nulle preses_norm = preses_akts; // microbit.print ("P0:"); // mikrobit.print (preses_norm, 0); // microbit.print ("hPa"); microbit.fillScreen (LED_ON); // mirgo vienreiz, lai apstiprinātu aizkavi (100); } else if (! digitalRead (PIN_BUTTON_B)) {// displeja dziļums metros microbit.print (dziļums, 2); microbit.print ("m"); // Serial.println (""); } cits {// aprēķināt dziļumu no spiediena starpības press_delta = (press_act - press_norm); // aprēķināt relatīvo spiediena dziļumu = (press_delta/100); // dziļums metros dziļums_m = int (abs (dziļums)); // dziļums im metri dziļums_cm = (abs (dziļums) - dziļums_m); // atlikums /* // izmantots izstrādei Serial.println (dziļums); Sērijas.println (dziļums_m); Sērijas.println (dziļums_cm); */ // soļi joslu diagrammai, ja (dziļums_cm> 0,8) {// iestatīts stieņu garums (N = 4); } cits if (dziļums_cm> 0,6) {(N = 3); } cits if (dziļums_cm> 0,4) {(N = 2); } cits if (dziļums_cm> 0,2) {(N = 1); } cits {(N = 0); }

ja (dziļums_m == 4) {// iestatītais līmenis == metrs

(M = 4); } cits ja (dziļums_m == 3) {(M = 3); } cits ja (dziļums_m == 2) {(M = 2); } cits ja (dziļums_m == 1) {(M = 1); } cits {(M = 0); // augšējā rinda} /* // izmanto attīstības nolūkos Serial.print ("m:"); Sērijas.println (dziļums_m); Sērijas nospiedums ("cm:"); Sērijas.println (dziļums_cm); Serial.print ("M:"); Sērijas.println (M); // attīstības mērķiem Serial.print ("N:"); Sērijas.println (N); // attīstības nolūkos kavēšanās (500); */ // zīmēt joslu grafiku microbit.drawLine (0, M, N, M, LED_ON); }

// nosūtīt vērtību ploterim uz seriālo portu

Serial.print (press_delta); // zīmējiet indikatoru līnijas un labojiet parādīto diapazonu Serial.print ("\ t"); Sērijas nospiedums (0); Serial.print ("\ t"); Sērijas nospiedums (-500); Serial.print ("\ t"); Sērijas.println (500); kavēšanās (500); // Mērīt divreiz sekundē} // ----------------------------------------- -------------------------------------------------- -------------------------------------------------- -------- // bmp/bme280 sensoram ir jārīkojas šādi, paturiet to tukšu readTrim () {uint8_t data [32], i = 0; // Labot 2014/Wire.beginTransmission (BME280_ADDRESS); Wire.write (0x88); Wire.endTransmission (); Wire.requestFrom (BME280_ADDRESS, 24); // Labot 2014/while (Wire.available ()) {data = Wire.read (); i ++; } Wire.beginTransmission (BME280_ADDRESS); // Pievienot 2014/Wire.write (0xA1); // Pievienot 2014/Wire.endTransmission (); // Pievienot 2014/Wire.requestFrom (BME280_ADDRESS, 1); // Pievienot 2014/data = Wire.read (); // Pievienot 2014/i ++; // Pievienot 2014/Wire.beginTransmission (BME280_ADDRESS); Wire.write (0xE1); Wire.endTransmission (); Wire.requestFrom (BME280_ADDRESS, 7); // Labot 2014/while (Wire.available ()) {data = Wire.read (); i ++; } dig_T1 = (dati [1] << 8) | dati [0]; dig_P1 = (dati [7] << 8) | dati [6]; dig_P2 = (dati [9] << 8) | dati [8]; dig_P3 = (dati [11] << 8) | dati [10]; dig_P4 = (dati [13] << 8) | dati [12]; dig_P5 = (dati [15] << 8) | dati [14]; dig_P6 = (dati [17] << 8) | dati [16]; dig_P7 = (dati [19] << 8) | dati [18]; dig_T2 = (dati [3] << 8) | dati [2]; dig_T3 = (dati [5] << 8) | dati [4]; dig_P8 = (dati [21] << 8) | dati [20]; dig_P9 = (dati [23] << 8) | dati [22]; dig_H1 = dati [24]; dig_H2 = (dati [26] << 8) | dati [25]; dig_H3 = dati [27]; dig_H4 = (dati [28] << 4) | (0x0F & dati [29]); dig_H5 = (dati [30] 4) & 0x0F); // Labot 2014/dig_H6 = dati [31]; // Labot 2014/} void writeReg (uint8_t reg_address, uint8_t data) {Wire.beginTransmission (BME280_ADDRESS); Wire.write (reg_address); Wire.write (dati); Wire.endTransmission (); } void readData () {int i = 0; uint32_t dati [8]; Wire.beginTransmission (BME280_ADDRESS); Wire.write (0xF7); Wire.endTransmission (); Wire.requestFrom (BME280_ADDRESS, 8); while (Wire.available ()) {data = Wire.read (); i ++; } pres_raw = (dati [0] << 12) | (dati [1] 4); temp_raw = (dati [3] << 12) | (dati [4] 4); hum_raw = (dati [6] 3) - ((parakstīts garš int) dig_T1 11; var2 = ((((((adc_T >> 4) - ((parakstīts garš int) dig_T1)) * ((adc_T >> 4) - ((parakstīts garš int) dig_T1))) >> 12) * ((parakstīts garš int) dig_T3)) >> 14; t_fine = var1 + var2; T = (t_fine * 5 + 128) >> 8; atgriezties T; } unsigned long int calibration_P (parakstīts garš int adc_P) {parakstīts garš int var1, var2; neparakstīts garš int P; var1 = (((parakstīts garš int) t_fine) >> 1) - (parakstīts garš int) 64000; var2 = (((var1 >> 2) * (var1 >> 2)) >> 11) * ((parakstīts garš int) dig_P6); var2 = var2 + ((var1 * ((parakstīts garš int) dig_P5)) 2) + (((parakstīts garš int) dig_P4) 2) * (var1 >> 2)) >> 13)) >> 3) + ((((parakstīts garš int) dig_P2) * var1) >> 1)) >> 18; var1 = (((((32768+var1))**((parakstīts garš int) dig_P1)) >> 15); ja (var1 == 0) {atgriezties 0; } P = (((neparakstīts garš int) (((parakstīts garš int) 1048576) -adc_P)-(var2 >> 12)))*3125; ja (P <0x80000000) {P = (P << 1) / ((neparakstīts garš int) var1); } cits {P = (P / (neparakstīts garš int) var1) * 2; } var1 = (((parakstīts garš int) dig_P9) * ((parakstīts garš int) (((P >> 3) * (P >> 3)) >> 13)))) >> 12; var2 = (((parakstīts garš int) (P >> 2)) * ((parakstīts garš int) dig_P8)) >> 13; P = (neparakstīts garš int) ((parakstīts garš int) P + ((var1 + var2 + dig_P7) >> 4)); atgriezties P; } unsigned long int calibration_H (parakstīts long int adc_H) {parakstīts long int v_x1; v_x1 = (t_smalks - ((parakstīts garš int) 76800)); v_x1 = ((((((adc_H << 14) -(((parakstīts garš int) dig_H4) 15) * (((((((v_x1 * ((parakstīts garš int) dig_H6)) >> 10) * (((v_x1 * ((parakstīts garš int) dig_H3)) >> 11) + ((parakstīts garš int) 32768))) >> 10) + ((parakstīts garš int) 2097152)) * ((parakstīts garš int) dig_H2) + 8192) >> 14)); v_x1 = (v_x1 - ((((((v_x1 >> 15) * (v_x1 >> 15)) >> 7) * ((parakstīts garš int) dig_H1)) >> 4)); v_x1 = (v_x1 419430400? 419430400: v_x1); atgriezties (neparakstīts garš int) (v_x1 >> 12);

6. darbība. Būtiska vienkāršošana: MakeCode/JavaScript kods

2018. gada maijā Pimoroni ir izlaidis vidi: bit, kas ir aprīkots ar BME280 spiediena/mitruma/temperatūras sensoru, TCS3472 gaismas un krāsu sensoru un MEMS mikrofonu. Turklāt viņi piedāvā JavaScript bibliotēku MakeCode redaktoram un MicroPython bibliotēku šiem sensoriem.

Esmu izmantojis viņu MakeCode bibliotēku, lai izstrādātu skriptus savai ierīcei. Pievienots atrodat atbilstošos hex failus, kurus varat kopēt tieši savā micro: bit.

Zemāk jūs atradīsit atbilstošo JavaScript kodu. Testēšana baseinā labi darbojās ar agrāku skripta versiju, tāpēc pieņemu, ka tie arī darbosies. Papildus pamata joslu diagrammas versijai ir arī krusta versija (X) un L versija, kas paredzēta lasīšanas atvieglošanai, īpaši vājā apgaismojumā. Izvēlieties sev tīkamāko.

ļaujiet kolonnai = 0

Ļaujiet Meter = 0 ļauj palikt = 0 ļaujiet Rindai = 0 let Delta = 0 ļaujiet Ref = 0 let 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)} else if (input.buttonIsPressed (Button. B)) {basic.showString ("" + Rinda + "." + paliek + "m") basic.pause (200) basic.clearScreen ()} else {Is = envirobit.getPressure () Delta = Is - Ref Meter = Math.abs (Delta), ja (Meter> = 400) {Row = 4} else if (Meter> = 300) {Row = 3} else if (Meter> = 200) {Row = 2} else if (Meter> = 100)) {Rinda = 1} cits {Rinda = 0} paliek = Metrs - Rinda * 100, ja (paliek> = 80) {Kolonna = 4} cits, ja (paliek> = 60) {Kolonna = 3} cits, ja (paliek> = 40) {Column = 2} else if (stay> = 20) {Column = 1} else {Column = 0} for (let ColA = 0; ColA <= Column; ColA ++) {led.plot (C olA, Rinda)} pamata.pauze (500)}})

7. darbība: vide: bitu versija

Tikmēr es saņēmu enviro: bit (20 GBP) un power: bit (6 GBP), abi no Pimoroni.

Kā minēts iepriekš, enviro: bit ir komplektā ar BME280 spiediena, mitruma un temperatūras sensoru, bet arī ar gaismas un krāsu sensoru (skatiet lietojumprogrammu šeit) un MEMS mikrofonu.

Power: bit ir jauks risinājums, lai darbinātu micro: bit, un tam ir ieslēgšanas/izslēgšanas slēdzis.

Lieliski ir tas, ka tas ir tikai klikšķis un lietošana, bez lodēšanas, kabeļiem, maizes dēļiem. Pievienojiet enviro: bit micro: bit, ielādējiet kodu micro: bit, izmantojiet to.

Šajā gadījumā es izmantoju micro, power un enviro: bit, ievietoju tos Ziploc maisiņā, ievietoju dzidrā, ūdensnecaurlaidīgā plastmasas maisiņā mobilajiem tālruņiem, gatavs. Ļoti ātrs un sakārtots risinājums. Skatiet attēlus. Slēdzis ir pietiekami liels, lai to varētu izmantot caur aizsargkārtām.

Tas ir pārbaudīts ūdenī, darbojas labi. Aptuveni 1,8 m dziļumā izmērītā vērtība bija aptuveni 1,7 m. Nav pārāk slikti ātram un lētam risinājumam, bet tālu no perfekta. Lai pielāgotos, nepieciešams zināms laiks, tāpēc jums, iespējams, būs jāpaliek noteiktā dziļumā apmēram 10-15 sekundes.

8. darbība: kabeļa un sensora zondes versija

Šī patiesībā bija pirmā ideja par mikro: bitu dziļuma mērītāju, kas tika izveidots pēdējais.

Šeit es pielodēju BMP280 sensoru līdz 5 m 4 vadu kabelim un otrā galā ievietoju sieviešu džemperi. Lai aizsargātu sensoru no ūdens, kabelis tika izvadīts caur lietotu vīna korķi. Korķa galus aizzīmogoja ar karstu līmi. Pirms es biju iegriezis korķī divus iegriezumus, abi gāja visapkārt. Tad es iesaiņoju sensoru sūkļa bumbiņā, ap to uzliku balonu un piestiprināju balona galu pie korķa (apakšējais iecirtums). tad es otrā balonā ievietoju 3 40 g svina svaru gabalus, aptinu to ap pirmo, svarus novietoju ārējā pusē un nostiprināju balona galu otrajā iecirtumā. Gaiss tika noņemts no otrā balona, pēc tam viss tika fiksēts ar līmlenti. Skatiet attēlus, var sekot detalizētāki attēli.

Džemperi tika savienoti ar micro: bit, izmantojot malas savienotāju, ierīce tika ieslēgta un tika iestatīts atskaites spiediens. Tad sensora galva lēnām tika izlaista līdz baseina apakšai (10 m lektornis, apmēram 4,5 m dziļš).

Rezultāti:

Man par izbrīnu, tas darbojās pat ar šo garo kabeli. No otras puses, bet nav pārsteidzoši, ka mērījumu kļūda, šķiet, kļuva lielāka pie lielāka spiediena, un aptuvenais 4 m dziļums tika ziņots kā aptuveni 3 m.

Potenciālie pielietojumi:

Ar dažiem kļūdu labojumiem ierīci var izmantot, lai izmērītu dziļumu līdz aptuveni 4 m.

Kopā ar Arduino vai Raspberry Pi to varētu izmantot, lai izmērītu un kontrolētu baseina vai ūdens tvertnes uzpildes punktu, piem. lai brīdinātu, ja ūdens līmenis pārsniedz vai zem noteiktiem sliekšņiem.

Otrās vietas ieguvējs āra fitnesa izaicinājumā