Messen Sie den Druck mit Ihrem Micro:bit - Gunook

2024 Autor: John Day | [email protected]. Zuletzt bearbeitet: 2024-01-30 07:20

Die folgende Anleitung beschreibt ein einfach zu bauendes und kostengünstiges Gerät zur Durchführung von Druckmessungen und zur Demonstration des Boyle-Gesetzes unter Verwendung des micro:bit in Kombination mit dem BMP280 Druck- / Temperatursensor.

Während diese Kombination aus Spritze / Drucksensor bereits in einem meiner vorherigen Instructables beschrieben wurde, bietet die Kombination mit dem micro:bit neue Möglichkeiten, z. für Klassenzimmerprojekte.

Darüber hinaus ist die Anzahl der Beschreibungen von Anwendungen, in denen das micro:bit in Kombination mit einem I2C-getriebenen Sensor verwendet wird, bisher eher begrenzt. Ich hoffe, dass dieses instructable ein Ausgangspunkt für andere Projekte sein könnte.

Das Gerät ermöglicht es, quantitative Luftdruckmessungen durchzuführen und die Ergebnisse auf dem micro:bit-LED-Array oder auf einem angeschlossenen Computer anzuzeigen, um später die seriellen Monitor- oder seriellen Plotterfunktionen der Arduino IDE zu verwenden. Außerdem haben Sie ein haptisches Feedback, da Sie den Kolben der Spritze selbst drücken oder ziehen und dabei die nötige Kraft spüren.

Standardmäßig ermöglicht Ihnen das Display, den Druck anhand der auf der LED-Matrix angezeigten Füllstandsanzeige abzuschätzen. Der serielle Plotter der Arduino IDE ermöglicht das gleiche, jedoch mit viel besserer Auflösung (siehe Video). Auch aufwändigere Lösungen sind verfügbar, z. B. in der Verarbeitungssprache. Sie können die genauen Messwerte von Druck und Temperatur auch auf der LED-Matrix anzeigen, nachdem Sie die A- bzw. B-Taste gedrückt haben, aber der serielle Monitor der Arduino IDE ist viel schneller und ermöglicht die Anzeige von Werten nahezu in Echtzeit.

Die Gesamtkosten und die technischen Fähigkeiten, die zum Bau des Geräts erforderlich sind, sind eher gering, so dass es ein schönes Klassenzimmerprojekt unter Aufsicht eines Lehrers sein könnte. Darüber hinaus könnte das Gerät ein Werkzeug für MINT-Projekte mit Schwerpunkt Physik sein oder in anderen Projekten verwendet werden, bei denen eine Kraft oder ein Gewicht in einen digitalen Wert umgewandelt werden soll.

Das Prinzip wurde verwendet, um ein sehr einfaches micro:bit Dive-O-Meter zu konstruieren, ein Gerät, um zu messen, wie tief man taucht.

Nachtrag 27. Mai 2018:

Da Pimoroni eine MakeCode-Bibliothek für den BMP280-Sensor entwickelt hat, hatte ich die Möglichkeit, ein Skript für das hier beschriebene Gerät zu entwickeln. Das Skript und die entsprechende HEX-Datei finden Sie im letzten Schritt dieser Anleitung. Um es zu verwenden, laden Sie einfach die HEX-Datei in Ihr micro:bit. Es ist keine spezielle Software erforderlich, und Sie können den Online-Editor MakeCode zum Bearbeiten des Skripts verwenden.

Schritt 1: Verwendete Materialien

• Ein micro:bit, habe meins von Pimoroni bekommen - 13,50 GBP
• Kitronic Edge Connector für micro:bit - via Pimoroni - 5 GBP, Hinweis: Pimorini bietet jetzt einen Steckbrett-freundlichen Edge Connector namens pin:bit mit Pins an den I2C-Ports an.
• 2 x 2 Stiftleisten
• Akku oder LiPo für das micro:bit (nicht notwendig, aber hilfreich), Akkukabel mit Schalter (dito) - Pimoroni
• Überbrückungskabel zum Anschluss von Sensoren an Edge Connector
• lange (!) Starthilfekabel für den Sensor, mindestens so lang wie die Spritze,, f/f oder f/m
• BMP280 Druck- und Temperatursensor - Banggood - 5 US$ für drei EinheitenDer Messbereich für diesen Sensor liegt zwischen 550 und 1537 hPa.
• 150 ml Kunststoff-Katheterspritze mit Gummidichtung - Amazon oder Baumärkte und Gartenläden - ca. 2 - 3 US$
• Heißkleber/Heißkleberpistole
• Lötkolben
• ein Computer mit installierter Arduino IDE

