Măsurați presiunea cu micro: bit: 5 pași (cu imagini)

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

Următorul instructabil descrie un dispozitiv ușor de construit și ieftin pentru a efectua măsurători de presiune și pentru a demonstra legea lui Boyle, utilizând bitul micro: în combinație cu senzorul de presiune / temperatură BMP280.

În timp ce această combinație seringă / senzor de presiune a fost deja descrisă într-unul din instructabilele mele anterioare, combinația cu micro: bit oferă noi oportunități, de ex. pentru proiecte de sală de clasă.

În plus, numărul descrierilor aplicațiilor în care micro: bit este utilizat în combinație cu un senzor I2C este destul de limitat până acum. Sper că acest instructable ar putea fi un punct de plecare pentru alte proiecte.

Dispozitivul permite efectuarea de măsurători cantitative ale presiunii aerului și afișarea rezultatelor pe tabloul de LED-uri micro: bit sau pe un computer conectat, pentru utilizarea ulterioară a funcțiilor monitorului serial sau a plotterului serial al Arduino IDE. În plus, aveți un feedback haptic, deoarece veți împinge sau trage singur pistonul seringii și veți simți prin aceasta puterea necesară.

În mod implicit, afișajul vă permite să estimați presiunea cu ajutorul indicatorului de nivel afișat pe matricea LED. Plotterul serial al Arduino IDE permite să facă același lucru, dar cu o rezoluție mult mai bună (vezi video). Sunt disponibile și soluții mai elaborate, de ex. în limba de procesare. De asemenea, puteți afișa valorile măsurate precise ale presiunii și temperaturii pe matricea LED după apăsarea butoanelor A sau B respectiv, dar monitorul serial al Arduino IDE este mult mai rapid, permițând afișarea valorilor aproape în timp real.

Costurile totale și abilitățile tehnice necesare pentru a construi dispozitivul sunt destul de mici, deci ar putea fi un proiect frumos la clasă sub supravegherea unui profesor. În plus, dispozitivul ar putea fi un instrument pentru proiectele STEM cu accent pe fizică sau utilizat în alte proiecte în care o forță sau o greutate trebuie transformată într-o valoare digitală.

Principiul a fost folosit pentru a construi un micro: bit dive-o-meter foarte simplu, un dispozitiv pentru a măsura cât de adânc te scufunzi.

Addendum 27-mai-2018:

Deoarece Pimoroni a dezvoltat o bibliotecă MakeCode pentru senzorul BMP280, acest lucru mi-a oferit ocazia să dezvolt un script care să fie utilizat pentru dispozitivul descris aici. Scriptul și fișierul HEX corespunzător pot fi găsite în ultimul pas al acestui instructable. Pentru a-l utiliza, încărcați doar fișierul HEX pe micro: bit. Nu este nevoie de software special și puteți utiliza editorul MakeCode online pentru editarea scriptului.

Pasul 1: Materiale uzate

• Un micro: bit, a primit al meu de la Pimoroni - 13,50 GBP
• Conector Kitronic Edge pentru micro: bit - prin Pimoroni - 5 GBP, Observație: Pimorini oferă acum un conector de margine compatibil cu panourile numit pin: bit cu pini pe porturile I2C.
• 2 benzi de antet cu 2 pini
• Baterie sau LiPo pentru micro: bit (nu este necesar, dar util), cablu baterie cu comutator (dito) - Pimoroni
• cabluri jumper pentru conectarea senzorilor la conectorul Edge
• cabluri jumper lungi (!) pentru senzor, cel puțin atât cât seringa,, f / f sau f / m
• Senzor de presiune și temperatură BMP280 - Banggood - 5 USD pentru trei unități Domeniul de măsurare pentru acest senzor este cuprins între 550 și 1537 hPa.
• Seringă de cateter din plastic de 150 ml cu garnitură de cauciuc - magazinele Amazon sau hardware și grădină - aproximativ 2-3 USD
• pistol cu lipici fierbinte / lipici fierbinte
• ciocan de lipit
• un computer cu Arduino IDE instalat

Pasul 2: Instrucțiuni de asamblare

Anteturi de lipit la ieșirea senzorului BMP280.

Lipiți cele două anteturi cu 2 pini la pinii 19 și pinii 20 ai conectorilor conectorului Edge (a se vedea imaginea).

