Een Micro:bit Dive-O-Meter - Ajarnpa

2024 Auteur: John Day | [email protected]. Laatst gewijzigd: 2024-01-30 11:18

De zomer is hier, het is tijd voor het zwembad!

Een mooie gelegenheid om jezelf en je micro:bit mee naar buiten te nemen, en in dit geval zelfs in het zwembad.

De micro:bit duik-o-meter die hier wordt beschreven, is een eenvoudige doe-het-zelf dieptemeter waarmee je kunt meten hoe diep je duikt of was. Het bestaat alleen uit een micro:bit, een batterijpakket of LiPo, een randconnector voor de micro:bit, een BMP280 of BME280 luchtdruksensor en enkele startkabels. Het gebruik van de Pimoroni enviro:bit maakt het steeds eenvoudiger. Dit alles is verpakt in twee lagen waterdichte doorzichtige plastic of siliconen zakken, met enkele gewichten toegevoegd om de opwaartse kracht te compenseren.

Het is een toepassing van het micro:bit-druksensorapparaat dat ik in een eerdere instructable had beschreven.

U kunt het apparaat gebruiken e. G. voor duikwedstrijden met vrienden en familie, of om erachter te komen hoe diep die vijver werkelijk is. Ik heb het getest met behulp van het diepste zwembad in mijn buurt en ontdekte dat het op zijn minst tot een diepte van 3,2 meter werkt. Ongeveer vijf meter is het theoretische maximum. Tot nu toe heb ik de nauwkeurigheid ervan niet in detail getest, maar de gerapporteerde cijfers lagen in ieder geval in het verwachte bereik.

Enkele opmerkingen: Dit is niet bedoeld als hulpmiddel voor echte duikers. Je micro:bit raakt beschadigd als deze nat wordt. U gebruikt deze instructable op eigen risico.

Update 27 mei: Nu kun je een MakeCode HEX-script vinden dat je direct in je micro:bit kunt laden. Zie stap 6. Update 13 juni: Een Enviro:bit en een kabelversie toegevoegd. Zie stappen 7 & 8

Stap 1: De theorie achter het apparaat

We leven op de bodem van een oceaan van lucht. De druk hier beneden is ongeveer 1020 hPa (hectoPascal) aangezien het gewicht van de luchtkolom hier naar de ruimte ongeveer 1 kg per vierkante centimeter is.

De dichtheid van water is veel hoger, aangezien een liter lucht ongeveer 1,2 g weegt en een liter water 1 kg, d.w.z. ongeveer het 800-voudige. Dus aangezien de daling van de barometrische druk ongeveer 1 hPa is voor elke 8 meter hoogte, is de druktoename 1 hPa voor elke centimeter onder het wateroppervlak. Op een diepte van ongeveer 10 m is de druk 2000 hPa of twee atmosfeer.

De hier gebruikte druksensor heeft een meetbereik tussen 750 en 1500 hPa bij een resolutie van ongeveer één hPa. Dit betekent dat we dieptes tot 5 meter kunnen meten met een resolutie van ongeveer 1 cm.

Het apparaat zou een dieptemeter van het type Boyle Marriotte zijn. De montage is vrij eenvoudig en wordt in een latere stap beschreven. De sensor maakt gebruik van het I2C-protocol, dus een edge-connector voor de micro:bit is handig. Het meest kritieke onderdeel zijn de waterdichte zakken, omdat eventuele vochtigheid de micro:bit, de sensor of de batterij zal beschadigen. Omdat er wat lucht in de zakken wordt opgesloten, helpt de toevoeging van gewichten om de opwaartse kracht te compenseren.

Stap 2: Het apparaat gebruiken

Het script, dat in een latere stap in detail wordt getoond, is een variatie op een script dat ik eerder heb ontwikkeld voor een drukmeter. Om het apparaat te testen, kunt u de daar beschreven eenvoudige drukkamer gebruiken.

Voor duikdoeleinden toont het de diepte in meters, zoals berekend uit drukmetingen, hetzij als een staafdiagram in stappen van 20 cm of, op verzoek, in cijfers.

Met de knop A op de micro:bit stelt u de huidige druk in als referentiedrukwaarde. Om de invoer te bevestigen, knippert de matrix eenmaal.

U kunt dit gebruiken om te zien hoe diep u aan het duiken bent, of om vast te leggen hoe diep u aan het duiken was.