Schritt 2: Montageanleitung

Lötstifte an den BMP280-Sensor-Breakout anlöten.

Löten Sie die beiden 2-poligen Stiftleisten an die Anschlüsse Pin 19 und Pin 20 des Edge Connectors (siehe Bild).

Verbinden Sie das micro:bit mit dem Edge-Anschluss und Ihrem Computer.

Bereiten Sie Software und micro:bit wie in der Adafruit micro:bit-Anleitung beschrieben vor. Lesen Sie sie gründlich durch.

Installieren Sie die erforderlichen Bibliotheken in der Arduino IDE.

Öffnen Sie das in einem späteren Schritt angehängte BMP280-Skript.

Verbinden Sie den Sensor mit dem Edge-Anschluss. GND auf 0V, VCC auf 3V, SCL auf Pin 19, SDA auf Pin 20.

Laden Sie das Skript in das micro:bit hoch.

Prüfen Sie, ob der Sensor vernünftige Daten liefert. Die Druckwerte sollten bei etwa 1020 hPa liegen und auf dem seriellen Monitor angezeigt werden. Überprüfen Sie in diesem Fall zuerst die Kabel und Verbindungen, dann die Softwareinstallation und korrigieren Sie sie.

micro:bit ausschalten, Sensor entfernen.

Führen Sie die langen Starthilfekabel durch den Auslass der Spritze. Eventuell müssen Sie die Öffnung erweitern. Achten Sie darauf, dass die Kabel nicht beschädigt werden.

Verbinden Sie den Sensor mit den Überbrückungskabeln. Überprüfen Sie, ob die Verbindungen richtig und gut sind. Verbinden Sie sich mit dem micro:bit.

Überprüfen Sie, ob der Sensor richtig funktioniert. Ziehen Sie vorsichtig an den Kabeln und bewegen Sie den Sensor an die Spitze der Spritze.

Kolben einsetzen und etwas weiter als die gewünschte Ruheposition (100 ml) bewegen.

Fügen Sie am Ende des Spritzenauslasses Heißkleber hinzu und bewegen Sie den Kolben etwas zurück. Überprüfen Sie, ob die Spritze luftdicht verschlossen ist, andernfalls fügen Sie mehr Heißkleber hinzu. Lassen Sie den Heißkleber abkühlen.

Überprüfen Sie erneut, ob der Sensor funktioniert. Wenn Sie den Kolben bewegen, sollten sich die Zahlen im seriellen Monitor und die Anzeige des micro:bit ändern.

Falls erforderlich, können Sie das Volumen der Spritze anpassen, indem Sie sie in der Nähe der Dichtung zusammendrücken und den Kolben bewegen.

Schritt 3: Ein bisschen Theorie und einige praktische Messungen

Mit dem hier beschriebenen Gerät können Sie den Zusammenhang von Kompression und Druck in einfachen physikalischen Experimenten demonstrieren. Da die Spritze mit einer "ml"-Skala versehen ist, sind selbst quantitative Experimente einfach durchzuführen.

Die Theorie dahinter: Nach dem Gesetz von Boyle ist [Volumen * Pressure] ein konstanter Wert für ein Gas bei einer bestimmten Temperatur.

Das bedeutet, wenn Sie ein gegebenes Gasvolumen N-fach komprimieren, d. h. das Endvolumen ist 1/N-fach des Originalvolumens, steigt sein Druck N-fach, als: P0*V0=P1*V1= cons t. Weitere Informationen finden Sie im Wikipedia-Artikel zu Gasgesetzen. Auf Meereshöhe liegt der Luftdruck normalerweise im Bereich von 1010 hPa (Hektopascal).