Conectați bitul micro: la conectorul Edge și la computer.

Pregătiți software și micro: bit așa cum este descris în instrucțiunile Adafruit micro: bit. Citiți-le cu atenție.

Instalați bibliotecile necesare pe Arduino IDE.

Deschideți scriptul BMP280 atașat într-un pas ulterior.

Conectați senzorul la conectorul Edge. GND la 0V, VCC la 3V, SCL la pinul 19, SDA la pinul 20.

Încărcați scriptul pe micro: bit.

Verificați dacă senzorul oferă date rezonabile, valorile presiunii ar trebui să fie de aproximativ 1020 hPa, afișate pe monitorul serial. În caz, verificați mai întâi cablurile și conexiunile, apoi instalarea software-ului și corectați.

Opriți micro: bit, scoateți senzorul.

Treceți cablurile jumperului lung prin ieșirea seringii. În caz că va trebui să lărgiți deschiderea. Aveți grijă să omiteți că cablurile se deteriorează.

Conectați senzorul la cablurile jumper. Verificați dacă conexiunile sunt corecte și bune. Conectați-vă la micro: bit.

Verificați dacă senzorul funcționează corect. Trageți cu grijă cablurile, mutați senzorul în partea superioară a seringii.

Introduceți pistonul și deplasați-l puțin mai departe decât poziția de repaus dorită (100 ml).

Adăugați adeziv fierbinte la capătul orificiului de evacuare a seringii și mutați pistonul puțin înapoi. Verificați dacă seringa este închisă etanș la aer, altfel adăugați mai mult adeziv fierbinte. Lăsați să răcească lipiciul fierbinte.

Verificați din nou dacă senzorul funcționează. Dacă mutați pistonul, numerele de pe monitorul serial și afișajul micro: bit ar trebui să se schimbe.

Dacă este necesar, puteți ajusta volumul în seringă strângând-o lângă garnitură și deplasând pistonul.

Pasul 3: Un pic de teorie și câteva măsurători practice

Cu dispozitivul descris aici, puteți demonstra corelația de compresie și presiune în experimente simple de fizică. Deoarece seringa vine cu o scară „ml”, chiar și experimentele cantitative sunt ușor de realizat.

Teoria din spatele ei: Conform legii lui Boyle, [Volumul * Presiunea] este o valoare constantă pentru un gaz la o temperatură dată.

Aceasta înseamnă că dacă comprimați un volum dat de gaz N-ori, adică volumul final este 1 / N ori din original, presiunea acestuia va crește N-ori, ca: P0 * V0 = P1 * V1 = contra t. Pentru mai multe detalii, vă rugăm să aruncați o privire la articolul Wikipedia privind legile gazelor. La nivelul mării, presiunea barometrică este de obicei în intervalul de 1010 hPa (hecto Pascal).

Deci, începând de la un punct de odihnă de ex. V0 = 100 ml și P0 = 1000 hPa, o comprimare a aerului la aproximativ 66 ml (adică V1 = 2/3 * V0) va avea ca rezultat o presiune de aproximativ 1500 hPa (P1 = 3/2 din P0). Tragerea pistonului la 125 ml (5/4 ori volum) are ca rezultat o presiune de aproximativ 800 hPa (presiune 4/5). Măsurătorile sunt uimitor de precise pentru un dispozitiv atât de simplu.

Dispozitivul vă permite să aveți o impresie haptică directă câtă forță este necesară pentru a comprima sau extinde cantitatea relativ mică de aer din seringă.

Dar, de asemenea, putem efectua unele calcule și le putem verifica experimental. Să presupunem că comprimăm aerul la 1500 hPa, la o presiune barometrică bazală de 1000 hPa. Deci diferența de presiune este de 500 hPa sau 50 000 Pa. Pentru seringa mea, diametrul (d) pistonului este de aproximativ 4 cm sau 0,04 metri.

Acum puteți calcula forța necesară pentru a ține pistonul în poziția respectivă. Dat fiind P = F / A (presiunea este forța împărțită la suprafață) sau F = P * A transformat. Unitatea SI pentru forță este "Newton" N, pentru lungimea "Meter" m, iar 1 Pa este 1N pe metru pătrat. Pentru un piston rotund, aria poate fi calculată folosind A = ((d / 2) ^ 2) * pi, ceea ce dă 0,00125 metri pătrați pentru seringa mea. Asa de

