Un micro-bit Dive-O-Meter: 8 pași (cu imagini)

2024 Autor: John Day | [email protected]. Modificat ultima dată: 2024-01-30 11:45

Vara este aici, timpul său de piscină!

O bună ocazie de a vă lua pe voi înșivă și pe micul dvs.: pic afară și, în acest caz, chiar în piscină.

Micrometrul de scufundare-o-metru descris aici este un gabarit simplu de adâncime DIY care vă permite să măsurați cât de adânc sunteți sau ați făcut scufundări. Acesta constă doar dintr-un micro: bit, un acumulator sau LiPo, un conector de margine pentru micro: bit, un senzor de presiune barometrică BMP280 sau BME280 și câteva cabluri jumper. Folosirea Pimoroni enviro: bit does face lucrurile din ce în ce mai simple. Toate acestea sunt ambalate în două straturi de pungi etanșe din plastic transparent sau silicon, cu unele greutăți adăugate pentru a compensa forța plutitoare.

Este o aplicație a dispozitivului cu senzor de presiune micro: bit pe care l-am descris într-o instrucțiune anterioară.

Puteți utiliza dispozitivul e. g. pentru competiții de scufundări cu prietenii și familia sau pentru a afla cât de adânc este cu adevărat acest iaz. L-am testat folosind cea mai adâncă piscină din cartierul meu și am constatat că funcționează cel puțin la o adâncime de 3,2 metri. Aproximativ cinci metri este maximul teoretic. Până acum nu i-am testat precizia în niciun detaliu, dar numerele raportate erau cel puțin în intervalul așteptat.

Câteva observații: Acesta nu trebuie să fie un instrument pentru scafandri reali. Micrul tău: bit se va deteriora dacă se udă. Utilizați acest instructable pe propriul risc.

Actualizare 27 mai: Acum puteți găsi un script MakeCode HEX pe care îl puteți încărca direct pe micro: bit. A se vedea pasul 6. Actualizare 13 iunie: Un Enviro: bit și o versiune de cablu adăugate. Vedeți pașii 7 și 8

Pasul 1: Teoria din spatele dispozitivului

Trăim pe fundul unui ocean de aer. Presiunea de aici este de aproximativ 1020 hPa (hectoPascal), deoarece greutatea coloanei de aer care se formează aici în spațiu este de aproximativ 1 kg pe centimetru pătrat.

Densitatea apei este mult mai mare, întrucât un litru de aer cântărește aproximativ 1,2 g și un litru de apă 1 kg, adică aproximativ 800 de ori. Deci, deoarece scăderea presiunii barometrice este de aproximativ 1 hPa pentru fiecare 8 metri înălțime, creșterea presiunii este de 1 hPa pentru fiecare centimetru sub suprafața apei. La o adâncime de aproximativ 10 m, presiunea este de 2000 hPa, sau două atmosfere.

Senzorul de presiune utilizat aici are un domeniu de măsurare între 750 și 1500 hPa la o rezoluție de aproximativ un hPa. Aceasta înseamnă că putem măsura adâncimi de până la 5 metri la o rezoluție de aproximativ 1 cm.

Dispozitivul ar fi un manometru de tip Boyle Marriotte. Asamblarea sa este destul de simplă și descrisă într-un pas ulterior. Senzorul folosește protocolul I2C, astfel încât un conector de margine pentru micro: bit este la îndemână. Partea cea mai critică sunt pungile etanșe, deoarece orice umiditate va deteriora micro: bitul, senzorul sau bateria. Deoarece un pic de aer va fi prins în interiorul sacilor, adăugarea de greutăți ajută la compensarea forței flotante.

Pasul 2: Utilizarea dispozitivului

Scenariul, așa cum se arată în detaliu la o etapă ulterioară, este o variantă a unui scenariu pe care l-am dezvoltat mai devreme pentru un contor de presiune. Pentru a testa dispozitivul, puteți utiliza camera de presiune simplă descrisă acolo.