Also ausgehend von einem Rastpunkt von z. B. V0=100 ml und P0=1000 hPa ergibt eine Kompression der Luft auf ca. 66 ml (d.h. V1 = 2/3 * V0) einen Druck von ca. 1500 hPa (P1= 3/2 von P0). Durch Ziehen des Kolbens auf 125 ml (5/4-faches Volumen) entsteht ein Druck von ca. 800 hPa (4/5 Druck). Die Messungen sind für ein so einfaches Gerät erstaunlich genau.

Das Gerät ermöglicht Ihnen einen direkten haptischen Eindruck, wie viel Kraft erforderlich ist, um die relativ geringe Luftmenge in der Spritze zu komprimieren oder zu expandieren.

Wir können aber auch einige Berechnungen durchführen und experimentell überprüfen. Angenommen, wir komprimieren die Luft auf 1500 hPa, bei einem basalen Luftdruck von 1000 hPa. Die Druckdifferenz beträgt also 500 hPa oder 50.000 Pa. Für meine Spritze beträgt der Durchmesser (d) des Kolbens etwa 4 cm oder 0,04 Meter.

Jetzt können Sie die Kraft berechnen, die erforderlich ist, um den Kolben in dieser Position zu halten. Gegeben P = F/A (Druck ist Kraft geteilt durch Fläche) oder transformiert F = P*A. Die SI-Einheit für Kraft ist "Newton" N, für Länge "Meter" m und 1 Pa ist 1 N pro Quadratmeter. Für einen runden Kolben kann die Fläche mit A = ((d/2)^2)*pi berechnet werden, was 0,00125 Quadratmeter für meine Spritze ergibt. So

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

Auf der Erde entspricht 1 N einem Gewicht von 100 g, also 63 N entsprechen einem Gewicht von 6,3 kg.

Dies lässt sich leicht mit einer Waage überprüfen. Drücken Sie die Spritze mit dem Kolben auf die Skala, bis ein Druck von ca. 1500 hPa erreicht ist, dann lesen Sie die Skala ab. Oder drücken Sie, bis die Waage ca. 6-7 kg anzeigt, drücken Sie dann die "A"-Taste und lesen Sie den auf der LED-Matrix des micro:bit angezeigten Wert ab. Wie sich herausstellte, war die auf den obigen Berechnungen basierende Schätzung nicht schlecht. Ein Druck knapp über 1500 hPa korrelierte mit einem angezeigten „Gewicht“von ca. 7 kg auf einer Körperwaage (siehe Bilder). Sie könnten dieses Konzept auch umdrehen und das Gerät verwenden, um eine einfache digitale Waage basierend auf Druckmessungen zu bauen.

Bitte beachten Sie, dass die Obergrenze für den Sensor bei ca. 1540 hPa liegt, so dass ein darüber liegender Druck nicht gemessen werden kann und den Sensor beschädigen kann.

Neben pädagogischen Zwecken kann das System auch für einige reale Anwendungen verwendet werden, da es die quantitative Messung von Kräften ermöglicht, die versuchen, den Kolben in die eine oder andere Richtung zu bewegen. So können Sie beispielsweise ein auf den Kolben aufgebrachtes Gewicht oder eine auf den Kolben auftreffende Schlagkraft messen. Oder bauen Sie einen Schalter, der ein Licht oder einen Summer aktiviert oder einen Ton abspielt, nachdem ein bestimmter Schwellenwert erreicht wurde. Oder Sie könnten ein Musikinstrument bauen, das die Frequenz abhängig von der Stärke der auf den Kolben ausgeübten Kraft ändert. Oder verwenden Sie es als Gamecontroller. Verwenden Sie Ihre Fantasie und spielen Sie!

Schritt 4: Das MicroPython-Skript

Anbei finden Sie mein BMP280-Skript für das micro:bit. Es ist ein Derivat eines BMP/BME280-Skripts, das ich irgendwo auf der Banggood-Website gefunden habe, kombiniert mit der Microbit-Bibliothek von Adafruit. Ersteres ermöglicht die Nutzung des Banggood-Sensors, zweiteres vereinfacht die Handhabung des 5x5-LED-Displays. Mein Dank geht an die Entwickler von beiden.

