Druk meten met uw Micro:bit: 5 stappen (met afbeeldingen)

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

De volgende instructable beschrijft een eenvoudig te bouwen en goedkoop apparaat om drukmetingen uit te voeren en de wet van Boyle te demonstreren, met behulp van de micro:bit in combinatie met de BMP280 druk-/temperatuursensor.

Waar deze combinatie van spuit/druksensor al is beschreven in een van mijn vorige instructables, biedt de combinatie met de micro:bit nieuwe mogelijkheden, b.v. voor klaslokaalprojecten.

Bovendien is het aantal beschrijvingen van toepassingen waarin de micro:bit wordt gebruikt in combinatie met een I2C-aangedreven sensor tot nu toe vrij beperkt. Ik hoop dat deze instructable een startpunt kan zijn voor andere projecten.

Het apparaat maakt het mogelijk kwantitatieve luchtdrukmetingen uit te voeren en de resultaten weer te geven op de micro:bit LED-array of op een aangesloten computer, voor later gebruik van de seriële monitor of seriële plotterfuncties van de Arduino IDE. Daarnaast heb je een haptische feedback, omdat je zelf de zuiger van de spuit duwt of trekt, en hierdoor de benodigde kracht voelt.

Standaard stelt het display u in staat om de druk te schatten aan de hand van de niveau-indicator die op de LED-matrix wordt weergegeven. De seriële plotter van de Arduino IDE maakt hetzelfde mogelijk, maar met een veel betere resolutie (zie video). Er zijn ook meer uitgebreide oplossingen beschikbaar, b.v. in de Verwerkingstaal. U kunt ook de precieze gemeten waarden van druk en temperatuur op de LED-matrix weergeven nadat u op respectievelijk de A- of B-knop hebt gedrukt, maar de seriële monitor van de Arduino IDE is veel sneller, waardoor waarden in bijna realtime kunnen worden weergegeven.

De totale kosten en de technische vaardigheden die nodig zijn om het apparaat te bouwen zijn vrij laag, dus het zou een leuk klasproject kunnen zijn onder toezicht van een leraar. Daarnaast kan het apparaat een hulpmiddel zijn voor STEM-projecten met een focus op natuurkunde of worden gebruikt in andere projecten waar een kracht of gewicht wordt omgezet in een digitale waarde.

Het principe werd gebruikt om een zeer eenvoudige micro:bit duik-o-meter te construeren, een apparaat om te meten hoe diep je duikt.

Aanvulling 27-mei-2018:

Omdat Pimoroni een MakeCode-bibliotheek voor de BMP280-sensor heeft ontwikkeld, kreeg ik de kans om een script te ontwikkelen voor het hier beschreven apparaat. Het script en het bijbehorende HEX-bestand zijn te vinden in de laatste stap van deze instructable. Om het te gebruiken, laadt u gewoon het HEX-bestand naar uw micro:bit. U heeft geen speciale software nodig en u kunt de online MakeCode-editor gebruiken om het script te bewerken.

Stap 1: Gebruikte materialen

• Een micro:bit, ik heb de mijne van Pimoroni - 13,50 GBP
• Kitronic Edge Connector voor micro:bit - via Pimoroni - 5 GBP, Opmerking: Pimorini biedt nu een breadboard-vriendelijke edge-connector genaamd pin:bit met pinnen op de I2C-poorten.
• 2 x 2-pins headerstrips
• Accu of LiPo voor de micro:bit (niet noodzakelijk, wel handig), accukabel met schakelaar (idem) - Pimoroni
• startkabels voor aansluiting van sensoren op Edge-connector
• lange (!) startkabels voor de sensor, minstens zo lang als de spuit,, f/f of f/m
• BMP280 druk- en temperatuursensor - Banggood - 5 US$ voor drie eenheden Het meetbereik voor deze sensor ligt tussen 550 en 1537 hPa.
• Plastic katheterspuit van 150 ml met rubberen pakking - Amazon of hardware- en tuinwinkels - ongeveer 2 - 3 US$
• hete lijm/hete lijmpistool
• soldeerbout
• een computer waarop de Arduino IDE is geïnstalleerd

Stap 2: Montage-instructies

