A Micro: bit Dive-O-Meter: 8 stappe (met foto's)

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

Die somer is hier, sy poel tyd!

'N Goeie geleentheid om jouself en jou mikro te neem: bietjie na buite, en in hierdie geval selfs na die swembad.

Die micro: bit duik-o-meter wat hier beskryf word, is 'n eenvoudige DIY-dieptemeter waarmee u kan meet hoe diep u duik of was. Dit bestaan net uit 'n micro: bit, 'n battery pack of LiPo, 'n randverbinder vir die micro: bit, 'n BMP280 of BME280 barometriese druksensor en 'n paar springkabels. Deur die Pimoroni enviro: bit te gebruik, word dinge steeds eenvoudiger. Dit alles word verpak in twee lae waterdigte, deursigtige plastiek- of silikonesakke, met 'n paar gewigte bygevoeg om die dryfkrag te vergoed.

Dit is 'n toepassing van die mikro: bit druksensortoestel wat ek in 'n vorige instruksie beskryf het.

U mag die toestel gebruik e. g. vir duikkompetisies saam met vriende en familie, of om uit te vind hoe diep die dam werklik is. Ek het dit met die diepste swembad in my omgewing getoets en gevind dat dit ten minste tot 3,2 meter diep werk. Ongeveer vyf meter is die teoretiese maksimum. Tot dusver het ek nie die akkuraatheid daarvan in detail getoets nie, maar die gerapporteerde getalle was ten minste in die verwagte reeks.

Enkele opmerkings: Dit is nie bedoel om 'n instrument vir regte duikers te wees nie. Jou mikro: bietjie sal beskadig raak as dit nat word. U gebruik hierdie opdrag op eie risiko.

Opdateer 27 Mei: Nou kan u 'n MakeCode HEX-script vind wat u direk in u micro: bit kan laai. Sien stap 6. Opdateer 13 Junie: 'n Enviro: bit en 'n kabelweergawe bygevoeg. Sien stap 7 en 8

Stap 1: Die teorie agter die toestel

Ons leef op die bodem van 'n oseaan van lug. Die druk hier onder is ongeveer 1020 hPa (hectoPascal), aangesien die gewig van die lugkolom hier na die ruimte ongeveer 1 kg per vierkante sentimeter is.

Die digtheid van water is baie hoër, aangesien een liter lug ongeveer 1,2 g en 1 liter water 1 kg weeg, dit wil sê ongeveer 800-vouer. Aangesien die daling in barometriese druk dus ongeveer 1 hPa is vir elke 8 meter in hoogte, is die drukverhoging 1 hPa vir elke sentimeter onder die wateroppervlak. Op 'n diepte van ongeveer 10 m is die druk 2000 hPa, of twee atmosferes.

Die druksensor wat hier gebruik word, het 'n meetbereik tussen 750 en 1500 hPa met 'n resolusie van ongeveer een hPa. Dit beteken dat ons dieptes tot 5 meter kan meet met 'n resolusie van ongeveer 1 cm.

Die toestel sou 'n Boyle Marriotte -dieptemeter wees. Die samestelling daarvan is redelik eenvoudig en word in 'n latere stap beskryf. Die sensor gebruik die I2C -protokol, dus 'n randaansluiting vir die micro: bit is handig. Die mees kritieke deel is die waterdigte sakke, aangesien enige humiditeit die mikro: bit, die sensor of die battery sal beskadig. Aangesien 'n bietjie lug in die sakke vasgevang is, help die byvoeging van gewigte om die dryfkrag te vergoed.

Stap 2: Gebruik die toestel

Die draaiboek, soos in 'n latere stadium breedvoerig getoon, is 'n variasie van 'n skrif wat ek vroeër vir 'n drukmeter ontwikkel het. Om die toestel te toets, kan u die eenvoudige drukkamer gebruik wat daar beskryf word.

Vir duikdoeleindes toon dit die diepte in meter aan, bereken uit drukmetings, óf as 'n staafgrafiek in stappe van 20 cm, óf op aanvraag in getalle.

Deur die knoppie A op die micro: bit te gebruik, stel u die huidige druk in as verwysingsdrukwaarde. Om die inskrywing te bevestig, knip die matriks een keer.

U kan dit gebruik om te sien hoe diep u duik, of om aan te teken hoe diep u geduik het.

Stel in die eerste geval die huidige lugdruk buite as verwysing in. In die tweede geval, stel u die druk op die diepste punt as drukverwysing, waarmee u kan aantoon hoe diep u was toe u weer op die oppervlak was. Knoppie B vertoon die diepte, bereken uit die drukverskil, as 'n numeriese waarde in meter.

Stap 3: Vereiste materiaal

'N Mikro: bietjie. Bv. teen 13 GBP/16 Euro by Pimoroni UK/DE.

'N Randverbinder (Kitronic of Pimoroni), 5 GBP. Ek het die Kitronic -weergawe gebruik.

'N BMP/BME280 -sensor. Ek gebruik 'n BMP280 -sensor van Banggood, 4,33 Euro vir drie eenhede.

Springkabels om sensor en randaansluiting aan te sluit.

'N Uitstekende alternatief vir die kombinasie van die randaansluiting/sensor hierbo, kan Pimoroni enviro wees: bietjie (nou nie getoets nie, sien laaste stap).

'N Batterypak of LiPo vir die micro: bit.

'N Kragkabel met 'n skakelaar (opsioneel, maar nuttig). Duidelike waterdigte sakke. Ek het 'n silikoon sak vir 'n selfoon en een of twee klein ritssakke gebruik. Maak seker dat die materiaal dik genoeg is, sodat die penne op die randverbinder die sakke nie beskadig nie.

'N Paar gewigte. Ek het stukke loodgewig gebruik wat vir visvang gebruik word.

Arduino IDE, en verskeie biblioteke.

Stap 4: Montering

Installeer die Arduino IDE en die vereiste biblioteke. Besonderhede word hier beskryf.

(Nie nodig vir die MakeCode -script nie.) Aangesien u die Kitronik -randverbinder gebruik, soldeer penne aan die I2C -poorte 19 & 20. Dit is nie nodig vir die Pimoroni -randverbinder nie. Soldeer die kopstuk aan die sensor, breek uit en verbind sensor en randaansluiting met behulp van springkabels. Koppel VCC aan 3V, GND aan 0 V, SCL aan poort 19 en SDA aan poort 20. Alternatiewelik kan u die kabels direk aan die uitbreek soldeer. Koppel die micro: bit met 'n USB -kabel aan ons rekenaar. Maak die gegewe script oop en flits dit na die micro: bit. Gebruik die seriële monitor of plotter, kyk of die sensor redelike data gee. Ontkoppel die micro: bit van u rekenaar. Koppel die battery of LiPo aan die micro: bit. Druk op knoppie B, lees die waarde Druk op knoppie A. Druk op knoppie B, lees die waarde. Plaas die toestel in twee lae lugdigte sakke, en laat slegs baie min lug in die sakke. Plaas in die geval 'n gewig om die dryfkrag te vergoed. Kyk of alles waterdig is. Gaan na die swembad en speel.

Stap 5: Die MicroPython -skrip

Die skrif neem net die drukwaarde van die sensor af, vergelyk dit met die verwysingswaarde en bereken dan die diepte van die verskil. Om die waardes as 'n staafgrafiek te vertoon, word die heelgetal en die res van die dieptewaarde geneem. Die eerste definieer wel die hoogte van die lyn. Die res word in vyf asblikke ingedeel, wat die lengte van die tralies bepaal. Die boonste vlak is 0 - 1 m, die laagste 4 - 5 m. Soos voorheen genoem, stel knoppie A die verwysingsdruk in, druk knoppie B die "relatiewe diepte" in meter, vertoon as 'n numeriese waarde. Teen hierdie tyd word negatiewe en positiewe waardes op dieselfde manier as staafgrafiek op die LED -matriks voorgestel. Voel vry om die script vir u behoeftes te optimaliseer. U kan sekere reëls demp om die waardes op die seriële monitor of plotter van die Arduino IDE weer te gee. Om die funksie na te volg, kan u die toestel bou wat ek in 'n vorige instruksie beskryf het.

Ek het nie die gedeelte van die skrif wat die sensor lees, geskryf nie. Ek is nie seker oor die bron nie, maar ek bedank graag die outeurs. Enige regstellings of wenke vir optimalisering is welkom.

#insluit

#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; dubbel druk_norm = 1015; // 'n beginwaarde dubbele diepte; // berekende diepte // -------------------------------------------- -------------------------------------------------- ---------------------- void setup () {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); // stel die seriële poort spoed in Serial.print ("Druk [hPa]"); // kop vir seriële uitvoer Wire.begin (); writeReg (0xF2, ctrl_hum_reg); writeReg (0xF4, ctrl_meas_reg); writeReg (0xF5, config_reg); readTrim (); // microbit.begin (); // microbit.print ("x"); vertraging (1000); } // ----------------------------------------------- ---------------------------------------------- leegte 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; int M; dubbel druk_delta; // relatiewe druk int depth_m; // diepte in meter, heelgetal deel dubbele diepte_cm; // res in cm 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 (); // reset LED -matriks // Knoppie A stel die werklike waarde as verwysing in (P nul) // Knoppie B vertoon huidige waarde as diepte in meters (bereken uit drukverskil) as (! digitalRead (PIN_BUTTON_A)) {// stel normale lugdruk in as nul press_norm = press_act; // microbit.print ("P0:"); // microbit.print (druk_norm, 0); // microbit.print ("hPa"); microbit.fillScreen (LED_ON); // knip een keer om die vertraging (100) te bevestig; } anders as (! digitalRead (PIN_BUTTON_B)) {// vertoon diepte in meter microbit.print (diepte, 2); microbit.print ("m"); // Serial.println (""); } anders {// bereken diepte van drukverskil press_delta = (press_act - press_norm); // bereken die relatiewe drukdiepte = (druk_delta/100); // diepte in meters diepte_m = int (abs (diepte)); // diepte im meters diepte_cm = (abs (diepte) - diepte_m); // restant /* // gebruik vir ontwikkeling Serial.println (diepte); Serial.println (diepte_m); Serial.println (diepte_cm); */ // Stappe vir staafgrafiek as (diepte_cm> 0,8) {// lengte van die staaf (N = 4); } anders as (diepte_cm> 0,6) {(N = 3); } anders as (diepte_cm> 0.4) {(N = 2); } anders as (diepte_cm> 0.2) {(N = 1); } anders {(N = 0); }

as (diepte_m == 4) {// stel vlak == meter

(M = 4); } anders as (diepte_m == 3) {(M = 3); } anders as (diepte_m == 2) {(M = 2); } anders as (diepte_m == 1) {(M = 1); } anders {(M = 0); // boonste ry} /* // gebruik vir ontwikkelingsdoeleindes Serial.print ("m:"); Serial.println (diepte_m); Serial.print ("cm:"); Serial.println (diepte_cm); Serial.print ("M:"); Serial.println (M); // vir ontwikkelingsdoeleindes Serial.print ("N:"); Serial.println (N); // vir ontwikkelingsdoeleindes vertraging (500); */ // teken staafgrafiek mikrobit.drawLine (0, M, N, M, LED_ON); }

// stuur waarde na die seriële poort vir plotter

Serial.print (druk_delta); // teken aanwyserlyne en herstel die vertoonde reeks Serial.print ("\ t"); Serial.print (0); Serial.print ("\ t"); Reeks.afdruk (-500); Serial.print ("\ t"); Serial.println (500); vertraging (500); // Meet twee keer per sekonde} // ----------------------------------------- -------------------------------------------------- -------------------------------------------------- -------- // die volgende is nodig vir die bmp/bme280-sensor, hou dit leegTrim () {uint8_t data [32], i = 0; // Fix 2014/Wire.beginTransmission (BME280_ADDRESS); Wire.write (0x88); Wire.endTransmission (); Wire.requestFrom (BME280_ADDRESS, 24); // Herstel 2014/terwyl (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 (); } leeg 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] 3) - ((onderteken lang int) dig_T1 11; var2 = (((((adc_T >> 4) - ((ondertekende 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) {ondertekende 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) -(((ondertekende lang int) dig_H4) 15) * ((((((v_x1 * ((ondertekende 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 6: 'n Belangrike vereenvoudiging: die MakeCode/JavaScript -kode

In Mei 2018 het Pimoroni die enviro: bit vrygestel, met 'n BME280 druk-/humiditeits-/temperatuursensor, 'n TCS3472 lig- en kleursensor en 'n MEMS -mikrofoon. Boonop bied hulle 'n JavaScript -biblioteek aan vir die MakeCode -redakteur en 'n MicroPython -biblioteek vir hierdie sensors.

Ek het hul MakeCode -biblioteek gebruik om skrifte vir my toestel te ontwikkel. Hierby vind u die ooreenstemmende hex -lêers, wat u direk na u micro: bit kan kopieer.

Hieronder vind u die ooreenstemmende JavaScript -kode. Die toets in die swembad het goed gewerk met 'n vorige weergawe van die script, so ek neem aan dat dit ook sal werk. Benewens die basiese, staafgrafiekweergawe, is daar ook 'n kruishaar-weergawe (X) en 'n L-weergawe, wat bedoel is om die lees makliker te maak, veral onder swak lig. Kies die een wat u verkies.

laat Kolom = 0

laat Meter = 0 laat bly = 0 laat Ry = 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 ("" + Ry + "." + bly + "m") basic.pause (200) basic.clearScreen ()} anders {Is = envirobit.getPressure () Delta = Is - Ref Meter = Wiskunde.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 (C olA, ry)} basic.pause (500)}})