În scopuri de scufundare, arată adâncimea în metri, calculată din măsurători de presiune, fie sub formă de grafic în bare în trepte de 20 cm sau, la cerere, în cifre.

Folosind butonul A de pe micro: bit, veți seta presiunea curentă ca valoare de presiune de referință. Pentru a confirma intrarea, matricea clipește o dată.

Puteți folosi acest lucru fie pentru a vedea cât de adânc vă scufundați, fie pentru a înregistra cât de adânc vă scufundați.

În primul caz, setați presiunea curentă a aerului exterior ca referință. În al doilea caz, setați presiunea în cel mai adânc punct în care vă aflați ca referință de presiune, ceea ce vă permite apoi să arătați cât de adânc ați fost când ați revenit la suprafață. Butonul B afișează adâncimea, calculată din diferența de presiune, ca valoare numerică în metri.

Pasul 3: Materiale necesare

Un micro: bit. De exemplu. la 13 GBP / 16 Euro la Pimoroni UK / DE.

Un conector de margine (Kitronic sau Pimoroni), 5 GBP. Am folosit versiunea Kitronic.

Un senzor BMP / BME280. Am folosit un senzor BMP280 de la Banggood, 4,33 Euro pentru trei unități.

Cabluri jumper pentru conectarea senzorului și a conectorului de margine.

O alternativă excelentă la combinația de conector de margine / senzor de mai sus ar putea fi Pimoroni enviro: bit (nu a fost testat până acum, vezi ultimul pas).

Un acumulator sau LiPo pentru micro: bit.

Un cablu de alimentare cu întrerupător (opțional, dar util). Ștergeți sacii etanși. Am folosit o pungă de silicon pentru un telefon mobil și una sau două pungi mici cu ziploc. Asigurați-vă că materialul este suficient de gros, astfel încât pinii de pe conectorul de margine să nu deterioreze pungile.

Unele greutăți. Am folosit bucăți de greutate de plumb care sunt folosite pentru pescuit.

Arduino IDE și mai multe biblioteci.

Pasul 4: Asamblare

Instalați Arduino IDE și bibliotecile necesare. Detaliile sunt descrise aici.

(Nu este necesar pentru scriptul MakeCode.) Având în vedere că utilizați conectorul de margine Kitronik, lipiți pinii la porturile I2C 19 și 20. Acest lucru nu este necesar pentru conectorul de margine Pimoroni. Lipiți antetul la senzorul de rupere și conectați senzorul și conectorul de margine utilizând cabluri jumper. Conectați VCC la 3V, GND la 0 V, SCL la portul 19 și SDA la portul 20. Alternativ, lipiți cablurile direct la breakout. Conectați bitul micro: la computerul nostru printr-un cablu USB. Deschideți scriptul furnizat și blocați-l pe micro: bit. Utilizați monitorul serial sau plotterul, verificați dacă senzorul oferă date rezonabile. Deconectați bitul micro: de la computer. Conectați bateria sau LiPo la micro: bit. Apăsați butonul B, citiți valoarea Apăsați butonul A. Apăsați butonul B, citiți valoarea. Așezați dispozitivul în două straturi de pungi etanșe, lăsând doar foarte puțin aer în pungi. În cazul în care, plasați o greutate pentru a compensa forța de flotabilitate. Verificați dacă totul este etanș. Du-te la biliard și joacă-te.

Pasul 5: Scriptul MicroPython

Scriptul preia doar valoarea presiunii din senzor, o compară cu valoarea de referință și apoi calculează adâncimea din diferență. Pentru afișarea valorilor sub formă de grafic cu bare, se iau întregul și restul valorii adâncimii. Primul definește înălțimea liniei. Restul este împărțit în cinci coșuri, care definesc lungimea barelor. Nivelul superior este 0 - 1 m, cel mai mic 4 - 5 m. După cum s-a menționat anterior, apăsând butonul A setează presiunea de referință, butonul B afișează „adâncimea relativă” în metri, afișată ca valoare numerică. Până acum, valorile negative și pozitive sunt prezentate sub formă de bare pe matricea LED în același mod. Simțiți-vă liber să optimizați scriptul pentru nevoile dvs. Puteți dezactiva anumite linii pentru a prezenta valorile pe monitorul serial sau pe plotter-ul Arduino IDE. Pentru a imita funcția, puteți construi dispozitivul pe care l-am descris într-o instrucțiune anterioară.

