Izmēriet spiedienu ar savu mikro: bits: 5 soļi (ar attēliem)

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

Turpmāk sniegtajā instrukcijā aprakstīta viegli uzbūvējama un lēta ierīce spiediena mērīšanai un Boila likuma demonstrēšanai, izmantojot micro: bit kombinācijā ar BMP280 spiediena/temperatūras sensoru.

Tā kā šī šļirces/spiediena sensora kombinācija jau ir aprakstīta vienā no maniem iepriekšējiem norādījumiem, kombinācija ar micro: bit piedāvā jaunas iespējas, piem. klases telpu projektiem.

Turklāt to lietojumu aprakstu skaits, kuros micro: bit tiek lietots kombinācijā ar sensoru I2C, līdz šim ir diezgan ierobežots. Es ceru, ka šī pamācība varētu būt sākumpunkts citiem projektiem.

Ierīce ļauj veikt kvantitatīvus gaisa spiediena mērījumus un parādīt rezultātus mikro bitu LED blokā vai savienotā datorā, lai vēlāk izmantotu Arduino IDE sērijas monitora vai sērijveida plotera funkcijas. Turklāt jums ir haptiska atgriezeniskā saite, jo jūs pats spiežat vai velkat šļirces virzuli un jūtat vajadzīgo jaudu.

Pēc noklusējuma displejs ļauj novērtēt spiedienu pēc līmeņa indikatora, kas redzams uz LED matricas. Arduino IDE sērijas ploteris ļauj darīt to pašu, bet ar daudz labāku izšķirtspēju (skat. Video). Ir pieejami arī sarežģītāki risinājumi, piem. apstrādes valodā. Jūs varat arī parādīt precīzas izmērītās spiediena un temperatūras vērtības uz LED matricas, nospiežot attiecīgi A vai B pogas, taču Arduino IDE sērijas monitors ir daudz ātrāks, ļaujot parādīt vērtības gandrīz reālā laikā.

Kopējās izmaksas un tehniskās prasmes, kas nepieciešamas ierīces izveidošanai, ir diezgan zemas, tāpēc tas varētu būt jauks klases projekts skolotāja uzraudzībā. Turklāt ierīce varētu būt rīks STEM projektiem, koncentrējoties uz fiziku, vai izmantot citos projektos, kur spēks vai svars jāpārveido par digitālu vērtību.

Šo principu izmantoja, lai izveidotu ļoti vienkāršu mikro: bitu niršanas mērītāju-ierīci niršanas dziļuma mērīšanai.

2018. gada 27. maija papildinājums:

Tā kā Pimoroni ir izstrādājis MakeCode bibliotēku BMP280 sensoram, tas man deva iespēju izstrādāt skriptu, kas jāizmanto šeit aprakstītajai ierīcei. Skriptu un atbilstošo HEX failu var atrast šīs pamācības pēdējā solī. Lai to izmantotu, vienkārši ielādējiet HEX failu savā micro: bit. Nav nepieciešama īpaša programmatūra, un skripta rediģēšanai varat izmantot tiešsaistes MakeCode redaktoru.

1. darbība: izmantotie materiāli

• A micro: bit, dabūja manu no Pimoroni - 13.50 GBP
• Kitronic Edge Connector for micro: bit - via Pimoroni - 5 GBP, Piezīme: Pimorini tagad piedāvā maizei draudzīgu malas savienotāju ar nosaukumu pin: bit ar tapām I2C portos.
• 2 x 2 tapas galvenes sloksnes
• Akumulators vai LiPo mikro: bits (nav nepieciešams, bet noderīgs), akumulatora kabelis ar slēdzi (dito) - Pimoroni
• džempera kabeļi sensoru pievienošanai Edge savienotājam
• sena (!) džempera kabeļi sensoram, vismaz tik gari kā šļirce,, f/f vai f/m
• BMP280 spiediena un temperatūras sensors - Banggood - 5 ASV dolāri par trim vienībām. Šī sensora mērījumu diapazons ir no 550 līdz 1537 hPa.
• 150 ml plastmasas katetra šļirce ar gumijas blīvi - Amazon vai datortehnikas un dārza veikalos - apmēram 2–3 ASV dolāri
• karstā līme/karstās līmes pistole
• lodāmurs
• dators ar instalētu Arduino IDE

2. solis: montāžas instrukcijas

Lodēšanas galvenes uz BMP280 sensora izlaušanos.

Lodējiet abas 2 kontaktu galvenes pie Edge savienotāja 19. un 20. tapas savienotājiem (skatiet attēlu).