Stel in het eerste geval de huidige buitenluchtdruk in als referentie. In het tweede geval stelt u de druk op het diepste punt in als drukreferentie, zodat u kunt laten zien hoe diep u bent geweest als u weer aan de oppervlakte bent. Knop B geeft de diepte weer, berekend op basis van het drukverschil, als een numerieke waarde in meters.

Stap 3: Benodigde materialen

Een micro:bit. bijv. voor 13 GBP/16 Euro bij Pimoroni UK/DE.

Een randconnector (Kitronic of Pimoroni), 5 GBP. Ik gebruikte de Kitronic-versie.

Een BMP/BME280-sensor. Ik gebruikte een BMP280-sensor van Banggood, 4,33 Euro voor drie eenheden.

Startkabels om sensor en randconnector aan te sluiten.

Een uitstekend alternatief voor de edge connector/sensor combinatie hierboven zou Pimoroni enviro:bit kunnen zijn (nu nog niet getest, zie laatste stap).

Een batterijpakket of LiPo voor de micro:bit.

Een stroomkabel met een schakelaar (optioneel maar handig). Doorzichtige waterdichte tassen. Ik heb een siliconen zakje gebruikt voor een mobiele telefoon en een of twee kleine ritssluitingszakjes. Zorg ervoor dat het materiaal dik genoeg is, zodat de pinnen op de randconnector de zakjes niet beschadigen.

Enkele gewichten. Ik gebruikte stukjes loden gewicht die gebruikt worden om te vissen.

Arduino IDE, en verschillende bibliotheken.

Stap 4: Montage

Installeer de Arduino IDE en de vereiste bibliotheken. Details worden hier beschreven.

(Niet vereist voor het MakeCode-script.) Bij gebruik van de Kitronik-edge connector, soldeer pinnen naar de I2C-poorten 19 & 20. Dit is niet vereist voor de Pimoroni-edge-connector. Soldeer de header aan de sensor breakout en sluit de sensor en de randconnector aan met behulp van startkabels. Sluit VCC aan op 3V, GND op 0 V, SCL op poort 19 en SDA op poort 20. U kunt de kabels ook rechtstreeks op de breakout solderen. Verbind de micro:bit met onze computer via een USB-kabel. Open het meegeleverde script en flash het naar de micro:bit. Gebruik de seriële monitor of plotter, controleer of de sensor redelijke gegevens geeft. Koppel de micro:bit los van uw computer. Sluit de batterij of LiPo aan op de micro:bit. Druk op knop B, lees de waarde Druk op knop A. Druk op knop B, lees de waarde. Plaats het apparaat in twee lagen luchtdichte zakken, zodat er maar heel weinig lucht in de zakken blijft. Plaats eventueel een gewicht om de opwaartse kracht te compenseren. Controleer of alles waterdicht is. Ga naar het zwembad en speel.

Stap 5: Het MicroPython-script

Het script neemt gewoon de drukwaarde van de sensor, vergelijkt deze met de referentiewaarde en berekent vervolgens de diepte van het verschil. Om de waarden als een staafdiagram weer te geven, worden het gehele getal en het resterende deel van de dieptewaarde genomen. De eerste bepaalt wel de hoogte van de lijn. De rest is opgedeeld in vijf bakken, die wel de lengte van de staven bepalen. Het hoogste niveau is 0 - 1 m, het laagste 4 - 5 m. Zoals eerder vermeld, stelt het indrukken van knop A de referentiedruk in, knop B geeft de "relatieve diepte" in meters weer, weergegeven als een numerieke waarde. Inmiddels worden negatieve en positieve waarden op dezelfde manier weergegeven als staafdiagram op de LED-matrix. Voel je vrij om het script te optimaliseren voor je behoeften. U kunt bepaalde regels opheffen om de waarden op de seriële monitor of plotter van de Arduino IDE weer te geven. Om de functie te emuleren, kunt u het apparaat bouwen dat ik in een eerdere instructable heb beschreven.

Ik heb het deel van het script dat de sensor leest niet geschreven. Ik ben niet zeker van de bron, maar ik wil graag de auteurs bedanken. Alle correcties of hints voor optimalisatie zijn welkom.

#erbij betrekken