Soldeer headers naar de BMP280 sensor breakout.

Soldeer de twee 2-pins headers aan de pin 19 en pin 20 connectoren van de Edge connector (zie afbeelding).

Sluit de micro:bit aan op de Edge-connector en uw computer.

Bereid software en micro:bit voor zoals beschreven in de Adafruit micro:bit instructies. Lees ze grondig.

Installeer de vereiste bibliotheken op de Arduino IDE.

Open het bijgevoegde BMP280-script in een latere stap.

Sluit de sensor aan op de Edge-connector. GND naar 0V, VCC naar 3V, SCL naar pin 19, SDA naar pin 20.

Upload het script naar de micro:bit.

Controleer of de sensor redelijke gegevens geeft, de drukwaarden moeten rond 1020 hPa liggen, weergegeven op de seriële monitor. Controleer in dat geval eerst de kabels en aansluitingen, dan de software-installatie en corrigeer.

Micro:bit uitschakelen, sensor verwijderen.

Leid de lange startkabels door de uitlaat van de spuit. Voor het geval u de opening moet vergroten. Let op dat de kabels niet beschadigd raken.

Sluit de sensor aan op de startkabels. Controleer of de aansluitingen correct en goed zijn. Maak verbinding met de micro:bit.

Controleer of de sensor correct werkt. Trek voorzichtig aan de kabels en verplaats de sensor naar de bovenkant van de spuit.

Plaats de zuiger en verplaats deze iets verder dan de gewenste rustpositie (100 ml).

Voeg hete lijm toe aan het uiteinde van de spuituitlaat en beweeg de zuiger een beetje terug. Controleer of de spuit luchtdicht is gesloten, voeg anders meer hete lijm toe. Laat de hete lijm afkoelen.

Controleer nogmaals of de sensor werkt. Als u de zuiger verplaatst, moeten de cijfers in de seriële monitor en de weergave van de micro:bit veranderen.

Indien nodig kunt u het volume in de spuit aanpassen door deze dicht bij de pakking te knijpen en de zuiger te bewegen.

Stap 3: Een beetje theorie en enkele praktische metingen

Met het hier beschreven apparaat kun je de correlatie tussen compressie en druk aantonen in eenvoudige natuurkundige experimenten. Omdat de spuit wordt geleverd met een "ml"-schaal erop, zijn zelfs kwantitatieve experimenten eenvoudig uit te voeren.

De theorie erachter: Volgens de wet van Boyle is [Volume * Druk] een constante waarde voor een gas bij een bepaalde temperatuur.

Dit betekent dat als je een bepaald gasvolume N-voudig comprimeert, d.w.z. het uiteindelijke volume 1/N-voudig van het origineel is, de druk N-voudig stijgt, als volgt: P0*V0=P1*V1= cons t. Kijk voor meer informatie in het Wikipedia-artikel over gaswetten. Op zeeniveau ligt de luchtdruk meestal in het bereik van 1010 hPa (hecto Pascal).

Dus beginnend bij een rustpunt van b.v. V0=100 ml en P0=1000 hPa, een compressie van de lucht tot ongeveer 66 ml (d.w.z. V1 = 2/3 * V0) zal resulteren in een druk van ongeveer 1500 hPa (P1= 3/2 van P0). Trekken van de zuiger tot 125 ml (5/4-voudig volume) resulteert in een druk van ongeveer 800 hPa (4/5 druk). De metingen zijn verbazingwekkend nauwkeurig voor zo'n eenvoudig apparaat.

Met het apparaat kunt u direct voelen hoeveel kracht er nodig is om de relatief kleine hoeveelheid lucht in de spuit samen te drukken of uit te zetten.

Maar we kunnen ook wat berekeningen uitvoeren en experimenteel controleren. Stel dat we de lucht comprimeren tot 1500 hPa, bij een basale luchtdruk van 1000 hPa. Het drukverschil is dus 500 hPa, of 50.000 Pa. Voor mijn spuit is de diameter (d) van de zuiger ongeveer 4 cm of 0,04 meter.