Nu am scris partea din script care citește senzorul. Nu sunt sigur de sursă, dar îmi place să le mulțumesc autorilor. Orice corecții sau indicii pentru optimizare sunt binevenite.

#include

#include microbitul Adafruit_Microbit_Matrix; #define BME280_ADDRESS 0x76 unsigned long int hum_raw, temp_raw, pres_raw; semnat lung 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; press_norm dublu = 1015; // o valoare de pornire dublă adâncime; // adâncime calculată // -------------------------------------------- -------------------------------------------------- ---------------------- void setup () {uint8_t osrs_t = 1; // Eșantionarea temperaturii x 1 uint8_t osrs_p = 1; // Eșantionarea presiunii x 1 uint8_t osrs_h = 1; // Eșantionare excesivă a umidității x 1 uint8_t mode = 3; // Mod normal uint8_t t_sb = 5; // Tstandby 1000ms uint8_t filter = 0; // Filtrează uint8_t spi3w_en = 0; // 3-fire SPI Disable uint8_t ctrl_meas_reg = (osrs_t << 5) | (osrs_p << 2) | modul; uint8_t config_reg = (t_sb << 5) | (filtrul << 2) | spi3w_en; uint8_t ctrl_hum_reg = osrs_h; pinMode (PIN_BUTTON_A, INPUT); pinMode (PIN_BUTTON_B, INPUT); Serial.begin (9600); // setați viteza portului Serial.print ("Presiune [hPa]"); // antet pentru ieșirea serială Wire.begin (); writeReg (0xF2, ctrl_hum_reg); writeReg (0xF4, ctrl_meas_reg); writeReg (0xF5, config_reg); readTrim (); // microbit.begin (); // microbit.print ("x"); întârziere (1000); } // ----------------------------------------------- ---------------------------------------------- bucla nulă () {double temp_act = 0.0, press_act = 0.0, hum_act = 0.0; semnat lung int temp_cal; unsigned long int press_cal, hum_cal; int N; int M; press_delta dublu; // presiune relativă ad adâncime_m; // adâncime în metri, parte întreagă adâncime dublă_cm; // restul în cm readData (); // temp_cal = calibration_T (temp_raw); press_cal = calibration_P (pres_raw); // hum_cal = calibration_H (hum_raw); // temp_act = (double) temp_cal / 100.0; press_act = (double) press_cal / 100.0; // hum_act = (double) hum_cal / 1024.0; microbit.clear (); // resetează matricea LED // Butonul A setează valoarea reală ca referință (P zero) // Butonul B afișează valoarea curentă ca adâncime în metri (calculată din diferența de presiune) dacă (! digitalRead (PIN_BUTTON_A)) {// setează presiunea normală a aerului ca zero press_norm = press_act; // microbit.print ("P0:"); // microbit.print (press_norm, 0); // microbit.print ("hPa"); microbit.fillScreen (LED_ON); // clipi o dată pentru a confirma întârzierea (100); } else if (! digitalRead (PIN_BUTTON_B)) {// afișează adâncimea în metri microbit.print (adâncimea, 2); microbit.print („m”); // Serial.println (""); } else {// calculează adâncimea din diferența de presiune press_delta = (press_act - press_norm); // calculați adâncimea presiunii relative = (press_delta / 100); // adâncime în metri adâncime_m = int (abs (adâncime)); // adâncime im metri adâncime_cm = (abs (adâncime) - adâncime_m); // rest / * // folosit pentru dezvoltare Serial.println (adâncime); Serial.println (depth_m); Serial.println (cm_adâncime); * / // Pași pentru graficul de bare dacă (adâncime_cm> 0,8) {// setați lungimea barelor (N = 4); } else if (depth_cm> 0.6) {(N = 3); } else if (depth_cm> 0.4) {(N = 2); } else if (depth_cm> 0.2) {(N = 1); } else {(N = 0); }