#include Adafruit_Microbit_Matrix microbit; #define BME280_ADDRESS 0x76 unsigned long int hum_raw, temp_raw, pres_raw; ondertekend lange 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; dubbele druk_norm = 1015; // een startwaarde dubbele diepte; // berekende diepte //-------------------------------------------- -------------------------------------------------- ---------------------- void setup() { uint8_t osrs_t = 1; // Temperatuuroversampling x 1 uint8_t osrs_p = 1; //Druk oversampling x 1 uint8_t osrs_h = 1; // Oversampling vochtigheid x 1 uint8_t-modus = 3; // Normale modus uint8_t t_sb = 5; //Tstandby 1000ms uint8_t filter = 0; // Filter uit uint8_t spi3w_en = 0; //3-draads SPI Uitschakelen uint8_t ctrl_meas_reg = (osrs_t << 5) | (osrs_p << 2) | modus; uint8_t config_reg = (t_sb << 5) | (filter <<2) | spi3w_nl; uint8_t ctrl_hum_reg = osrs_h; pinMode (PIN_BUTTON_A, INPUT); pinMode (PIN_BUTTON_B, INPUT); Serieel.begin(9600); // stel de snelheid van de seriële poort in Serial.print ("Druk [hPa] "); // header voor seriële output Wire.begin(); writeReg (0xF2, ctrl_hum_reg); writeReg (0xF4, ctrl_meas_reg); writeReg (0xF5, config_reg); leesTrim(); // microbit.begin(); // microbit.print ("x"); vertraging (1000); } //----------------------------------------------- ---------------------------------------------- ongeldige lus() {dubbele temp_act = 0.0, press_act = 0.0, hum_act=0.0; ondertekend lange int temp_cal; unsigned long int press_cal, hum_cal; int N; int M; dubbele press_delta; // relatieve druk int depth_m; // diepte in meters, integer deel dubbel depth_cm; // rest in cm readData(); // temp_cal = kalibratie_T (temp_raw); press_cal = kalibratie_P(pres_raw); // hum_cal = kalibratie_H (hum_raw); // temp_act = (dubbel)temp_cal / 100.0; press_act = (dubbel)press_cal / 100.0; // hum_act = (dubbel) hum_cal / 1024.0; microbit.clear(); // reset LED-matrix // Knop A stelt werkelijke waarde in als referentie (P nul) // Knop B geeft huidige waarde weer als diepte in meters (berekend op basis van drukverschil) als (! digitalRead (PIN_BUTTON_A)) { // stel normale luchtdruk in als nul press_norm = press_act; // microbit.print ("P0: "); // microbit.print (press_norm, 0); // microbit.print ("hPa"); microbit.fillScreen (LED_ON); // één keer knipperen om de vertraging te bevestigen (100); }else if (! digitalRead (PIN_BUTTON_B)) { // diepte weergeven in meters microbit.print (diepte, 2); microbit.print("m"); // Serieel.println(""); }else{ // bereken diepte uit drukverschil press_delta = (press_act - press_norm); // bereken relatieve drukdiepte = (press_delta/100); // diepte in meters depth_m = int(abs(diepte)); // diepte im meter diepte_cm = (abs(diepte) - diepte_m); // rest /* // gebruikt voor ontwikkeling Serial.println(diepte); Serial.println(diepte_m); Serial.println (diepte_cm); */ // Stappen voor staafgrafiek als (diepte_cm> 0,8) { // stel lengte van staven in (N=4); } else if (diepte_cm > 0,6){ (N=3); } else if (diepte_cm > 0,4){ (N=2); } else if (diepte_cm > 0,2){ (N=1); } anders { (N=0); }

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

