Micro: bit Dive-O-Meter: 8 sammu (piltidega)

2024 Autor: John Day | [email protected]. Viimati modifitseeritud: 2024-01-30 08:49

Suvi on käes, basseini aeg!

Hea võimalus võtta ennast ja oma mikro: hammustada õue basseini ja sel juhul isegi basseini.

Siin kirjeldatud mikro: bit sukeldumismõõtur on lihtne isetegemise sügavuse mõõtur, mis võimaldab teil mõõta, kui sügaval te sukeldusite. See koosneb ainult mikro: bitist, akust või LiPo -st, servaühendusest micro: bit, BMP280 või BME280 õhurõhu andurist ja mõnest hüppakaablist. Pimoroni ümbruse kasutamine: bit teeb asju veelgi lihtsamaks. Kõik see on pakitud kahte kihti veekindlasse läbipaistvasse plast- või silikoonkotti, millele on lisatud mõned raskused, et kompenseerida ujuvjõudu.

See on mikro -bitise rõhuanduri seadme rakendus, mida kirjeldasin eelmises juhendis.

Saate seadet kasutada e. g. sõprade ja perega sukeldumisvõistlusteks või et teada saada, kui sügav see tiik tegelikult on. Testisin seda oma naabruskonna sügavaima basseini abil ja leidsin, et see töötab vähemalt 3,2 meetri sügavusel. Umbes viis meetrit on teoreetiline maksimum. Siiani pole ma selle täpsust üksikasjalikult testinud, kuid teatatud numbrid olid vähemalt oodatud vahemikus.

Mõned tähelepanekud: see ei ole mõeldud tõeliste sukeldujate tööriistaks. Teie micro: bit saab märjaks saades kahjustada. Kasutate seda juhendit omal vastutusel.

Värskendus 27. mai: Nüüd leiate MakeCode HEX-skripti, mille saate otse oma mikro: bitile laadida. Vaadake 6. sammu. Värskendage 13. juunit: lisati Enviro: bit ja kaabli versioon. Vaadake samme 7 ja 8

Samm: seadme taga olev teooria

Me elame õhu ookeani põhjas. Siinne rõhk on umbes 1020 hPa (hectoPascal), kuna õhukolonni mass ruumis on umbes 1 kg ruutsentimeetri kohta.

Vee tihedus on palju suurem, kuna üks liiter õhku kaalub umbes 1,2 g ja üks liiter vett 1 kg, st umbes 800 korda. Seega, kuna õhurõhu langus on umbes 1 hPa iga 8 meetri kõrguse kohta, on rõhutõus 1 hPa iga sentimeetri kohta allpool veepinda. Umbes 10 m sügavusel on rõhk 2000 hPa ehk kaks atmosfääri.

Siin kasutatava rõhuanduri mõõtepiirkond on vahemikus 750 kuni 1500 hPa, eraldusvõimega umbes üks hPa. See tähendab, et saame mõõta sügavust kuni 5 meetrit umbes 1 cm eraldusvõimega.

Seade oleks Boyle Marriotte tüüpi sügavusmõõtur. Selle kokkupanek on üsna lihtne ja seda kirjeldatakse hilisemas etapis. Andur kasutab I2C protokolli, seega on micro: bit servapistik mugav. Kõige kriitilisem osa on veekindlad kotid, kuna igasugune niiskus kahjustab mikro: bitti, andurit või akut. Kuna kottide sisse jääb veidi õhku, aitab raskuste lisamine ujuvjõudu kompenseerida.

Samm: seadme kasutamine

Skript, nagu hilisemas etapis üksikasjalikult näidatud, on variatsioon skriptist, mille töötasin välja varem rõhumõõturi jaoks. Seadme testimiseks võite kasutada seal kirjeldatud lihtsat survekambrit.

Sukeldumise eesmärgil näitab see sügavust meetrites, mis on arvutatud rõhumõõtmiste põhjal, kas tulpdiagrammina 20 cm sammuga või soovi korral numbrites.

Kasutades mikro: bitti nuppu A, seadistate rõhu etalonväärtuseks hetke rõhu. Sisestuse kinnitamiseks vilgub maatriks üks kord.