50, 000 Pa * 0,00125 m ^ 2 = 63 N.

Pe Pământ, 1 N se corelează cu o greutate de 100 gr, deci 63 N sunt egale cu o greutate de 6,3 kg.

Acest lucru poate fi verificat cu ușurință utilizând o scală. Împingeți seringa cu pistonul pe cântar, până când se atinge o presiune de aproximativ 1500 hPa, apoi citiți cântarul. Sau apăsați până când cântarul arată aproximativ 6-7 kg, apoi apăsați butonul „A” și citiți valoarea afișată pe matricea LED a micro: bitului. După cum sa dovedit, estimarea bazată pe calculele de mai sus nu a fost rea. O presiune ușor peste 1500 hPa corelată cu o „greutate” afișată de aproximativ 7 kg pe o scară corporală (vezi imagini). De asemenea, ați putea întoarce acest concept și puteți utiliza dispozitivul pentru a construi o scală digitală simplă bazată pe măsurători de presiune.

Rețineți că limita superioară pentru senzor este de aproximativ 1540 hPa, astfel încât orice presiune peste aceasta nu poate fi măsurată și poate deteriora senzorul.

Pe lângă scopuri educaționale, se poate folosi sistemul și pentru unele aplicații din lumea reală, deoarece permite măsurarea cantitativă a forțelor care încearcă să deplaseze pistonul într-un fel sau altul. Așadar, puteți măsura o greutate plasată pe piston sau o forță de impact care lovește pistonul. Sau construiți un comutator care activează o lumină sau un buzzer sau redă un sunet după ce a fost atinsă o anumită valoare prag. Sau puteți construi un instrument muzical care schimbă frecvența în funcție de puterea forței aplicate pistonului. Sau folosește-l ca controler de joc. Folosește-ți imaginația și joacă-te!

Pasul 4: Scriptul MicroPython

Atașat găsiți scriptul meu BMP280 pentru micro: bit. Este un derivat al unui script BMP / BME280 pe care l-am găsit undeva pe site-ul web Banggood, combinat cu biblioteca Microbit a Adafruit. Primul vă permite să utilizați senzorul Banggood, al doilea simplifică manipularea afișajului LED 5x5. Mulțumirile mele se adresează dezvoltatorilor ambelor.

În mod implicit, scriptul afișează rezultatele măsurătorilor de presiune în 5 pași pe afișajul LED 5x5 al micro: bit, permițând vizualizarea modificărilor cu o mică întârziere. Valorile precise pot fi afișate în paralel pe monitorul serial Arduino IDE sau un grafic mai detaliat poate fi afișat plotterul serial al Arduino IDE.

Dacă apăsați butonul A, valorile măsurate ale presiunii sunt afișate pe matricea de LED-uri 5x5 a micro: bitului. Dacă apăsați butonul B, se afișează valorile temperaturii. Deși acest lucru permite citirea datelor precise, încetinesc semnificativ ciclurile de măsurare.

Sunt sigur că există modalități mult mai elegante de a programa sarcinile și de a îmbunătăți scriptul. Orice ajutor este binevenit.

#include xxx