(M=4); } else if (diepte_m == 3){ (M=3); } else if (diepte_m == 2){ (M=2); } else if (diepte_m == 1){ (M=1); } anders { (M=0); // bovenste rij } /* // gebruikt voor ontwikkelingsdoeleinden Serial.print("m: "); Serial.println(diepte_m); Serial.print("cm: "); Serial.println (diepte_cm); Serial.print("M: "); Seriële.println(M); // voor ontwikkelingsdoeleinden Serial.print("N: "); Serieel.println(N); // voor ontwikkelingsdoeleinden vertraging (500); */ // teken staafdiagram microbit.drawLine (0, M, N, M, LED_ON); }

// stuur waarde naar seriële poort voor plotter

Serial.print(press_delta); // teken indicatorlijnen en repareer het weergegeven bereik Serial.print ("\t"); Serieafdruk(0); Serieel.print("\t"); Serieafdruk(-500); Serieel.print("\t"); Serieel.println(500); vertraging (500); // Meet twee keer per seconde } //----------------------------------------- -------------------------------------------------- -------------------------------------------------- -------- // het volgende is vereist voor de bmp/bme280-sensor, keep as it is void readTrim() { uint8_t data[32], i=0; // Fix 2014/Wire.beginTransmission (BME280_ADDRESS); Draad.schrijven (0x88); Wire.endTransmission(); Wire.requestFrom (BME280_ADDRESS, 24); // Fix 2014/while(Wire.available()){ data = Wire.read(); i++; } Wire.beginTransmission (BME280_ADDRESS); // Voeg 2014/Wire.write (0xA1) toe; // Voeg 2014/Wire.endTransmission(); // Voeg 2014/Wire.requestFrom toe (BME280_ADDRESS, 1); // Voeg 2014/data = Wire.read(); // Voeg 2014/i++ toe; // Voeg 2014/Wire.beginTransmission toe (BME280_ADDRESS); Draad.schrijven (0xE1); Wire.endTransmission(); Wire.requestFrom (BME280_ADDRESS, 7); // Fix 2014/while(Wire.available()){ data = Wire.read(); i++; } dig_T1 = (gegevens[1] << 8) | gegevens[0]; dig_P1 = (gegevens[7] << 8) | gegevens[6]; dig_P2 = (gegevens[9] << 8) | gegevens[8]; dig_P3 = (gegevens[11]<< 8) | gegevens[10]; dig_P4 = (gegevens[13]<< 8) | gegevens[12]; dig_P5 = (gegevens[15]<< 8) | gegevens[14]; dig_P6 = (gegevens[17]<< 8) | gegevens[16]; dig_P7 = (gegevens[19]<< 8) | gegevens[18]; dig_T2 = (gegevens[3] << 8) | gegevens[2]; dig_T3 = (gegevens[5] << 8) | gegevens[4]; dig_P8 = (gegevens[21]<< 8) | gegevens[20]; dig_P9 = (gegevens[23]<< 8) | gegevens[22]; dig_H1 = gegevens[24]; dig_H2 = (gegevens[26]<< 8) | gegevens[25]; dig_H3 = gegevens[27]; dig_H4 = (gegevens[28]<< 4) | (0x0F & gegevens[29]); dig_H5 = (gegevens[30] 4) & 0x0F); // Fix 2014/dig_H6 = gegevens [31]; // Fix 2014/} void writeReg (uint8_t reg_address, uint8_t data) { Wire.beginTransmission (BME280_ADDRESS); Wire.write(reg_address); Wire.write (gegevens); Wire.endTransmission(); } void readData() { int i = 0; uint32_t gegevens[8]; Wire.beginTransmission (BME280_ADDRESS); Draad.schrijven (0xF7); Wire.endTransmission(); Wire.requestFrom (BME280_ADDRESS, 8); while(Wire.available()){ data = Wire.read(); i++; } pres_raw = (data[0] << 12) | (gegevens[1] 4); temp_raw = (gegevens[3] << 12) | (gegevens[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) - ((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))*((signed long int)dig_P1))>>15); if (var1 == 0) { retourneer 0; } P = (((unsigned long int)(((signed 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 = (((signed long int)dig_P9) * ((signed long int)((((P>>3) * (P>>3))>>13)))>>12; var2 = (((signed long int)(P>>2)) * ((signed long int)dig_P8))>>13; P = (unsigned long int)((signed long int)P + ((var1 + var2 + dig_P7) >> 4)); retour P; } unsigned long int Calibration_H (signed long int adc_H) { ondertekend long int v_x1; v_x1 = (t_fine - ((ondertekend lang int)76800)); v_x1 = (((((adc_H << 14) -(((signed long int)dig_H4) 15) * (((((((v_x1 * ((signed long int)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);

Stap 6: Een belangrijke vereenvoudiging: de MakeCode/JavaScript-code

In mei 2018 heeft Pimoroni de enviro:bit uitgebracht, die wordt geleverd met een BME280 druk-/vochtigheids-/temperatuursensor, een TCS3472 licht- en kleursensor en een MEMS-microfoon. Daarnaast bieden ze een JavaScript-bibliotheek voor de MakeCode-editor en een MicroPython-bibliotheek voor deze sensoren.

Ik heb hun MakeCode-bibliotheek gebruikt om scripts voor mijn apparaat te ontwikkelen. Bijgevoegd vindt u de bijbehorende hex-bestanden, die u rechtstreeks naar uw micro:bit kunt kopiëren.

Hieronder vindt u de bijbehorende JavaScript-code. Testen in de pool werkte goed met een eerdere versie van het script, dus ik neem aan dat ze ook zullen werken. Naast de basis bargraph-versie is er ook een crosshair-versie (X) en een L-versie, bedoeld om het lezen te vergemakkelijken, vooral bij weinig licht. Kies degene die u verkiest.

laat Kolom = 0

laat Meter = 0 laten blijven = 0 laten Rij = 0 laten Delta = 0 laten Ref = 0 laten 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 + "." + blijven + " m") basic.pause(200) basic.clearScreen() } else { Is = envirobit.getPressure() Delta = Is - Ref Meter = Math.abs(Delta) if (Meter >= 400) { Rij = 4 } else if (Meter >= 300) { Rij = 3 } else if (Meter >= 200) { Rij = 2 } else if (Meter >= 100) { Rij = 1 } else { Rij = 0 } rest = Meter - Rij * 100 if (blijft >= 80) { Kolom = 4 } else if (blijft >= 60) { Kolom = 3 } else if (blijft >= 40) { Column = 2 } else if (remain>= 20) { Column = 1 } else { Column = 0 } for (let ColA = 0; ColA <= Column; ColA++) { led.plot(C olA, Rij) } basis.pauze(500) } })