Saate seda kasutada kas sukeldumise sügavuse nägemiseks või sukeldumise salvestamiseks.

Esimesel juhul seadistage võrdluseks praegune välisõhu rõhk. Teisel juhul seadistage rõhk sügavaimas kohas, kus olete rõhu võrdlusaluseks, mis võimaldab teil näidata, kui sügav olete pinnale tagasi jõudnud. Nupp B kuvab rõhu erinevuse põhjal arvutatud sügavuse numbrilise väärtusena meetrites.

Samm: vajalikud materjalid

Mikro: natuke. Nt. hinnaga 13 GBP/16 eurot Pimoroni UK/DE.

Servaühendus (Kitronic või Pimoroni), 5 GBP. Kasutasin Kitronicu versiooni.

BMP/BME280 andur. Kasutasin Banggoodilt pärit BMP280 andurit, 4,33 eurot kolme ühiku eest.

Jumperkaablid anduri ja servaühenduse ühendamiseks.

Suurepärane alternatiiv ülaltoodud servaühenduse/anduri kombinatsioonile võiks olla Pimoroni enviro: bit (praeguseks testimata, vt viimast sammu).

Aku või LiPo micro: bitile.

Lülitiga toitekaabel (valikuline, kuid kasulik). Puhastage veekindlad kotid. Kasutasin mobiiltelefoni jaoks silikoonkotti ja ühte või kahte väikest ziploc -kotti. Veenduge, et materjal on piisavalt paks, nii et servapistiku tihvtid ei kahjustaks kotte.

Mõned kaalud. Kasutasin kalapüügiks pliimassi tükke.

Arduino IDE ja mitmed raamatukogud.

4. samm: kokkupanek

Installige Arduino IDE ja vajalikud teegid. Üksikasju kirjeldatakse siin.