Stap 7: Die Enviro: bit weergawe

Intussen het ek die enviro: bit (20 GBP) en die power: bit (6 GBP) ontvang, albei van Pimoroni.

Soos voorheen genoem, kom die enviro: bit met die BME280 -druk-, humiditeits- en temperatuursensor, maar ook 'n lig- en kleursensor (sien 'n aansoek hier) en 'n MEMS -mikrofoon.

Die power: bit is 'n goeie oplossing om die micro: bit aan te dryf en kom met 'n aan/uit -skakelaar.

Die wonderlike is dat dit net klik en gebruik is, sonder soldeer, kabels, broodborde. Voeg die enviro: bit by die micro: bit, laai die kode in die micro: bit, gebruik dit.

In hierdie geval gebruik ek micro, power en enviro: bit, plaas dit in 'n Ziploc -sak, plaas dit in 'n deursigtige waterdigte plastieksak vir selfone, gereed. 'N Baie vinnige en netjiese oplossing. Sien die prente. Die skakelaar is groot genoeg om dit deur die beskermingslae te gebruik.

Dit is in water getoets, werk goed. Op 'n diepte van ongeveer 1,8 m was die gemete waarde ongeveer 1,7 m. Nie te sleg vir 'n vinnige en goedkoop oplossing nie, maar ver van perfek. Dit neem 'n rukkie om aan te pas, sodat u moontlik ongeveer 10-15 sekondes op 'n sekere diepte moet bly.