if (depth_m == 4) {// set level == metru

(M = 4); } else if (depth_m == 3) {(M = 3); } else if (depth_m == 2) {(M = 2); } else if (depth_m == 1) {(M = 1); } else {(M = 0); // rândul superior} / * // utilizat în scopuri de dezvoltare Serial.print ("m:"); Serial.println (depth_m); Serial.print ("cm:"); Serial.println (cm_adâncime); Serial.print ("M:"); Serial.println (M); // în scopuri de dezvoltare Serial.print ("N:"); Serial.println (N); // în scop de dezvoltare întârziere (500); * / // desenați bargraph microbit.drawLine (0, M, N, M, LED_ON); }

// trimite valoarea la portul serial pentru plotter

Serial.print (press_delta); // desenează linii indicator și fixează gama afișată Serial.print ("\ t"); Serial.print (0); Serial.print ("\ t"); Serial.print (-500); Serial.print ("\ t"); Serial.println (500); întârziere (500); // Măsurați de două ori pe secundă} // ----------------------------------------- -------------------------------------------------- -------------------------------------------------- -------- // următoarele sunt necesare pentru senzorul bmp / bme280, păstrați-l așa cum este nul readTrim () {uint8_t data [32], i = 0; // Fix 2014 / Wire.beginTransmission (BME280_ADDRESS); Wire.write (0x88); Wire.endTransmission (); Wire.requestFrom (BME280_ADDRESS, 24); // Fix 2014 / while (Wire.available ()) {data = Wire.read (); i ++; } Wire.beginTransmission (BME280_ADDRESS); // Adăugați 2014 / Wire.write (0xA1); // Adăugați 2014 / Wire.endTransmission (); // Adăugați 2014 / Wire.requestFrom (BME280_ADDRESS, 1); // Adăugați 2014 / data = Wire.read (); // Adăugați 2014 / i ++; // Adăugați 2014 / Wire.beginTransmission (BME280_ADDRESS); Wire.write (0xE1); Wire.endTransmission (); Wire.requestFrom (BME280_ADDRESS, 7); // Fix 2014 / while (Wire.available ()) {data = Wire.read (); i ++; } dig_T1 = (date [1] << 8) | date [0]; dig_P1 = (date [7] << 8) | date [6]; dig_P2 = (date [9] << 8) | date [8]; dig_P3 = (date [11] << 8) | date [10]; dig_P4 = (date [13] << 8) | date [12]; dig_P5 = (date [15] << 8) | date [14]; dig_P6 = (date [17] << 8) | date [16]; dig_P7 = (date [19] << 8) | date [18]; dig_T2 = (date [3] << 8) | date [2]; dig_T3 = (date [5] << 8) | date [4]; dig_P8 = (date [21] << 8) | date [20]; dig_P9 = (date [23] << 8) | date [22]; dig_H1 = date [24]; dig_H2 = (date [26] << 8) | date [25]; dig_H3 = date [27]; dig_H4 = (date [28] << 4) | (0x0F & date [29]); dig_H5 = (date [30] 4) & 0x0F); // Fix 2014 / dig_H6 = data [31]; // Remediați 2014 /} void writeReg (uint8_t reg_address, uint8_t data) {Wire.beginTransmission (BME280_ADDRESS); Wire.write (reg_address); Wire.write (date); Wire.endTransmission (); } void readData () {int i = 0; date uint32_t [8]; Wire.beginTransmission (BME280_ADDRESS); Wire.write (0xF7); Wire.endTransmission (); Wire.requestFrom (BME280_ADDRESS, 8); while (Wire.available ()) {data = Wire.read (); i ++; } pres_raw = (date [0] << 12) | (date [1] 4); temp_raw = (date [3] << 12) | (date [4] 4); hum_raw = (date [6] 3) - ((semnat lung int) dig_T1 11; var2 = (((((adc_T >> 4) - ((semnat lung int) dig_T1)) * ((adc_T >> 4) - ((semnat int lung) dig_T1))) >> 12) * ((semnat int lung) dig_T3)) >> 14; t_fine = var1 + var2; T = (t_fine * 5 + 128) >> 8; returnează T; } unsigned long int calibration_P (semnat long int adc_P) {semnat long int var1, var2; nesemnat long int P; var1 = (((semnat long int) t_fine) >> 1) - (semnat long int) 64000; var2 = (((var1 >> 2) * (var1 >> 2)) >> 11) * ((semnat lung int) dig_P6); var2 = var2 + ((var1 * ((semnat lung int) dig_P5)) 2) + (((semnat int lung) dig_P4) 2) * (var1 >> 2)) >> 13)) >> 3) + ((((semnat int lung) dig_P2) * var1) >> 1)) >> 18; var1 = (((((32768 + var1)) * ((semnat lung int) dig_P1)) >> 15); if (var1 == 0) {return 0; } P = (((unsigned long int) (((semnat long int) 1048576) -adc_P) - (var2 >> 12))) * 3125; if (P <0x80000000) {P = (P << 1) / ((unsigned long int) var1); } else {P = (P / (unsigned long int) var1) * 2; } var1 = (((semnat int lung) dig_P9) * ((semnat int lung) (((P >> 3) * (P >> 3)) >> 13))) >> 12; var2 = (((semnat lung int) (P >> 2)) * ((semnat int lung) dig_P8)) >> 13; P = (nesemnat lung int) ((semnat lung int) P + ((var1 + var2 + dig_P7) >> 4)); retur P; } unsigned long int calibration_H (semnat long int adc_H) {semnat long int v_x1; v_x1 = (t_fine - ((semnat lung int) 76800)); v_x1 = ((((((adc_H << 14) - (((semnat lung int) dig_H4) 15) * ((((((((v_x1 * ((semnat lung int) dig_H6)) >> 10) * (((v_x1 * ((semnat lung int) dig_H3)) >> 11) + ((semnat lung int) 32768))) >> 10) + ((semnat lung int) 2097152)) * ((semnat lung int) dig_H2) + 8192) >> 14)); v_x1 = (v_x1 - ((((((v_x1 >> 15) * (v_x1 >> 15)) >> 7) * ((semnat lung int) dig_H1)) >> 4)); v_x1 = (v_x1 419430400? 419430400: v_x1); return (int long long nesemnat) (v_x1 >> 12);

Pasul 6: o simplificare majoră: codul MakeCode / JavaScript

În mai 2018, Pimoroni a lansat enviro: bit, care vine cu un senzor BME280 de presiune / umiditate / temperatură, un senzor TCS3472 de lumină și culoare și un microfon MEMS. În plus, acestea oferă o bibliotecă JavaScript pentru editorul MakeCode și o bibliotecă MicroPython pentru acești senzori.

Am folosit biblioteca lor MakeCode pentru a dezvolta scripturi pentru dispozitivul meu. Atașat găsiți fișierele hexagonale corespunzătoare, pe care le puteți copia direct pe micro: bit.

Mai jos găsiți codul JavaScript corespunzător. Testarea în piscină a funcționat bine cu o versiune anterioară a scriptului, așa că presupun că vor funcționa și ele. În plus față de versiunea de bază, bargraph, există și o versiune crosshair (X) și o versiune L, destinată să ușureze citirea, în special în condiții de lumină slabă. Alegeți-l pe cel pe care îl preferați.

lasă Coloana = 0

let Meter = 0 let stay = 0 let Row = 0 let Delta = 0 let 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 ("" + Row + "." + stay + "m") basic.pause (200) basic.clearScreen ()} else {Is = envirobit.getPressure () Delta = Is - Ref Meter = Math.abs (Delta) if (Meter> = 400) {Rând = 4} else if (Meter> = 300) {Row = 3} else if (Meter> = 200) {Row = 2} else if (Meter> = 100) {Rând = 1} altceva {Rând = 0} rămâne = Meter - Rând * 100 dacă (rămâne> = 80) {Coloană = 4} altfel dacă (rămâne> = 60) {Rând = 3} altfel dacă (rămâne> = 40) {Coloană = 2} altceva dacă (rămâne> = 20) {Coloană = 1} altceva {Coloană = 0} pentru (să fie ColA = 0; ColA <= Coloană; ColA ++) {led.plot (C olA, Row)} basic.pause (500)}})