(Pole nõutav MakeCode'i skripti jaoks.) Kui kasutate Kitroniku servaühendust, jootke tihvtid I2C portidesse 19 ja 20. Pimoroni servaühenduse puhul pole seda vaja. Jootke päis andurile välja ja ühendage andur ja servaühendus hüppakaablitega. Ühendage VCC 3V, GND 0V, SCL porti 19 ja SDA porti 20. Alternatiivina jootke kaablid otse katkestusseadme külge. Ühendage micro: bit meie arvutiga USB -kaabli abil. Avage kaasasolev skript ja välkuge micro: bitile. Kasutage jadamonitori või plotterit, kontrollige, kas andur annab mõistlikke andmeid. Ühendage micro: bit arvutist lahti. Ühendage aku või LiPo micro: bitiga. Vajutage nuppu B, lugege väärtust Vajutage nuppu A. Vajutage nuppu B, lugege väärtust. Asetage seade kahte kihti õhukindlasse kotti, jättes kottidesse ainult väga vähe õhku. Igaks juhuks asetage ujuvuse kompenseerimiseks kaal. Kontrollige, kas kõik on veekindel. Mine basseini ja mängi.

Samm: MicroPythoni skript

Skript võtab lihtsalt andurilt rõhu väärtuse, võrdleb seda võrdlusväärtusega ja arvutab seejärel erinevuse põhjal sügavuse. Väärtuste tulpdiagrammina kuvamiseks võetakse sügavuse väärtuse täisarv ja ülejäänud osa. Esimene määrab joone kõrguse. Ülejäänud osa jagatakse viieks prügikasti, mis määravad ribade pikkuse. Ülemine tase on 0–1 m, madalaim 4–5 m. Nagu varem mainitud, määrab nupu A vajutamine võrdlusrõhu, nupp B kuvab numbrilise väärtusena „suhtelise sügavuse” meetrites. Praeguseks on negatiivsed ja positiivsed väärtused LED -maatriksil tulpdiagrammina esitatud samamoodi. Optimeerige skript vastavalt oma vajadustele. Arduino IDE jadamonitoril või plotteril väärtuste esitamiseks võite teatud ridade vaigistuse tühistada. Funktsiooni jäljendamiseks võite ehitada seadme, mida kirjeldasin eelmises juhendis.

Ma pole kirjutanud skripti osa, mis loeb andurit. Ma pole allikas kindel, kuid mulle meeldib autoreid tänada. Kõik parandused või näpunäited optimeerimiseks on teretulnud.

#kaasake

#kaasake Adafruit_Microbit_Matrix mikrobit; #define BME280_ADDRESS 0x76 allkirjastamata pikk int hum_raw, temp_raw, pres_raw; allkirjastatud pikk 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; topelt vajutage_norm = 1015; // algväärtus topelt sügavus; // arvutatud sügavus // -------------------------------------------- -------------------------------------------------- ---------------------- void setup () {uint8_t osrs_t = 1; // Temperatuuri üleproovimine x 1 uint8_t osrs_p = 1; // Rõhu üleproovimine x 1 uint8_t osrs_h = 1; // Niiskuse üleproovide võtmine x 1 uint8_t mode = 3; // Tavarežiim uint8_t t_sb = 5; // Ooterežiimis 1000ms uint8_t filter = 0; // Filtreeri välja uint8_t spi3w_en = 0; // 3-juhtmeline SPI Keela uint8_t ctrl_meas_reg = (osrs_t << 5) | (osrs_p << 2) | režiim; uint8_t config_reg = (t_sb << 5) | (filter << 2) | spi3w_et; uint8_t ctrl_hum_reg = osrs_h; pinMode (PIN_BUTTON_A, INPUT); pinMode (PIN_BUTTON_B, INPUT); Seriaalne algus (9600); // seeriapordi kiiruse määramine Serial.print ("Rõhk [hPa]"); // jada väljundi päis Wire.begin (); writeReg (0xF2, ctrl_hum_reg); writeReg (0xF4, ctrl_meas_reg); writeReg (0xF5, config_reg); readTrim (); // microbit.begin (); // mikrobit.print ("x"); viivitus (1000); } // ------------------------------------------------ ---------------------------------------------- void loop () {kahekordne temp_akt = 0.0, vajutage_akt = 0.0, hum_akt = 0.0; allkirjastatud pikk int temp_cal; allkirjastamata pikk int press_cal, hum_cal; int N; int M; topeltpress_delta; // suhteline rõhk int sügavus_m; // sügavus meetrites, täisarv kahekordne sügavus_cm; // jääk sentimeetrites readData (); // temp_cal = calibration_T (temp_raw); press_cal = calibration_P (pres_raw); // hum_cal = calibration_H (hum_raw); // temp_act = (topelt) temp_cal / 100.0; press_act = (topelt) press_cal / 100.0; // hum_act = (topelt) hum_cal / 1024,0; microbit.clear (); // LED -maatriksi lähtestamine // Nupp A määrab tegeliku väärtuse võrdluseks (P null) // Nupp B kuvab praeguse väärtuse sügavusena meetrites (arvutatakse rõhkude erinevuse põhjal), kui (! digitalRead (PIN_BUTTON_A)) {// seadistage normaalne õhurõhk nullina press_norm = press_act; // mikrobit.print ("P0:"); // mikrobit.print (press_norm, 0); // mikrobit.print ("hPa"); microbit.fillScreen (LED_ON); // vilgub üks kord, et kinnitada viivitust (100); } else if (! digitalRead (PIN_BUTTON_B)) {// kuvatakse sügavus meetrites microbit.print (sügavus, 2); mikrobit.print ("m"); // Serial.println (""); } else {// sügavuse arvutamine rõhuvahe järgi press_delta = (press_act - press_norm); // suhtelise rõhusügavuse arvutamine = (press_delta/100); // sügavus meetrites sügavus_m = int (abs (sügavus)); // sügavus im meetrit sügavus_cm = (abs (sügavus) - sügavus_m); // ülejäänud /* // kasutatakse arendamiseks Serial.println (sügavus); Seeria.println (sügavus_m); Seeria.println (sügavus_cm); */ // sammud tulpdiagrammi jaoks, kui (sügavus_cm> 0,8) {// seatud vardade pikkus (N = 4); } muidu kui (sügavus_cm> 0,6) {(N = 3); } muu kui (sügavus_cm> 0,4) {(N = 2); } muidu kui (sügavus_cm> 0,2) {(N = 1); } muu {(N = 0); }

kui (sügavus_m == 4) {// seatud tase == meeter

(M = 4); } muidu kui (sügavus_m == 3) {(M = 3); } muidu kui (sügavus_m == 2) {(M = 2); } muidu kui (sügavus_m == 1) {(M = 1); } muu {(M = 0); // ülemine rida} /* // kasutatakse arenduseesmärkidel Serial.print ("m:"); Seeria.println (sügavus_m); Seeria.print ("cm:"); Seeria.println (sügavus_cm); Serial.print ("M:"); Seeria.println (M); // arenduseesmärkidel Serial.print ("N:"); Seeria.println (N); // arengu eesmärgil viivitus (500); */ // joonista tulpgraafik microbit.drawLine (0, M, N, M, LED_ON); }

// väärtuse saatmine plotteri jadaporti

Serial.print (press_delta); // joonista indikaatorjooned ja paranda kuvatud vahemik Serial.print ("\ t"); Seeriatrükk (0); Serial.print ("\ t"); Seeriaprint (-500); Serial.print ("\ t"); Seeria.println (500); viivitus (500); // Mõõda kaks korda sekundis} // ----------------------------------------- -------------------------------------------------- -------------------------------------------------- -------- // bmp/bme280 anduri jaoks on vaja järgmist, jätke see tühjaks readTrim () {uint8_t andmed [32], i = 0; // Parandus 2014/Wire.beginTransmission (BME280_ADDRESS); Wire.write (0x88); Wire.endTransmission (); Wire.requestFrom (BME280_ADDRESS, 24); // Parandus 2014/while (Wire.available ()) {data = Wire.read (); i ++; } Wire.beginTransmission (BME280_ADDRESS); // Lisa 2014/Wire.write (0xA1); // Lisa 2014/Wire.endTransmission (); // Lisa 2014/Wire.requestFrom (BME280_ADDRESS, 1); // Lisa 2014/andmed = Wire.read (); // Lisa 2014/i ++; // Lisa 2014/Wire.beginTransmission (BME280_ADDRESS); Wire.write (0xE1); Wire.endTransmission (); Wire.requestFrom (BME280_ADDRESS, 7); // Parandus 2014/while (Wire.available ()) {data = Wire.read (); i ++; } dig_T1 = (andmed [1] << 8) | andmed [0]; dig_P1 = (andmed [7] << 8) | andmed [6]; dig_P2 = (andmed [9] << 8) | andmed [8]; dig_P3 = (andmed [11] << 8) | andmed [10]; dig_P4 = (andmed [13] << 8) | andmed [12]; dig_P5 = (andmed [15] << 8) | andmed [14]; dig_P6 = (andmed [17] << 8) | andmed [16]; dig_P7 = (andmed [19] << 8) | andmed [18]; dig_T2 = (andmed [3] << 8) | andmed [2]; dig_T3 = (andmed [5] << 8) | andmed [4]; dig_P8 = (andmed [21] << 8) | andmed [20]; dig_P9 = (andmed [23] << 8) | andmed [22]; dig_H1 = andmed [24]; dig_H2 = (andmed [26] << 8) | andmed [25]; dig_H3 = andmed [27]; dig_H4 = (andmed [28] << 4) | (0x0F ja andmed [29]); dig_H5 = (andmed [30] 4) & 0x0F); // Parandus 2014/dig_H6 = andmed [31]; // Parandage 2014/} void writeReg (uint8_t reg_address, uint8_t data) {Wire.beginTransmission (BME280_ADDRESS); Wire.write (reg_address); Wire.write (andmed); Wire.endTransmission (); } void readData () {int i = 0; uint32_t andmed [8]; Wire.beginTransmission (BME280_ADDRESS); Wire.write (0xF7); Wire.endTransmission (); Wire.requestFrom (BME280_ADDRESS, 8); while (Wire.available ()) {data = Wire.read (); i ++; } pres_raw = (andmed [0] << 12) | (andmed [1] 4); temp_raw = (andmed [3] << 12) | (andmed [4] 4); hum_raw = (andmed [6] 3) - ((allkirjastatud pikk int) dig_T1 11; var2 = ((((((adc_T >> 4) - ((allkirjastatud pikk int) dig_T1)) * ((adc_T >> 4) - ((allkirjastatud pikk int) dig_T1))) >> 12) * ((allkirjastatud pikk int) dig_T3)) >> 14; t_fine = var1 + var2; T = (t_fine * 5 + 128) >> 8; return T; } allkirjastamata pikk int kalibreerimine_P (allkirjastatud pikk int adc_P) {allkirjastatud pikk int var1, var2; allkirjastamata pikk int P; var1 = (((allkirjastatud pikk int) t_fine) >> 1) - (allkirjastatud pikk int) 64000; var2 = (((var1 >> 2) * (var1 >> 2)) >> 11) * ((allkirjastatud pikk int) dig_P6); var2 = var2 + ((var1 * ((allkirjastatud pikk int) dig_P5)) 2) + (((allkirjastatud pikk int) dig_P4) 2) * (var1 >> 2)) >> 13)) >> 3) + ((((allkirjastatud pikk int) dig_P2) * var1) >> 1)) >> 18; var1 = (((((32768+var1))*((allkirjastatud pikk int) dig_P1)) >> 15); if (var1 == 0) {return 0; } P = (((allkirjastamata pikk int) (((allkirjastatud pikk int) 1048576) -adc_P)-(var2 >> 12)))*3125; kui (P <0x80000000) {P = (P << 1) / ((allkirjastamata pikk int) var1); } else {P = (P / (allkirjastamata pikk int) var1) * 2; } var1 = (((allkirjastatud pikk int) dig_P9) * ((allkirjastatud pikk int) ((((P >> 3) * (P >> 3)) >> 13))) >> 12; var2 = (((allkirjastatud pikk int) (P >> 2)) * ((allkirjastatud pikk int) dig_P8)) >> 13; P = (allkirjastamata pikk int) ((allkirjastatud pikk int) P + ((var1 + var2 + dig_P7) >> 4)); tagasitulek P; } allkirjastamata pikk int kalibreerimine_H (allkirjastatud pikk int adc_H) {allkirjastatud pikk int v_x1; v_x1 = (t_fine - ((allkirjastatud pikk int) 76800)); v_x1 = ((((((adc_H << 14) -(((allkirjastatud pikk int) dig_H4) 15) * ((((((((v_x1 * ((allkirjastatud pikk int) dig_H6)) >> 10) * (((v_x1 * ((allkirjastatud pikk int) dig_H3)) >> 11) + ((allkirjastatud pikk int) 32768))) >> 10) + ((allkirjastatud pikk int) 2097152)) * ((allkirjastatud pikk int) dig_H2) + 8192) >> 14)); v_x1 = (v_x1 - ((((((v_x1 >> 15) * (v_x1 >> 15)) >> 7) * ((allkirjastatud pikk int) dig_H1)) >> 4)); v_x1 = (v_x1 419430400? 419430400: v_x1); return (allkirjastamata pikk int) (v_x1 >> 12);

6. samm: oluline lihtsustamine: MakeCode/JavaScripti kood

2018. aasta mais avaldas Pimoroni keskkonna: bit, mis on varustatud BME280 rõhu/niiskuse/temperatuuri anduri, TCS3472 valguse- ja värvisensori ning MEMS -mikrofoniga. Lisaks pakuvad nad MakeCode redaktori jaoks JavaScripti teeki ja nende andurite jaoks MicroPythoni raamatukogu.

Olen kasutanud nende MakeCode'i teeki oma seadme jaoks skriptide väljatöötamiseks. Lisatud leiate vastavad hex -failid, mida saate otse oma micro: bitile kopeerida.

Altpoolt leiate vastava JavaScripti koodi. Basseinis testimine töötas skripti varasema versiooniga hästi, seega eeldan, et need toimivad samuti. Lisaks baargraafilisele põhiversioonile on olemas ka ristikujuline versioon (X) ja L-versioon, mis on mõeldud lugemise hõlbustamiseks, eriti hämaras. Valige see, mida eelistate.

veerg = 0

las Meter = 0 lase jääda = 0 lase Rida = 0 las Delta = 0 lase Ref = 0 las 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 ("" + Rida + "." + jääb + "m") basic.pause (200) basic.clearScreen ()} else {Is = envirobit.getPressure () Delta = Is - Ref Meter = Matemaatika.abs (Delta), kui (meeter> = 400) {rida = 4} muu, kui (arvesti> = 300) {rida = 3} muu, kui (arvesti> = 200) {rida = 2} muu, kui (arvesti> = 100) {Rida = 1} muu {Rida = 0} jääb = arvesti - rida * 100, kui (jääb> = 80) {veerg = 4} muu, kui (jääb> = 60) {veerg = 3} muu, kui (jääb> = 40) {Veerg = 2} muu, kui (jääb> = 20) {Veerg = 1} veel {Veerg = 0} jaoks (las veerg = 0; veerg <= veerg; veerg ++) {led.plot (C olA, rida)} basic.pause (500)}})