Stap 7: De Enviro:bit-versie

Inmiddels heb ik de enviro:bit (20 GBP) en de power:bit (6 GBP) ontvangen, beide van Pimoroni.

Zoals eerder vermeld, wordt de enviro:bit geleverd met de BME280 druk-, vochtigheids- en temperatuursensor, maar ook een licht- en kleursensor (zie hier een applicatie) en een MEMS-microfoon.

De power:bit is een mooie oplossing om de micro:bit van stroom te voorzien en wordt geleverd met een aan/uit schakelaar.

Het mooie is dat het allebei gewoon klikken en gebruiken is, geen solderen, kabels, breadboards. Voeg de enviro:bit toe aan de micro:bit, laad je code in de micro:bit, gebruik hem.

In dit geval heb ik micro, power en enviro:bit gebruikt, ze in een Ziploc-zak gedaan, in een doorzichtige waterdichte plastic zak voor mobiele telefoons geplaatst, klaar. Een zeer snelle en nette oplossing. Zie de foto's. De schakelaar is groot genoeg om hem door de beschermingslagen heen te gebruiken.

Het is getest in water, werkte goed. Op een diepte van ongeveer 1,8 m was de gemeten waarde ongeveer 1,7 m. Niet slecht voor een snelle & goedkope oplossing, maar verre van perfect. Het duurt even om je aan te passen, dus het kan zijn dat je ongeveer 10-15 seconden op een bepaalde diepte moet blijven.

Stap 8: Kabel- en sensorsondeversie

Dit was eigenlijk het eerste idee dat men had voor een micro:bit dieptemeter, het laatste dat werd gebouwd.

Hier heb ik de BMP280-sensor gesoldeerd aan 5m van een 4-aderige kabel en aan het andere uiteinde een vrouwelijke jumper geplaatst. Om de sensor tegen water te beschermen, werd de kabel door een gebruikte wijnkurk geleid. De uiteinden van de kurk werden verzegeld met hete lijm. Daarvoor had ik twee inkepingen in de kurk gemaakt, die er allebei omheen liepen. Daarna pakte ik de sensor in een sponsbal, plaatste er een ballon omheen en bevestigde het uiteinde van de ballon op de kurk (onderste inkeping). vervolgens plaatste ik 3 stukken loodgewicht van 40 g in een tweede ballon, wikkelde deze om de eerste, gewichten aan de buitenkant en bevestigde het uiteinde van de ballon bij de tweede inkeping. De lucht werd uit de tweede ballon verwijderd, daarna werd alles vastgezet met ducttape. Zie afbeeldingen, meer gedetailleerde kunnen volgen.

De jumpers werden via een edge-connector op de micro:bit aangesloten, het apparaat werd ingeschakeld en de referentiedruk werd ingesteld. Daarna werd de sensorkop langzaam losgelaten naar de bodem van het zwembad (10 m springtoren, ongeveer 4,5 m diep).

Resultaten:

Tot mijn verbazing werkte het zelfs met deze lange kabel. Aan de andere kant, maar niet verrassend, leek de meetfout groter te worden bij hogere drukken, en een geschatte diepte van 4 m werd gerapporteerd als ongeveer 3 m.

Mogelijke toepassingen:

Met enkele foutcorrecties kan het apparaat worden gebruikt om diepte te meten tot ongeveer 4 m.

In combinatie met een Arduino of Raspberry Pi kan dit worden gebruikt om het vulpunt van een zwembad of watertank, bijv. om een waarschuwing op te roepen als de waterstanden boven of onder bepaalde drempels komen.

Tweede plaats in de Outdoor Fitness Challenge