Pasul 7: Versiunea Enviro: bit

Între timp am primit enviro: bit (20 GBP) și puterea: bit (6 GBP), ambele de la Pimoroni.

Așa cum am menționat anterior, bitul enviro: vine cu senzorul de presiune, umiditate și temperatură BME280, dar și un senzor de lumină și culoare (vezi o aplicație aici) și un microfon MEMS.

Puterea: bit este o soluție plăcută pentru a alimenta micro: bit și vine cu un comutator de pornire / oprire.

Lucrul grozav este că ambele sunt doar clic și utilizare, fără lipire, cabluri, panouri. Adăugați enviro: bit la micro: bit, încărcați codul la micro: bit, utilizați-l.

În acest caz, am folosit micro, power și enviro: bit, le-am așezat într-o pungă Ziploc, l-am așezat într-o pungă de plastic transparentă etanșă la apă pentru telefoane mobile, gata. O soluție foarte rapidă și ordonată. Vezi imaginile. Comutatorul este suficient de mare pentru a-l utiliza prin straturile de protecție.

A fost testat în apă, funcționa bine. La o adâncime de aproximativ 1,8 m valoarea măsurată a fost de aproximativ 1,7 m. Nu prea rău pentru o soluție rapidă și ieftină, dar departe de a fi perfectă. Este nevoie de un timp pentru a vă ajusta, deci este posibil să fie necesar să rămâneți la o anumită adâncime timp de aproximativ 10-15 secunde.