Samm 7: Enviro: bit versioon

Vahepeal sain Pimoronilt mõlemad: enviro: bit (20 GBP) ja power: bit (6 GBP).

Nagu varem mainitud, on enviro: bitiga kaasas BME280 rõhu-, niiskus- ja temperatuuriandur, aga ka valguse- ja värviandur (vt rakendust siit) ning MEMS -mikrofon.

Power: bit on kena lahendus micro: bit'i toiteks ja on sisse/välja lülitiga.

Suurepärane on see, et mõlemad on lihtsalt klõpsatavad ja kasutatavad, ei vaja jootmist, kaableid, leivaplaate. Lisage enviro: bit mikro: bitile, laadige kood micro: bitile, kasutage seda.

Sel juhul kasutasin micro, power ja enviro: bit, panin need Ziploci kotti, panin mobiiltelefonide läbipaistvasse veekindlasse kilekotti, valmis. Väga kiire ja korralik lahendus. Vaata pilte. Lüliti on piisavalt suur, et seda kasutada kaitsekihtide kaudu.

Seda on vees testitud, see töötab hästi. Umbes 1,8 m sügavusel oli mõõdetud väärtus umbes 1,7 m. Pole liiga halb kiire ja odava lahenduse jaoks, kuid pole kaugeltki täiuslik. Kohanemine võtab natuke aega, seega peate võib-olla jääma teatud sügavusele umbes 10-15 sekundiks.

