Ein Micro:bit Dive-O-Meter - Gunook

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

Der Sommer ist da, seine Poolzeit!

Eine gute Gelegenheit, sich und Ihr micro:bit mit nach draußen zu nehmen, und in diesem Fall sogar ins Schwimmbad.

Das hier beschriebene micro:bit Dive-O-Meter ist ein einfacher DIY-Tiefenmesser, mit dem Sie messen können, wie tief Sie getaucht sind oder waren. Es besteht nur aus einem micro:bit, einem Akkupack oder LiPo, einem Randstecker für das micro:bit, einem BMP280 oder BME280 Luftdrucksensor und einigen Überbrückungskabeln. Mit dem enviro:bit von Pimoroni wird die Sache noch einfacher. All dies ist in zwei Schichten wasserdichter, durchsichtiger Plastik- oder Silikonbeutel verpackt, mit einigen Gewichten, die die Auftriebskraft kompensieren.

Es ist eine Anwendung des Mikro: Bit-Drucksensorgeräts, das ich in einem früheren anweisbaren beschrieben hatte.

Sie können das Gerät z. g. für Tauchwettbewerbe mit Freunden und Familie oder um herauszufinden, wie tief dieser Teich wirklich ist. Ich habe es mit dem tiefsten Pool in meiner Nachbarschaft getestet und festgestellt, dass es mindestens bis zu einer Tiefe von 3,2 Metern funktioniert. Ungefähr fünf Meter ist das theoretische Maximum. Bisher habe ich die Genauigkeit nicht im Detail getestet, aber die gemeldeten Zahlen lagen zumindest im erwarteten Bereich.

Einige Anmerkungen: Dies ist kein Werkzeug für echte Taucher. Ihr micro:bit wird beschädigt, wenn es nass wird. Sie verwenden dieses instructable auf eigene Gefahr.

Update 27. Mai: Jetzt finden Sie ein MakeCode HEX-Skript, das Sie direkt in Ihr micro:bit laden können. Siehe Schritt 6. Update 13. Juni: Ein Enviro:bit und eine Kabelversion hinzugefügt. Siehe Schritte 7 & 8

Schritt 1: Die Theorie hinter dem Gerät

Wir leben auf dem Grund eines Ozeans aus Luft. Der Druck hier unten beträgt etwa 1020 hPa (HektoPascal), da das Gewicht der Luftsäule vom Weltraum hier etwa 1 kg pro Quadratzentimeter beträgt.

Die Dichte von Wasser ist viel höher, denn ein Liter Luft wiegt etwa 1,2 g und ein Liter Wasser 1 kg, also etwa das 800-fache. Da der Luftdruckabfall etwa 1 hPa pro 8 Meter Höhe beträgt, beträgt die Druckerhöhung 1 hPa pro Zentimeter unter der Wasseroberfläche. In einer Tiefe von etwa 10 m beträgt der Druck 2000 hPa oder zwei Atmosphären.

Der hier verwendete Drucksensor hat einen Messbereich zwischen 750 und 1500 hPa bei einer Auflösung von etwa einem hPa. Damit können wir Tiefen bis zu 5 Meter bei einer Auflösung von ca. 1 cm messen.

Das Gerät wäre ein Tiefenmesser vom Typ Boyle Marriotte. Die Montage ist recht einfach und wird in einem späteren Schritt beschrieben. Der Sensor verwendet das I2C-Protokoll, daher ist ein Edge-Connector für das micro:bit praktisch. Der kritischste Teil sind die wasserdichten Beutel, da jede Feuchtigkeit das micro:bit, den Sensor oder die Batterie beschädigt. Da etwas Luft in den Taschen eingeschlossen wird, hilft das Hinzufügen von Gewichten, die Auftriebskraft zu kompensieren.

Schritt 2: Verwenden des Geräts

Das Skript, das in einem späteren Schritt detailliert gezeigt wird, ist eine Variation eines Skripts, das ich zuvor für einen Druckmesser entwickelt habe. Zum Testen des Gerätes können Sie die dort beschriebene einfache Druckkammer verwenden.

Für Tauchzwecke zeigt es die aus Druckmessungen berechnete Tiefe in Metern entweder als Bargraph in 20 cm Schritten oder auf Wunsch in Zahlen an.

Mit der Taste A am micro:bit stellen Sie den aktuellen Druck als Referenzdruckwert ein. Zur Bestätigung der Eingabe blinkt die Matrix einmal.

Sie können dies entweder verwenden, um zu sehen, wie tief Sie tauchen, oder um aufzuzeichnen, wie tief Sie getaucht haben.

Stellen Sie im ersten Fall den aktuellen Außenluftdruck als Referenz ein. Im zweiten Fall stellen Sie den Druck an der tiefsten Stelle als Druckreferenz ein, die Ihnen dann anzeigt, wie tief Sie waren, wenn Sie wieder an der Oberfläche waren. Taste B zeigt die aus der Druckdifferenz berechnete Tiefe als Zahlenwert in Metern an.