Pasul 8: Versiunea sondei de cablu și senzor

Aceasta a fost de fapt prima idee pe care a avut-o pentru un contor de adâncime micro: bit, ultima care a fost construită.

Aici am lipit senzorul BMP280 la 5 m de cablu cu 4 fire și am așezat jumperul feminin la celălalt capăt. Pentru a proteja senzorul de apă, cablul a fost trecut printr-un dop de vin uzat. Capetele plutei au fost sigilate cu lipici fierbinte. Înainte de a tăia două crestături în plută, ambele mergând în jurul ei. Apoi am împachetat senzorul într-o minge de burete, am așezat un balon în jurul său și am fixat capătul balonului pe plută (crestătura inferioară). apoi am așezat 3 bucăți de 40 g de greutăți de plumb într-un al doilea balon, l-am înfășurat în jurul primului, greutăți plasate în partea exterioară și am fixat capătul balonului la a doua crestătură. Aerul a fost îndepărtat din al doilea balon, apoi totul a fost fixat cu bandă adezivă. Vedeți imagini, pot urma altele mai detaliate.

Jumperii au fost conectați la micro: bit printr-un conector de margine, dispozitivul a pornit și presiunea de referință a fost setată. Apoi, capul senzorului a fost eliberat încet pe fundul bazinului (turn de săritură de 10 m, adâncime de aproximativ 4,5 m).

Rezultate:

Spre uimirea mea, a funcționat chiar și cu acest cablu lung. Pe de altă parte, dar nu în mod surprinzător, eroarea de măsurare părea să devină mai mare la presiuni mai mari și o adâncime estimată de 4 m a fost raportată la aproximativ 3 m.

Aplicații potențiale:

Cu unele corecții de eroare, dispozitivul ar putea fi utilizat pentru a măsura adâncimea de aproximativ 4 m.

Împreună cu un Arduino sau Raspberry Pi, acesta ar putea fi folosit pentru a măsura și controla punctul de umplere al unui bazin sau rezervor de apă, de exemplu. pentru a evoca un avertisment dacă nivelul apei depășește sau sub anumite praguri.

Runner Up în Outdoor Fitness Challenge