8. samm: kaabli ja anduri sondi versioon

See oli tegelikult esimene idee, mis mul oli viimane: mikro: bit sügavuse mõõtja.

Siin jootsin BMP280 anduri 5-meetrise 4-juhtmelise kaabli külge ja asetasin teise otsa naissoost hüppaja. Anduri kaitsmiseks vee eest juhiti kaabel läbi kasutatud veinikorgi. Korgi otsad suleti kuuma liimiga. Enne olin korki lõiganud kaks sälku, mõlemad käisid selle ümber. Seejärel pakkisin anduri käsnapalli, panin selle ümber õhupalli ja kinnitasin õhupalli otsa korgi külge (alumine sälk). siis panin teise õhupalli 3 40 g plii raskust, keerasin selle ümber esimese, kaalud asetasin välisküljele ja kinnitasin õhupalli otsa teise sälgu külge. Teisest õhupallist eemaldati õhk, seejärel kinnitati kõik kleeplindiga. Vaata pilte, täpsemad pildid võivad järgneda.

Džemprid ühendati servapistiku kaudu micro: bitiga, seade lülitati sisse ja seati võrdlusrõhk. Seejärel lasti anduripea aeglaselt basseini põhja (10 m hüppetorn, umbes 4,5 m sügav).

Tulemused:

Minu hämmastuseks töötas see isegi selle pika kaabliga. Teisest küljest, kuid mitte üllatavalt, tundus, et mõõtmisviga muutus suuremal rõhul suuremaks ja hinnanguline sügavus 4 m oli umbes 3 m.

Võimalikud rakendused:

Mõne veaparandusega võib seadet kasutada sügavuse mõõtmiseks umbes 4 m -ni.

Koos Arduino või Raspberry Pi -ga saab seda kasutada basseini või veepaagi täitmispunkti mõõtmiseks ja juhtimiseks, nt. hoiatada, kui veetase tõuseb teatud künnistest üle või alla.

Välitreeningu väljakutses teine koht