Schritt 3: Benötigte Materialien

Ein micro:bit. Z. B. bei 13 GBP/16 Euro bei Pimoroni UK/DE.

Ein Kantenverbinder (Kitronic oder Pimoroni), 5 GBP. Ich habe die Kitronic-Version verwendet.

Ein BMP/BME280-Sensor. Ich habe einen BMP280 Sensor von Banggood verwendet, 4,33 Euro für drei Einheiten.

Überbrückungskabel zum Verbinden von Sensor und Randleiste.

Eine hervorragende Alternative zu der oben genannten Kantenstecker/Sensor-Kombination könnte Pimoroni enviro:bit sein (noch nicht getestet, siehe letzter Schritt).

Ein Akkupack oder LiPo für das micro:bit.

Ein Stromkabel mit Schalter (optional, aber hilfreich). Durchsichtige wasserdichte Taschen. Ich habe eine Silikontasche für ein Handy und ein oder zwei kleine Ziploc-Taschen verwendet. Achte darauf, dass das Material dick genug ist, damit die Stifte am Randverbinder die Taschen nicht beschädigen.

Einige Gewichte. Ich habe Bleistücke verwendet, die zum Angeln verwendet werden.

Arduino IDE und mehrere Bibliotheken.

Schritt 4: Montage

Installieren Sie die Arduino IDE und die erforderlichen Bibliotheken. Einzelheiten werden hier beschrieben.

(Nicht erforderlich für das MakeCode-Skript.) Wenn Sie den Kitronik-Randstecker verwenden, löten Sie die Pins an die I2C-Ports 19 & 20. Dies ist für den Pimoroni-Randstecker nicht erforderlich. Löten Sie den Header an den Sensorausbruch und verbinden Sie Sensor und Randleiste mit Überbrückungskabeln. Verbinden Sie VCC mit 3V, GND mit 0V, SCL mit Port 19 und SDA mit Port 20. Alternativ löten Sie die Kabel direkt an den Breakout. Verbinden Sie das micro:bit über ein USB-Kabel mit unserem Computer. Öffnen Sie das mitgelieferte Skript und flashen Sie es auf das micro:bit. Verwenden Sie den seriellen Monitor oder Plotter und prüfen Sie, ob der Sensor vernünftige Daten liefert. Trennen Sie das micro:bit von Ihrem Computer. Verbinden Sie den Akku oder LiPo mit dem micro:bit. Taste B drücken, Wert ablesen Taste A drücken. Taste B drücken, Wert ablesen. Legen Sie das Gerät in zwei Lagen luftdichter Beutel und lassen Sie nur sehr wenig Luft in den Beuteln. Platzieren Sie gegebenenfalls ein Gewicht, um die Auftriebskraft auszugleichen. Prüfen Sie, ob alles wasserdicht ist. Geh zum Pool und spiele.

Schritt 5: Das MicroPython-Skript

Das Skript nimmt einfach den Druckwert vom Sensor, vergleicht ihn mit dem Referenzwert und berechnet dann die Tiefe aus der Differenz. Für die Anzeige der Werte als Balkendiagramm werden der ganzzahlige und restliche Teil des Tiefenwertes verwendet. Die erste definiert die Höhe der Linie. Der Rest wird in fünf Fächer unterteilt, die die Länge der Balken definieren. Die oberste Ebene beträgt 0 - 1 m, die unterste 4 - 5 m. Wie bereits erwähnt, wird durch Drücken von Taste A der Referenzdruck eingestellt, Taste B zeigt die "relative Tiefe" in Metern als Zahlenwert an. Negative und positive Werte werden jetzt auf die gleiche Weise als Bargraph auf der LED-Matrix dargestellt. Optimieren Sie das Skript gerne für Ihre Bedürfnisse. Sie können die Stummschaltung bestimmter Zeilen aufheben, um die Werte auf dem seriellen Monitor oder Plotter der Arduino IDE anzuzeigen. Um die Funktion zu emulieren, können Sie das Gerät bauen, das ich in einem vorherigen instructable beschrieben habe.

Ich habe den Teil des Skripts nicht geschrieben, der den Sensor liest. Ich bin mir der Quelle nicht sicher, aber ich möchte den Autoren danken. Korrekturen oder Hinweise zur Optimierung sind willkommen.

#enthalten