Savienojiet micro: bit ar Edge savienotāju un datoru.

Sagatavojiet programmatūru un micro: bit, kā aprakstīts Adafruit micro: bit instrukcijās. Rūpīgi izlasiet tos.

Instalējiet nepieciešamās bibliotēkas Arduino IDE.

Atveriet BMP280 skriptu, kas pievienots vēlāk.

Pievienojiet sensoru Edge savienotājam. GND līdz 0 V, VCC līdz 3 V, SCL līdz 19. tapai, SDA līdz 20. tapai.

Augšupielādējiet skriptu uz micro: bit.

Pārbaudiet, vai sensors sniedz saprātīgus datus, spiediena vērtībām jābūt aptuveni 1020 hPa, kas parādītas sērijas monitorā. Gadījumā, ja vispirms pārbaudiet kabeļus un savienojumus, tad programmatūras instalāciju un izlabojiet.

Izslēdziet micro: bit, noņemiet sensoru.

Izvelciet garo džemperu kabeļus caur šļirces izeju. Gadījumā, ja jums būs jāpaplašina atvere. Uzmanieties, lai izvairītos no kabeļu bojājumiem.

Savienojiet sensoru ar džempera kabeļiem. Pārbaudiet, vai savienojumi ir pareizi un labi. Izveidojiet savienojumu ar micro: bit.

Pārbaudiet, vai sensors darbojas pareizi. Uzmanīgi pavelkot kabeļus, pārvietojiet sensoru uz šļirces augšpusi.

Ievietojiet virzuli un pārvietojiet to nedaudz tālāk par vēlamo atpūtas stāvokli (100 ml).

Pievienojiet karstu līmi šļirces izejas galam un nedaudz pavirziet virzuli atpakaļ. Pārbaudiet, vai šļirce ir aizvērta hermētiski, pretējā gadījumā pievienojiet vēl karstu līmi. Ļauj atdzist karsto līmi.

Vēlreiz pārbaudiet, vai sensors darbojas. Ja pārvietojat virzuli, numuriem sērijveida monitorā un micro: bit displejā vajadzētu mainīties.

Ja nepieciešams, varat pielāgot šļirces tilpumu, saspiežot to starplikas tuvumā un pārvietojot virzuli.

3. solis: mazliet teorijas un daži praktiski mērījumi

Izmantojot šeit aprakstīto ierīci, vienkāršos fizikas eksperimentos varat parādīt kompresijas un spiediena korelāciju. Tā kā šļircei ir "ml" skala, pat kvantitatīvus eksperimentus ir viegli veikt.

Teorija aiz tās: Saskaņā ar Boila likumu [tilpums * spiediens] ir nemainīga gāzes vērtība noteiktā temperatūrā.

Tas nozīmē, ka, saspiežot noteiktu gāzes daudzumu N-kārtā, t.i., galīgais tilpums ir 1/N reizes lielāks par oriģinālu, tā spiediens palielināsies N-kārtīgi, piemēram: P0*V0 = P1*V1 = mīnus t. Lai iegūtu sīkāku informāciju, lūdzu, apskatiet Wikipedia rakstu par gāzes likumiem. Jūras līmenī barometriskais spiediens parasti ir 1010 hPa (hecto Pascal).

Tātad, sākot no atpūtas vietām, piem. V0 = 100 ml un P0 = 1000 hPa, gaisa saspiešana līdz aptuveni 66 ml (t.i., V1 = 2/3 * V0) radīs aptuveni 1500 hPa spiedienu (P1 = 3/2 no P0). Pavelkot virzuli līdz 125 ml (5/4 reizes lielāks), spiediens ir aptuveni 800 hPa (4/5 spiediens). Šādas vienkāršas ierīces mērījumi ir pārsteidzoši precīzi.

Ierīce ļauj jums radīt tiešu haptisku iespaidu, cik daudz spēka nepieciešams, lai saspiestu vai paplašinātu salīdzinoši nelielu gaisa daudzumu šļircē.

Bet mēs varam arī veikt dažus aprēķinus un pārbaudīt tos eksperimentāli. Pieņemsim, ka mēs saspiežam gaisu līdz 1500 hPa pie bazālā barometriskā spiediena 1000 hPa. Tātad spiediena starpība ir 500 hPa jeb 50 000 Pa. Manai šļircei virzuļa diametrs (d) ir aptuveni 4 cm jeb 0,04 metri.