Nu kun je de kracht berekenen die nodig is om de zuiger in die positie te houden. Gegeven P = F/A (Druk is Kracht gedeeld door Oppervlakte), of getransformeerd F = P*A. De SI-eenheid voor kracht is "Newton" N, voor lengte "Meter" m, en 1 Pa is 1N per vierkante meter. Voor een ronde zuiger kan het gebied worden berekend met A = ((d/2)^2)*pi, wat 0,00125 vierkante meter geeft voor mijn spuit. Dus

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

Op aarde komt 1 N overeen met een gewicht van 100 gram, dus 63 N is gelijk aan een gewicht van 6,3 kg.

Dit kan eenvoudig worden gecontroleerd met behulp van een schaal. Duw de spuit met de zuiger op de schaal, totdat een druk van ongeveer 1500 hPa is bereikt, lees dan de schaal af. Of druk totdat de weegschaal ongeveer 6-7 kg aangeeft, druk dan op de "A"-knop en lees de waarde af die wordt weergegeven op de micro:bit's LED-matrix. Het bleek dat de schatting op basis van de bovenstaande berekeningen niet slecht was. Een druk iets boven 1500 hPa correleerde met een weergegeven "gewicht" van ongeveer 7 kg op een weegschaal (zie afbeeldingen). Je kunt dit concept ook omdraaien en het apparaat gebruiken om een eenvoudige digitale weegschaal te bouwen op basis van drukmetingen.

Houd er rekening mee dat de bovengrens voor de sensor ongeveer 1540 hPa is, dus elke druk daarboven kan niet worden gemeten en kan de sensor beschadigen.

Naast educatieve doeleinden kan men het systeem ook gebruiken voor sommige toepassingen in de echte wereld, omdat het de mogelijkheid biedt om krachten kwantitatief te meten die de plunjer op de een of andere manier proberen te bewegen. U kunt dus een gewicht meten dat op de plunjer is geplaatst of een slagkracht die op de plunjer slaat. Of bouw een schakelaar die een licht of zoemer activeert of een geluid laat horen nadat een bepaalde drempelwaarde is bereikt. Of je zou een muziekinstrument kunnen bouwen dat de frequentie verandert afhankelijk van de kracht die op de plunjer wordt uitgeoefend. Of gebruik hem als gamecontroller. Gebruik je fantasie en speel!

Stap 4: Het MicroPython-script

Bijgevoegd vind je mijn BMP280-script voor de micro:bit. Het is een afgeleide van een BMP/BME280-script dat ik ergens op de Banggood-website vond, gecombineerd met Adafruit's Microbit-bibliotheek. Met de eerste kunt u de Banggood-sensor gebruiken, de tweede vereenvoudigt de bediening van het 5x5 LED-display. Mijn dank gaat uit naar de ontwikkelaars van beide.

Standaard geeft het script de resultaten van drukmetingen in 5 stappen weer op het 5x5 LED-display van de micro:bit, waardoor veranderingen met weinig vertraging te zien zijn. De precieze waarden kunnen parallel worden weergegeven op de Arduino IDE seriële monitor, of een meer gedetailleerde grafiek kan worden weergegeven op de seriële plotter van de Arduino IDE.

Als u op de A-knop drukt, worden de gemeten drukwaarden weergegeven op de 5x5 LED-array van de micro:bit. Als u op de B-knop drukt, worden de temperatuurwaarden weergegeven. Hoewel dit het mogelijk maakt om de precieze gegevens te lezen, vertraagt het de meetcycli aanzienlijk.

Ik ben er zeker van dat er veel elegantere manieren zijn om de taken te programmeren en het script te verbeteren. Alle hulp is welkom.

#inclusief xxx