#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; doppelte press_norm = 1015; // ein Startwert doppelte Tiefe; // berechnete Tiefe //-------------------------------------------------------- -------------------------------------------------- ---------------------- 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); // Geschwindigkeit der seriellen Schnittstelle einstellen Serial.print ("Druck [hPa]"); // Header für serielle Ausgabe 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; int M; doppeltes press_delta; // relativer Druck int Tiefe_m; // Tiefe in Metern, ganzzahliger Teil double Depth_cm; // Rest in cm readData(); // temp_cal = Calibration_T (temp_raw); press_cal = Kalibrierung_P(pres_raw); // hum_cal = Calibration_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 // Taste A setzt Istwert als Referenz (P null) // Taste B zeigt den aktuellen Wert als Tiefe in Metern an (aus der Druckdifferenz berechnet) if (! digitalRead (PIN_BUTTON_A)) { // Normalen Luftdruck einstellen als Null press_norm = press_act; // microbit.print("P0:"); // microbit.print (press_norm, 0); // microbit.print("hPa"); microbit.fillScreen(LED_ON); // einmal blinken, um die Verzögerung zu bestätigen (100); } Sonst if (! digitalRead (PIN_BUTTON_B)) {// Anzeigetiefe in Metern microbit.print (Tiefe, 2); microbit.print("m"); // Serial.println(""); }sonst{ // Tiefe aus Druckdifferenz berechnen press_delta = (press_act - press_norm); // relative Drucktiefe berechnen = (press_delta/100); // Tiefe in Metern Tiefe_m = int(abs(Tiefe)); // Tiefe im Meter Tiefe_cm = (abs (Tiefe) - Tiefe_m); // Rest /* // für die Entwicklung verwendet Serial.println (Tiefe); Serial.println (Tiefe_m); Serial.println (Tiefe_cm); */ // Schritte für Balkendiagramm if (depth_cm> 0.8) { // Länge der Balken einstellen (N = 4); aufrechtzuerhalten. Sonst wenn (Tiefe_cm > 0,6) { (N = 3); aufrechtzuerhalten. Sonst wenn (Tiefe_cm > 0,4) { (N = 2); aufrechtzuerhalten. Sonst wenn (Tiefe_cm > 0,2) { (N = 1); } sonst { (N = 0); }

if (depth_m == 4) {// Level einstellen == meter

(M=4); aufrechtzuerhalten. Sonst wenn (Tiefe_m == 3) { (M = 3); aufrechtzuerhalten. Sonst wenn (Tiefe_m == 2) { (M = 2); aufrechtzuerhalten. Sonst wenn (Tiefe_m == 1) {(M=1); } sonst { (M = 0); // obere Reihe} /* // für Entwicklungszwecke verwendet Serial.print ("m: "); Serial.println (Tiefe_m); Serial.print("cm:"); Serial.println (Tiefe_cm); Serial.print("M:"); Serial.println (M); // für Entwicklungszwecke Serial.print("N:"); Serial.println (N); // für Entwicklungszwecke delay(500); */ // Balkendiagramm zeichnen microbit.drawLine (0, M, N, M, LED_ON); }

// Wert an serielle Schnittstelle für Plotter senden

Serial.print (press_delta); // Indikatorlinien zeichnen und angezeigten Bereich fixieren Serial.print ("\t"); Seriendruck (0); Serial.print("\t"); Seriendruck (-500); Serial.print("\t"); Serial.println (500); Verzögerung (500); // Zweimal pro Sekunde messen } //----------------------------------------------------- -------------------------------------------------- -------------------------------------------------- -------- // 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(); aufrechtzuerhalten. 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 = (data[6] 3) - ((signed long int)dig_T1 11; var2 = (((((adc_T >> 4) - ((signed long int)dig_T1)) * ((adc_T>>4) - ((Vorzeichen lange Ganzzahl)dig_T1))) >> 12) * ((Vorzeichen lange Ganzzahl)dig_T3)) >> 14; t_fine = var1 + var2; T = (t_fine * 5 + 128) >> 8; Rückgabe T; aufrechtzuerhalten. ((var1>>2) * (var1>>2)) >> 11) * ((signed long int)dig_P6); var2 = var2 + ((var1*((signed long int)dig_P5))2)+(((Vorzeichen lange Ganzzahl)dig_P4)2)*(var1>>2)) >> 13)) >>3) + ((((Vorzeichen lange Ganzzahl)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 6: Eine wesentliche Vereinfachung: der MakeCode/JavaScript-Code

Im Mai 2018 hat Pimoroni das enviro:bit veröffentlicht, das mit einem BME280 Druck-/Feuchte-/Temperatursensor, einem TCS3472 Licht- und Farbsensor und einem MEMS-Mikrofon ausgestattet ist. Darüber hinaus bieten sie eine JavaScript-Bibliothek für den MakeCode-Editor und eine MicroPython-Bibliothek für diese Sensoren an.

Ich habe ihre MakeCode-Bibliothek verwendet, um Skripte für mein Gerät zu entwickeln. Im Anhang finden Sie die entsprechenden Hex-Dateien, die Sie direkt auf Ihr micro:bit kopieren können.

Unten finden Sie den entsprechenden JavaScript-Code. Das Testen im Pool hat mit einer früheren Version des Skripts gut funktioniert, daher gehe ich davon aus, dass sie auch funktionieren werden. Neben der Basis-Bargraph-Version gibt es auch eine Fadenkreuz-Version (X) und eine L-Version, die das Ablesen insbesondere bei schlechten Lichtverhältnissen erleichtern sollen. Wählen Sie diejenige aus, die Sie bevorzugen.

let Spalte = 0

lass Meter = 0 lass bleiben = 0 lass Row = 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("" + Row + "." + stay + "m") 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) { Spalte = 2 } else if (rest >= 20) { Spalte = 1 } else { Spalte = 0 } for (let ColA = 0; ColA <= Column; ColA++) { led.plot(C olA, Zeile) } basic.pause(500) } })