Tagad jūs varat aprēķināt spēku, kas vajadzīgs, lai virzuli noturētu šajā pozīcijā. Dots P = F/A (spiediens ir spēks dalīts ar laukumu) vai pārveidots F = P*A. Spēka SI mērvienība ir "Ņūtons" N, garumam "Metrs" m, un 1 Pa ir 1 N uz kvadrātmetru. Apaļam virzuļam laukumu var aprēķināt, izmantojot A = ((d/2)^2)*pi, kas manai šļircei dod 0,00125 kvadrātmetrus. Tātad

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

Uz Zemes 1 N korelē ar svaru 100 gr, tātad 63 N ir vienāds ar 6,3 kg svara turēšanu.

To var viegli pārbaudīt, izmantojot skalu. Piespiediet šļirci ar virzuli uz skalas, līdz tiek sasniegts aptuveni 1500 hPa spiediens, pēc tam nolasiet skalu. Vai arī spiediet, līdz skala rāda apmēram 6-7 kg, pēc tam nospiediet pogu "A" un izlasiet vērtību, kas parādīta micro: bit LED matricā. Kā izrādījās, aprēķins, kas balstīts uz iepriekšminētajiem aprēķiniem, nebija slikts. Spiediens nedaudz virs 1500 hPa korelē ar uzrādīto aptuveni 7 kg ķermeņa svaru ķermeņa svarā (skatīt attēlus). Jūs varētu arī mainīt šo koncepciju un izmantot ierīci, lai izveidotu vienkāršu digitālo skalu, pamatojoties uz spiediena mērījumiem.

Lūdzu, ņemiet vērā, ka sensora augšējā robeža ir aptuveni 1540 hPa, tāpēc spiedienu virs tā nevar izmērīt un tas var sabojāt sensoru.

Papildus izglītojošiem mērķiem sistēmu var izmantot arī dažām reālās pasaules lietojumprogrammām, jo tā ļauj kvantitatīvi izmērīt spēkus, kas mēģina virzīt virzuli vienā vai otrā virzienā. Tātad jūs varētu izmērīt svaru, kas novietots uz virzuļa, vai trieciena spēku, kas triecas uz virzuli. Vai arī izveidojiet slēdzi, kas aktivizē gaismu vai skaņas signālu vai atskaņo skaņu pēc noteiktas sliekšņa vērtības sasniegšanas. Vai arī jūs varat izveidot mūzikas instrumentu, kas maina frekvenci atkarībā no virzuļa spēka. Vai arī izmantojiet to kā spēļu kontrolieri. Izmantojiet savu iztēli un spēlējiet!

4. solis: MicroPython skripts

Pielikumā jūs atradīsit manu BMP280 skriptu micro: bit. Tas ir atvasinājums no BMP/BME280 skripta, ko es atradu kaut kur Banggood vietnē, apvienojumā ar Adafruit Microbit bibliotēku. Pirmais ļauj izmantot Banggood sensoru, otrais vienkāršo 5x5 LED displeja apstrādi. Pateicos abu izstrādātājiem.

Pēc noklusējuma skripts parāda spiediena mērījumu rezultātus 5 soļos micro: bit 5x5 LED displejā, ļaujot redzēt izmaiņas ar nelielu kavēšanos. Precīzas vērtības var parādīt paralēli Arduino IDE sērijas monitorā, vai arī detalizētāku grafiku var attēlot Arduino IDE sērijas ploterī.

Nospiežot pogu A, izmērītās spiediena vērtības tiek parādītas micro: bit 5x5 LED blokā. Nospiežot pogu B, tiek parādītas temperatūras vērtības. Lai gan tas ļauj nolasīt precīzus datus, tas ievērojami palēnina mērījumu ciklus.

Esmu pārliecināts, ka ir daudz elegantu veidu, kā programmēt uzdevumus un uzlabot skriptu. Jebkura palīdzība ir laipni gaidīta.

#iekļaut xxx