Standardmäßig zeigt das Skript die Ergebnisse von Druckmessungen in 5 Schritten auf dem 5x5-LED-Display des micro:bit an, sodass Änderungen mit geringer Verzögerung sichtbar sind. Die genauen Werte können parallel auf dem seriellen Monitor der Arduino IDE angezeigt werden, oder eine detailliertere Grafik kann auf dem seriellen Plotter der Arduino IDE angezeigt werden.

Wenn Sie die A-Taste drücken, werden die gemessenen Druckwerte auf dem 5x5 LED-Array des micro:bit angezeigt. Wenn Sie die Taste B drücken, werden die Temperaturwerte angezeigt. Dies ermöglicht zwar das genaue Auslesen der Daten, verlangsamt aber die Messzyklen deutlich.

Ich bin mir sicher, dass es wesentlich elegantere Möglichkeiten gibt, die Aufgaben zu programmieren und das Skript zu verbessern. Jede Hilfe ist willkommen.

#einschließen xxx

#include Adafruit_Microbit_Matrix-Mikrobit; #define BME280_ADDRESS 0x76 unsigned long int hum_raw, temp_raw, pres_raw; signiert 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; // Container für Messwerte int value0; int-Wert1; int-Wert2; int-Wert3; int-Wert4; //------------------------------------------------ -------------------------------------------------- ------------------ Void setup () {uint8_t osrs_t = 1; // Temperaturüberabtastung x 1 uint8_t osrs_p = 1; //Drucküberabtastung x 1 uint8_t osrs_h = 1; // Feuchtigkeitsüberabtastung x 1 uint8_t mode = 3; //Normaler Modus uint8_t t_sb = 5; // Tstandby 1000ms uint8_t Filter = 0; //Filter aus uint8_t spi3w_en = 0; //3-Draht-SPI Deaktivieren uint8_t ctrl_meas_reg = (osrs_t << 5) | (osrs_p << 2) | Modus; uint8_t config_reg = (t_sb << 5) | (Filter << 2) | spi3w_en; uint8_t ctrl_hum_reg = osrs_h; pinMode (PIN_BUTTON_A, EINGANG); pinMode (PIN_BUTTON_B, EINGANG); Serial.begin (9600); // Serial.println ("Temperatur [Grad C]"); // Serial.print("\t"); Serial.print ("Druck [hPa]"); // Kopfzeile Wire.begin(); writeReg(0xF2, ctrl_hum_reg); writeReg(0xF4, ctrl_meas_reg); writeReg(0xF5, config_reg); readTrim(); // microbit.begin(); // microbit.print("x"); Verzögerung (1000); } //----------------------------------------------------------- -------------------------------------------------- -------- void loop() { double temp_act = 0.0, press_act = 0.0, hum_act=0.0; signiert long int temp_cal; unsigned long int press_cal, hum_cal; int N; // Schwellenwerte für LED-Matrix-Anzeige einstellen, in hPa double max_0 = 1100; doppeltes max_1 = 1230; doppeltes max_2 = 1360; doppeltes max_3 = 1490; readData(); temp_cal = Kalibrierung_T(temp_raw); press_cal = Kalibrierung_P(pres_raw); hum_cal = Kalibrierung_H(hum_raw); temp_act = (double)temp_cal / 100.0; press_act = (doppelt)press_cal / 100.0; hum_act = (double)hum_cal / 1024.0; microbit.clear(); // LED-Matrix zurücksetzen / * 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)) {// Anzeige von Werten in Zahlen verzögert das Messen von Kreisen microbit.print("T:"); microbit.print (temp_act, 1); microbit.print(" 'C"); // Serial.println(""); } Sonst wenn (! digitalRead (PIN_BUTTON_A)) { microbit.print ("P: "); microbit.print (press_act, 0); microbit.print("hPa"); }else{ // Druckwerte als Pixel oder Linien in einem bestimmten Level anzeigen // 5 Schritte: 1490 hPa // Schwellenwerte definiert durch die max_n-Werte if (press_act > max_3){ (N=0); // obere Reihe} else if (press_act > max_2) { (N=1); } else if (press_act > max_1){ (N=2); } sonst if (press_act > max_0) { (N = 3); } sonst { (N = 4); // Basiszeile} // Serial.println (N); // für Entwicklungszwecke // microbit.print(N); // als Linie // microbit.drawLine(N, 0, 0, 4, LED_ON); // Werte in die nächste Zeile verschieben value4 = value3; Wert3 = Wert2; Wert2 = Wert1; Wert1 = Wert0; Wert0 = N; // Bild spaltenweise zeichnen microbit.drawPixel(0, value0, LED_ON); // als Pixel: Spalte, Zeile. 0, 0 linke obere Ecke microbit.drawPixel(1, value1, LED_ON); microbit.drawPixel(2, Wert2, LED_ON); microbit.drawPixel(3, Wert3, LED_ON); microbit.drawPixel(4, Wert4, LED_ON); } // Daten an seriellen Monitor und seriellen Plotter senden // Serial.println (press_act); // Wert(e) an serielle Schnittstelle für numerische Anzeige senden, optional