#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; // containere pentru valori măsurate int valoare0; int valoare1; valoare int2; valoare int3; valoare int4; // ------------------------------------------------ -------------------------------------------------- ------------------ 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); // Serial.println ("Temperatura [deg C]"); // Serial.print ("\ t"); Serial.print ("Presiune [hPa]"); // antet 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); } // ----------------------------------------------- -------------------------------------------------- -------- void loop () {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; // setați valorile de prag pentru afișarea cu matrice LED, în hPa dublu max_0 = 1100; dublu max_1 = 1230; dublu max_2 = 1360; dublu max_3 = 1490; 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 / * Serial.print ("PRESS:"); Serial.println (press_act); Serial.print ("hPa"); Serial.print ("TEMP:"); Serial.print ("\ t"); Serial.println (temp_act); * / if (! digitalRead (PIN_BUTTON_B)) {// afișarea valorilor în numere întârzie măsurarea cercurilor microbit.print ("T:"); microbit.print (temp_act, 1); microbit.print ("'C"); // Serial.println (""); } else if (! digitalRead (PIN_BUTTON_A)) {microbit.print ("P:"); microbit.print (press_act, 0); microbit.print ("hPa"); } else {// afișarea valorilor presiunii ca pixeli sau linii într-un anumit nivel // 5 pași: 1490 hPa // praguri definite de valorile max_n if (press_act> max_3) {(N = 0); // rândul superior} else if (press_act> max_2) {(N = 1); } else if (press_act> max_1) {(N = 2); } else if (press_act> max_0) {(N = 3); } else {(N = 4); // rândul de bază} // Serial.println (N); // în scopuri de dezvoltare // microbit.print (N); // ca Linie // microbit.drawLine (N, 0, 0, 4, LED_ON); // deplasați valorile la următoarea linie value4 = value3; valoare3 = valoare2; valoare2 = valoare1; valoare1 = valoare0; valoare0 = N; // desenează imagine, coloană cu coloană microbit.drawPixel (0, valoare0, LED_ON); // ca Pixel: coloană, rând. 0, 0 colțul din stânga sus microbit.drawPixel (1, valoare1, LED_ON); microbit.drawPixel (2, valoare2, LED_ON); microbit.drawPixel (3, valoare3, LED_ON); microbit.drawPixel (4, valoare4, LED_ON); } // trimite date către monitorul serial și plotterul serial // Serial.println (press_act); // trimiteți valori la portul serial pentru afișare numerică, opțional

Serial.print (press_act); // trimite valoarea la portul serial pentru plotter

// desenează linii indicator și fixează gama afișată Serial.print ("\ t"); Serial.print (600); Serial.print ("\ t"); Serial.print (1100), Serial.print ("\ t"); Serial.println (1600); întârziere (200); // Măsurați de trei ori pe secundă} // ---------------------------------------- -------------------------------------------------- -------------------------------------------------- - // următoarele sunt necesare pentru senzorul bmp / bme280, păstrați-l ca fiind 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] << 8) | date [7]; }

calibrat int lung semnat_T (semnat int lung adc_T)

{semnat lung int var1, var2, T; var1 = ((((adc_T >> 3) - ((semnat lung int) dig_T1 11; var2 = (((((adc_T >> 4) - ((semnat lung int) dig_T1)) * ((adc_T >> 4) - ((semnat lung int) dig_T1))) >> 12) * ((semnat int lung) dig_T3)) >> 14; t_fine = var1 + var2; T = (t_fine * 5 + 128) >> 8; returnare 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 int lung) dig_H1)) >> 4)); v_x1 = (v_x1 419430400? 419430400: v_x1); return (int long long nesemnat) (v_x1 >> 12);}

Pasul 5: Scripturi MakeCode / JavaScript

Pimoroni a lansat recent enviro: bit, care vine cu un senzor de presiune BMP280, un senzor de lumină / culoare și un microfon MEMS. De asemenea, oferă un MicroPython și o bibliotecă MakeCode / JavaScript.

Am folosit versiunea ulterioară pentru a scrie un script MakeCode pentru senzorul de presiune. Fișierul hexagonal corespunzător poate fi copiat direct pe micro: bit. Codul este afișat mai jos și poate fi modificat folosind editorul MakeCode online.

Este o variantă a scriptului pentru scufundarea micro-bit. În mod implicit, afișează diferența de presiune ca un grafic cu bare. Apăsarea butonului A setează presiunea de referință, apăsarea butonului B afișează diferența dintre presiunea reală și presiunea de referință în hPa.

În plus față de versiunea de bază a codului de bare, găsiți și o versiune "X", o versiune încrucișată și o versiune "L", destinată să ușureze citirea.

lasă Coloana = 0

să rămână = 0 să Rând = 0 să Meter = 0 să Delta = 0 să Ref = 0 să 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 ("" + Delta + "hPa") 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) {Row = 1} else {Rând = 0} rămâne = Meter - Rând * 100 if (rămâne> = 80) {Coloană = 4} else if (rămâne> = 60) {Coloană = 3} else if (rămâne> = 40) {Coloană = 2 } else if (stay> = 20) {Column = 1} else {Column = 0} for (let ColA = 0; ColA <= Column; ColA ++) {led.plot (ColA, Row)} basic.pause (500)}})