#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; // konteineri izmērītajām vērtībām int value0; int vērtība1; int vērtība2; int vērtība3; int vērtība4; // ------------------------------------------------ -------------------------------------------------- ------------------ 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); // Serial.println ("Temperatūra [° C]"); // Serial.print ("\ t"); Serial.print ("Spiediens [hPa]"); // 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 () {double 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; // iestatīt sliekšņa vērtības LED matricas displejam, hPa dubultā max_0 = 1100; dubultā max_1 = 1230; dubultā max_2 = 1360; dubultā max_3 = 1490; readData (); temp_cal = calibration_T (temp_raw); press_cal = calibration_P (pres_raw); hum_cal = kalibrēšana_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 /* 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)) {// vērtību parādīšana skaitļos aizkavē apļu mērīšanu microbit.print ("T:"); microbit.print (temp_act, 1); microbit.print ("'C"); // Serial.println (""); } cits if (! digitalRead (PIN_BUTTON_A)) {microbit.print ("P:"); microbit.print (press_act, 0); microbit.print ("hPa"); } cits {// spiediena vērtību parādīšana pikseļos vai līnijās noteiktā līmenī // 5 soļi: 1490 hPa // sliekšņi, ko nosaka max_n vērtības if (press_act> max_3) {(N = 0); // augšējā rinda} else if (press_act> max_2) {(N = 1); } cits if (press_act> max_1) {(N = 2); } cits if (press_act> max_0) {(N = 3); } cits {(N = 4); // bāzes rinda} // Sērijas.println (N); // attīstības nolūkiem // microbit.print (N); // kā līnija // microbit.drawLine (N, 0, 0, 4, LED_ON); // pārvietot vērtības uz nākamās rindas vērtību4 = vērtība3; vērtība3 = vērtība2; vērtība2 = vērtība1; vērtība1 = vērtība0; vērtība0 = N; // zīmēt attēlu, kolonnas pēc kolonnas microbit.drawPixel (0, vērtība0, LED_ON); // kā pikseļi: kolonna, rinda. 0, 0 kreisā augšējā stūra microbit.drawPixel (1, vērtība1, LED_ON); microbit.drawPixel (2, vērtība2, LED_ON); microbit.drawPixel (3, vērtība3, LED_ON); microbit.drawPixel (4, vērtība4, LED_ON); } // nosūtīt datus uz seriālo monitoru un sērijveida ploteri // Serial.println (press_act); // nosūtīt vērtību (-as) uz seriālo portu ciparu attēlošanai, pēc izvēles

Serial.print (press_act); // nosūtīt vērtību ploterim uz seriālo portu

// zīmējiet indikatoru līnijas un labojiet parādīto diapazonu Serial.print ("\ t"); Sērijas nospiedums (600); Serial.print ("\ t"); Serial.print (1100), Serial.print ("\ t"); Sērijas.println (1600); kavēšanās (200); // Mērīt trīs reizes sekundē} // ---------------------------------------- -------------------------------------------------- -------------------------------------------------- - // bmp/bme280 sensoram ir nepieciešams šāds, 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] << 8) | dati [7]; }

parakstīts garš int calibration_T (parakstīts long int adc_T)

{parakstīts garš int var1, var2, T; var1 = (((((adc_T >> 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; return T;} neparakstīts garš int kalibrēšana_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 garais int) 2097152)) * ((parakstīts garais 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);}

5. darbība: MakeCode/JavaScript skripti

Pimoroni nesen ir izlaidis vidi: bit, kas ir aprīkots ar BMP280 spiediena sensoru, gaismas/krāsu sensoru un MEMS mikrofonu. Tie piedāvā arī MicroPython un MakeCode/JavaScript bibliotēku.

Es izmantoju vēlāk, lai rakstītu MakeCode skriptu spiediena sensoram. Atbilstošo hex failu var kopēt tieši uz jūsu micro: bit. Kods tiek parādīts zemāk, un to var mainīt, izmantojot tiešsaistes MakeCode redaktoru.

Tas ir micro: bit dive-o-meter skripta variants. Pēc noklusējuma tas parāda spiediena starpību kā joslu diagrammu. Nospiežot pogu A, tiek iestatīts atsauces spiediens, nospiežot pogu B, tiek parādīta atšķirība starp faktisko un atsauces spiedienu hPa.

Papildus svītrkoda pamata versijai jūs atradīsit arī "X", krusta versiju un "L" versiju, kas atvieglo lasīšanu.

ļaujiet kolonnai = 0

ļaujiet palikt = 0 let Row = 0 let Meter = 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 ("" + Delta + "hPa") basic.pause (200) basic.clearScreen ()} else {Is = envirobit.getPressure () Delta = Is - Ref Meter = Math.abs (Delta) if (Skaitītājs> = 400) {rinda = 4} cits, ja (skaitītājs> = 300) {rinda = 3} cits, ja (skaitītājs> = 200) {rinda = 2} cits, ja (skaitītājs> = 100) {rinda = 1} cits {Rinda = 0} paliek = skaitītājs - rinda * 100, ja (paliek> = 80) {kolonna = 4} cits, ja (paliek> = 60) {kolonna = 3} cits, ja (paliek> = 40) {kolonna = 2 } else if (paliek> = 20) {Column = 1} else {Column = 0} for (let ColA = 0; ColA <= Column; ColA ++) {led.plot (ColA, Row)} basic.pause (500)}}