Schritt 7: Die Enviro:bit-Version

Inzwischen habe ich von Pimoroni das enviro:bit (20 GBP) und das power:bit (6 GBP) erhalten.

Wie bereits erwähnt, kommt das enviro:bit mit dem BME280 Druck-, Feuchte- und Temperatursensor, aber auch einem Licht- und Farbsensor (siehe Anwendung hier) und einem MEMS-Mikrofon.

Das power:bit ist eine schöne Lösung, um das micro:bit mit Strom zu versorgen und wird mit einem Ein- / Ausschalter geliefert.

Das Tolle ist, dass beides einfach zu klicken und zu verwenden ist, kein Löten, keine Kabel, Steckbretter. Fügen Sie das enviro:bit zum micro:bit hinzu, laden Sie Ihren Code in das micro:bit, verwenden Sie es.

In diesem Fall habe ich micro, power und enviro:bit verwendet, sie in eine Ziploc-Tasche gelegt, in eine klare wasserdichte Plastiktüte für Mobiltelefone gelegt, fertig. Eine sehr schnelle und saubere Lösung. Siehe die Bilder. Der Switch ist groß genug, um ihn durch die Schutzschichten hindurch zu verwenden.

Es wurde in Wasser getestet, hat gut funktioniert. In einer Tiefe von ca. 1,8 m lag der Messwert bei ca. 1,7 m. Nicht schlecht für eine schnelle & günstige Lösung, aber bei weitem nicht perfekt. Die Anpassung dauert eine Weile, daher müssen Sie möglicherweise etwa 10-15 Sekunden in einer bestimmten Tiefe bleiben.

Schritt 8: Kabel- und Sensorsondenversion

Dies war eigentlich die erste Idee für ein micro:bit Depth Meter, das letzte, das gebaut wurde.

Hier habe ich den BMP280 Sensor an 5m eines 4-adrigen Kabels angelötet und am anderen Ende eine Steckbrücke gesteckt. Um den Sensor vor Wasser zu schützen, wurde das Kabel durch einen gebrauchten Weinkorken geführt. Die Enden des Korkens wurden mit Heißkleber versiegelt. Vorher hatte ich zwei Kerben in den Kork geschnitten, die beide rundherum gingen. Dann habe ich den Sensor in eine Schwammkugel gepackt, einen Ballon darum gelegt und das Ende des Ballons am Korken befestigt (untere Kerbe). Dann legte ich 3 Stück 40 g Bleigewichte in einen zweiten Ballon, wickelte ihn um den ersten, legte Gewichte an die Außenseite und befestigte das Ende des Ballons an der zweiten Kerbe. Die Luft wurde aus dem zweiten Ballon entfernt, dann wurde alles mit Klebeband fixiert. Siehe Bilder, detailliertere können folgen.

Über eine Steckleiste wurden die Jumper mit dem micro:bit verbunden, das Gerät eingeschaltet und der Referenzdruck eingestellt. Dann wurde der Sensorkopf langsam auf den Beckenboden losgelassen (10 m Sprungturm, ca. 4,5 m tief).

Ergebnisse:

Zu meinem Erstaunen hat es sogar mit diesem langen Kabel funktioniert. Andererseits, aber nicht überraschend, schien der Messfehler bei höheren Drücken größer zu werden, und eine geschätzte Tiefe von 4 m wurde mit etwa 3 m angegeben.

Anwendungsmöglichkeiten:

Mit einigen Fehlerkorrekturen kann das Gerät zur Tiefenmessung bis etwa 4 m verwendet werden.

In Verbindung mit einem Arduino oder Raspberry Pi könnte damit der Füllpunkt eines Pools oder Wassertanks gemessen und kontrolliert werden, z. um eine Warnung hervorzurufen, wenn der Wasserstand bestimmte Schwellenwerte über- oder unterschreitet.

Zweiter Platz bei der Outdoor-Fitness-Challenge