Stap 8: Weergawe van kabel- en sensorsonde

Dit was eintlik die eerste idee wat ek gehad het vir 'n micro: bit dieptemeter, die laaste wat gebou is.

Hier het ek die BMP280-sensor aan 5 m van 'n 4-draads kabel gesoldeer en 'n vroulike trui aan die ander kant geplaas. Om die sensor teen water te beskerm, is die kabel deur 'n gebruikte wynprop gevoer. Die punte van die kurk is met warm gom verseël. Voordat ek twee kepe in die kurk gesny het, het ek albei daardeur gegaan. Toe pak ek die sensor in 'n sponsbal, plaas 'n ballon om dit en maak die einde van die ballon op die kurk vas (laer kerf). dan sit ek 3 40 g stukke loodgewigte in 'n tweede ballon, draai dit om die eerste, gewigte aan die buitekant en plaas die einde van die ballon op die tweede kerf. Die lug is uit die tweede ballon verwyder, en dan is alles met kleefband vasgemaak. Sien prente, meer gedetailleerde kan volg.

Die springers is via 'n randverbinding met die micro: bit verbind, die toestel is aangeskakel en die verwysingsdruk is ingestel. Daarna is die sensorhoof stadig na die onderkant van die swembad (10 m springtoring, ongeveer 4,5 m diep) losgemaak.

Resultate:

Tot my verbasing werk dit selfs met hierdie lang kabel. Aan die ander kant, maar nie verrassend nie, blyk dit dat die meetfout by hoër druk groter word, en 'n geskatte diepte van 4 m is ongeveer 3 m gerapporteer.

Moontlike toepassings:

Met 'n paar foutregstellings kan die toestel gebruik word om diepte tot ongeveer 4 m te meet.

In kombinasie met 'n Arduino of Raspberry Pi, kan dit gebruik word om die vulpunt van 'n swembad of watertenk te meet en te beheer, bv. om 'n waarskuwing op te roep as die watervlakke bo of onder sekere drempels styg.

Naaswenner in die Outdoor Fitness Challenge