Serial.print (press_act); // Wert an serielle Schnittstelle für Plotter senden

// Indikatorlinien zeichnen und angezeigten Bereich fixieren Serial.print ("\t"); Seriendruck (600); Serial.print("\t"); Serial.print(1100), Serial.print("\t"); Serial.println(1600); Verzögerung (200); // Messen Sie dreimal pro Sekunde } //---------------------------------------------------- -------------------------------------------------- -------------------------------------------------- -- // Folgendes ist für den bmp / bme280-Sensor erforderlich, so wie es ist void 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); // 2014/Wire.write (0xA1) hinzufügen; // 2014/Wire.endTransmission () hinzufügen; // 2014/Wire.requestFrom(BME280_ADDRESS, 1) hinzufügen; // 2014/data hinzufügen = Wire.read(); // 2014/i++ hinzufügen; // 2014/Wire.beginTransmission(BME280_ADDRESS) hinzufügen; Wire.write(0xE1); Wire.endTransmission(); Wire.requestFrom(BME280_ADDRESS, 7); // Fix 2014/while(Wire.available()){ data = Wire.read(); i++; } dig_T1 = (Daten[1] << 8) | Daten[0]; dig_P1 = (Daten[7] << 8) | Daten[6]; dig_P2 = (Daten[9] << 8) | Daten[8]; dig_P3 = (Daten[11]<< 8) | Daten[10]; dig_P4 = (Daten[13]<< 8) | Daten[12]; dig_P5 = (Daten[15]<< 8) | Daten[14]; dig_P6 = (Daten[17]<< 8) | Daten[16]; dig_P7 = (Daten[19]<< 8) | Daten[18]; dig_T2 = (Daten[3] << 8) | Daten[2]; dig_T3 = (Daten[5] << 8) | Daten[4]; dig_P8 = (Daten[21]<< 8) | Daten[20]; dig_P9 = (Daten[23]<< 8) | Daten[22]; dig_H1 = Daten[24]; dig_H2 = (Daten[26]<< 8) | Daten[25]; dig_H3 = Daten[27]; dig_H4 = (Daten[28]<< 4) | (0x0F & Daten[29]); dig_H5 = (Daten[30] 4) & 0x0F); // Fix 2014/dig_H6 = data[31]; // Fix 2014/} void writeReg(uint8_t reg_address, uint8_t data) { Wire.beginTransmission(BME280_ADDRESS); Wire.write (reg_address); Wire.write (Daten); Wire.endTransmission(); }

void readData()

{int i = 0; uint32_t-Daten[8]; Wire.beginTransmission(BME280_ADDRESS); Wire.write(0xF7); Wire.endTransmission(); Wire.requestFrom(BME280_ADDRESS, 8); while(Wire.available()){data = Wire.read(); i++; } pres_raw = (data[0] << 12) | (Daten[1] 4); temp_raw = (Daten[3] << 12) | (Daten[4] 4); hum_raw = (Daten[6] << 8) | Daten[7]; }

vorzeichenbehaftete lange int-Kalibrierung_T(vorzeichenbehaftete lange int-adc_T)