#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; // containers voor meetwaarden int value0; int-waarde1; int-waarde2; int-waarde3; int-waarde4; //------------------------------------------------ -------------------------------------------------- ------------------ 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); // Serial.println ("Temperatuur [deg C]"); // Serieel.print("\t"); Serial.print("Druk [hPa] "); // koptekst Wire.begin(); writeReg (0xF2, ctrl_hum_reg); writeReg (0xF4, ctrl_meas_reg); writeReg (0xF5, config_reg); leesTrim(); // microbit.begin(); // microbit.print ("x"); vertraging (1000); } //----------------------------------------------- -------------------------------------------------- -------- void loop() {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; // ingestelde drempelwaarden voor LED-matrixweergave, in hPa dubbel max_0 = 1100; dubbel max_1 = 1230; dubbele max_2 = 1360; dubbele max_3 = 1490; leesData(); 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 /* Serial.print ("PRESS: "); Serial.println(press_act); Serial.print(" hPa "); Serial.print("TEMP: "); Serieel.print("\t"); Serial.println(temp_act); */ if (! digitalRead (PIN_BUTTON_B)) { // weergave van waarden in getallen vertragingen bij het meten van cirkels microbit.print ("T: "); microbit.print(temp_act, 1); microbit.print(" 'C"); // Serieel.println(""); }else if (! digitalRead(PIN_BUTTON_A)) { microbit.print("P: "); microbit.print(press_act, 0); microbit.print ("hPa"); }else{ // drukwaarden weergeven als pixels of lijnen in een bepaald niveau // 5 stappen: 1490 hPa // drempels gedefinieerd door de max_n-waarden if (press_act > max_3){ (N=0); // bovenste rij } else if (press_act > max_2){ (N=1); } else if (press_act > max_1){ (N=2); } else if (press_act > max_0){ (N=3); } anders { (N=4); // basisrij} // Serial.println (N); // voor ontwikkelingsdoeleinden // microbit.print(N); // as Line // microbit.drawLine (N, 0, 0, 4, LED_ON); // verschuif waarden naar de volgende regel value4 = value3; waarde3 = waarde2; waarde2 = waarde1; waarde1 = waarde0; waarde0 = N; // teken afbeelding, kolom voor kolom microbit.drawPixel (0, value0, LED_ON); // als Pixel: kolom, rij. 0, 0 linker bovenhoek microbit.drawPixel(1, value1, LED_ON); microbit.drawPixel(2, waarde2, LED_ON); microbit.drawPixel (3, waarde3, LED_ON); microbit.drawPixel(4, waarde4, LED_ON); } // stuur gegevens naar seriële monitor en seriële plotter // Serial.println (press_act); // stuur waarde(n) naar seriële poort voor numerieke weergave, optioneel

Serial.print(press_act); // stuur waarde naar seriële poort voor plotter

// teken indicatorlijnen en repareer het weergegeven bereik Serial.print ("\t"); Serieafdruk(600); Serieel.print("\t"); Serial.print(1100), Serial.print("\t"); Serieel.println(1600); vertraging (200); // Meet drie 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(); }

ongeldig leesData()

{ int ik = 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 = (gegevens[6] << 8) | gegevens[7]; }

ondertekend long int Calibration_T (signed long int adc_T)

{ ondertekend lange 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))*((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 5: MakeCode/JavaScript-scripts

Pimoroni heeft onlangs de enviro:bit uitgebracht, die wordt geleverd met een BMP280-druksensor, een licht-/kleurensensor en een MEMS-microfoon. Ze bieden ook een MicroPython en een MakeCode/JavaScript-bibliotheek.

Ik heb de laatste gebruikt om een MakeCode-script voor de druksensor te schrijven. Het bijbehorende hex-bestand kan rechtstreeks naar uw micro:bit worden gekopieerd. De code wordt hieronder weergegeven en kan worden gewijzigd met behulp van de online MakeCode-editor.

Het is een variatie op het script voor de micro:bit dive-o-meter. Standaard wordt het drukverschil weergegeven als een staafdiagram. Door op knop A te drukken wordt de referentiedruk ingesteld, door op knop B te drukken wordt het verschil tussen de werkelijke en de referentiedruk in hPa weergegeven.

Naast de basis barcode-versie vindt u ook een "X", een draadkruisversie en een "L"-versie, bedoeld om het lezen te vergemakkelijken.

laat Kolom = 0

laten blijven = 0 laten Rij = 0 laten Meter = 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("" + Delta + "hPa") 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 { Row = 0 } rest = Meter - Rij * 100 if (remain >= 80) { Column = 4 } else if (remain >= 60) { Column = 3 } else if (remain >= 40) { Column = 2 } else if (remain>= 20) { Column = 1 } else { Column = 0 } for (let ColA = 0; ColA <= Column; ColA++) { led.plot (ColA, Row) } basis.pauze(500) } })