{ Vorzeichen lang int var1, var2, T; var1 = ((((adc_T >> 3) - ((signed long int)dig_T1 11; var2 = (((((adc_T >> 4) - ((signed long int)dig_T1)) * ((adc_T>>4) - ((signed long int)dig_T1))) >> 12) * ((signed long int)dig_T3)) >> 14; t_fine = var1 + var2; T = (t_fine * 5 + 128) >> 8; return T; } unsigned long int Calibration_P(signed long int adc_P) { signed long int var1, var2; unsigned long int P; var1 = (((signed long int)t_fine)>>1) - (signed long int)64000; var2 = (((var1>>2) * (var1>>2)) >> 11) * ((signed long int)dig_P6); var2 = var2 + ((var1*((signed long int)dig_P5))2) +(((signed long int)dig_P4)2)*(var1>>2)) >> 13)) >>3) + ((((signed long int)dig_P2) * var1)>>1))>> 18; var1 = ((((32768+var1))*((Vorzeichen lange Ganzzahl)dig_P1))>>15); wenn (var1 == 0) { 0 zurückgeben; } P = (((unsigned long int)(((signed long int)1048576)-adc_P)-(var2>>12)))*3125; if(P<0x80000000) { P = (P <<1) / ((unsigned long int) var1); aufrechtzuerhalten. Else { P = (P / (unsigned long int) var1) * 2; } var1 = (((Vorzeichen lange Ganzzahl)dig_P9) * ((Vorzeichen lange Ganzzahl)(((P>>3) * (P>>3))>>13)))>>12; var2 = (((Vorzeichen lange Ganzzahl)(P>>2)) * ((Vorzeichen lange Ganzzahl)dig_P8))>>13; P = (unsigned long int)((signed long int)P + ((var1 + var2 + dig_P7) >> 4)); P zurückgeben; aufrechtzuerhalten. Unsigned long int Calibration_H (signed long int adc_H) {signed long int v_x1; v_x1 = (t_fine - ((signed long int)76800)); v_x1 = (((((adc_H << 14) -(((Vorzeichen lange Ganzzahl)dig_H4) 15) * (((((((v_x1 * ((Vorzeichen lange Ganzzahl)dig_H6))) >> 10) * (((v_x1 * ((signed long int)dig_H3)) >> 11) + ((signed long int) 32768))) >> 10) + ((signed long int)2097152)) * ((signed long int) dig_H2) + 8192) >> 14)); v_x1 = (v_x1 - (((((v_x1 >> 15) * (v_x1 >> 15)) >> 7) * ((signed long int)dig_H1)) >> 4)); v_x1 = (v_x1 419430400 ? 419430400: v_x1); return (unsigned long int)(v_x1 >> 12); }

Schritt 5: MakeCode/JavaScript-Skripte

Pimoroni hat kürzlich das enviro:bit herausgebracht, das mit einem BMP280-Drucksensor, einem Licht-/Farbsensor und einem MEMS-Mikrofon ausgestattet ist. Sie bieten auch eine MicroPython- und eine MakeCode/JavaScript-Bibliothek.

Später habe ich ein MakeCode-Skript für den Drucksensor geschrieben. Die entsprechende Hex-Datei kann direkt auf Ihr micro:bit kopiert werden. Der Code wird unten angezeigt und kann mit dem Online-Editor MakeCode geändert werden.

Es ist eine Variation des Skripts für das micro:bit Dive-O-Meter. Standardmäßig wird die Druckdifferenz als Balkendiagramm angezeigt. Durch Drücken der Taste A wird der Referenzdruck eingestellt, durch Drücken der Taste B wird die Differenz zwischen Ist- und Referenzdruck in hPa angezeigt.

Neben der Basis-Barcode-Version finden Sie auch eine "X", eine Fadenkreuz-Version und eine "L"-Version, die das Lesen erleichtern sollen.

let Spalte = 0

lass bleiben = 0 lass Row = 0 lass Meter = 0 lass Delta = 0 lass Ref = 0 lass 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) { Row = 4 } else if (Meter >= 300) { Row = 3 } else if (Meter >= 200) { Row = 2 } else if (Meter >= 100) { Row = 1 } else { Row = 0 } stay = Meter - Row * 100 if (remain >= 80) { Column = 4 } else if (remain >= 60) { Column = 3 } else if (remain >= 40) { Column = 2 } else if (rest >= 20) { Column = 1 } else { Column = 0 } for (let ColA = 0; ColA <= Column; ColA++) {led.plot(ColA, Row) } basic.pause(500) } })