Mesurez la pression avec votre Micro:bit : 5 étapes (avec photos)

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:09

L'instructable suivante décrit un appareil facile à construire et peu coûteux pour effectuer des mesures de pression et démontrer la loi de Boyle, en utilisant le micro:bit en combinaison avec le capteur de pression/température BMP280.

Alors que cette combinaison seringue/capteur de pression a déjà été décrite dans l'un de mes précédents instructables, la combinaison avec le micro:bit offre de nouvelles opportunités, par ex. pour les projets de salle de classe.

De plus, le nombre de descriptions d'applications dans lesquelles le micro:bit est utilisé en combinaison avec un capteur piloté par I2C est plutôt limité jusqu'à présent. J'espère que cette instructable pourrait être un point de départ pour d'autres projets.

L'appareil permet d'effectuer des mesures quantitatives de la pression atmosphérique et d'afficher les résultats sur la matrice de LED micro:bit ou sur un ordinateur connecté, pour ce dernier en utilisant les fonctions de moniteur série ou de traceur série de l'IDE Arduino. De plus, vous avez un retour haptique, car vous pousserez ou tirerez vous-même le piston de la seringue et ressentirez ainsi la puissance requise.

Par défaut, l'affichage vous permet d'estimer la pression par l'indicateur de niveau affiché sur la matrice LED. Le traceur série de l'IDE Arduino permet de faire la même chose, mais avec une bien meilleure résolution (voir vidéo). Des solutions plus élaborées sont également disponibles, par ex. dans le langage de traitement. Vous pouvez également afficher les valeurs mesurées précises de la pression et de la température sur la matrice LED après avoir appuyé respectivement sur les boutons A ou B, mais le moniteur série de l'IDE Arduino est beaucoup plus rapide, permettant d'afficher les valeurs en temps quasi réel.

Les coûts totaux et les compétences techniques requises pour construire l'appareil sont plutôt faibles, ce qui pourrait être un beau projet de classe sous la supervision d'un enseignant. En outre, l'appareil pourrait être un outil pour les projets STEM axés sur la physique ou utilisé dans d'autres projets où une force ou un poids doit être transformé en une valeur numérique.

Le principe a été utilisé pour construire un très simple micro:bit dive-o-meter, un appareil pour mesurer à quelle profondeur vous plongez.

Addendum 27-mai-2018:

Comme Pimoroni a développé une bibliothèque MakeCode pour le capteur BMP280, cela m'a donné l'opportunité de développer un script à utiliser pour l'appareil décrit ici. Le script et le fichier HEX correspondant se trouvent dans la dernière étape de cette instructable. Pour l'utiliser, il suffit de charger le fichier HEX sur votre micro:bit. Pas besoin de logiciel spécial, et vous pouvez utiliser l'éditeur en ligne MakeCode pour éditer le script.

Étape 1: Matériaux utilisés

• Un micro:bit, obtenu le mien de Pimoroni - 13,50 GBP
• Connecteur de bord Kitronic pour micro:bit - via Pimoroni - 5 GBP, Remarque: Pimorini propose désormais un connecteur de bord compatible avec la planche à pain appelé pin:bit avec des broches sur les ports I2C.
• 2 bandes d'en-tête à 2 broches
• Batterie ou LiPo pour le micro:bit (pas nécessaire, mais utile), câble de batterie avec interrupteur (dito) - Pimoroni
• câbles de démarrage pour la connexion des capteurs au connecteur Edge
• câbles de démarrage longs (!) pour le capteur, au moins aussi longs que la seringue,, f/f ou f/m
• Capteur de pression et de température BMP280 - Banggood - 5 US$ pour trois unitésLa plage de mesure de ce capteur est comprise entre 550 et 1537 hPa.
• Seringue de cathéter en plastique de 150 ml avec joint en caoutchouc - Amazon ou quincailleries et jardineries - environ 2 - 3 US$
• pistolet à colle chaude/colle chaude
• fer à souder
• un ordinateur avec l'IDE Arduino installé

Étape 2: Instructions de montage

Soudez les en-têtes à la sortie du capteur BMP280.

Soudez les deux en-têtes à 2 broches aux connecteurs broche 19 et broche 20 du connecteur Edge (voir image).

Connectez le micro:bit au connecteur Edge et à votre ordinateur.

Préparez le logiciel et le micro:bit comme décrit dans les instructions micro:bit d'Adafruit. Lisez-les attentivement.

Installez les bibliothèques requises sur l'IDE Arduino.

Ouvrez le script BMP280 joint dans une étape ultérieure.

Connectez le capteur au connecteur Edge. GND à 0V, VCC à 3V, SCL à la broche 19, SDA à la broche 20.

Téléchargez le script sur le micro:bit.

Vérifiez que le capteur donne des données raisonnables, les valeurs de pression doivent être d'environ 1020 hPa, affichées sur le moniteur série. Dans ce cas, vérifiez d'abord les câbles et les connexions, puis l'installation du logiciel et corrigez.

Éteignez le micro:bit, retirez le capteur.

Faites passer les longs câbles de démarrage à travers la sortie de la seringue. Au cas où vous auriez à élargir l'ouverture. Veillez à omettre que les câbles sont endommagés.

Connectez le capteur aux câbles de démarrage. Vérifiez que les connexions sont correctes et bonnes. Connectez-vous au micro:bit.

Vérifiez que le capteur fonctionne correctement. En tirant avec précaution sur les câbles, déplacez le capteur vers le haut de la seringue.

Insérez le piston et déplacez-le un peu plus loin que la position de repos souhaitée (100 ml).

Ajoutez de la colle chaude à l'extrémité de la sortie de la seringue et reculez un peu le piston. Vérifiez si la seringue est fermée hermétiquement, sinon ajoutez plus de colle chaude. Laissez refroidir la colle chaude.

Vérifiez à nouveau que le capteur fonctionne. Si vous déplacez le piston, les numéros sur le moniteur série et l'affichage du micro:bit devraient changer.

Si nécessaire, vous pouvez ajuster le volume de la seringue en la pressant près du joint et en déplaçant le piston.

Étape 3: Un peu de théorie et quelques mesures pratiques

Avec l'appareil décrit ici, vous pouvez démontrer la corrélation de la compression et de la pression dans des expériences de physique simples. Comme la seringue est livrée avec une échelle "ml", même les expériences quantitatives sont faciles à réaliser.

La théorie derrière cela: Selon la loi de Boyle, [Volume * Pression] est une valeur constante pour un gaz à une température donnée.

Cela signifie que si vous comprimez un volume donné de gaz N fois, c'est-à-dire que le volume final est 1/N fois l'original, sa pression augmentera N fois, comme: P0*V0=P1*V1= contre t. Pour plus de détails, veuillez consulter l'article de Wikipédia sur les lois sur le gaz. Au niveau de la mer, la pression barométrique est généralement de l'ordre de 1010 hPa (hecto Pascal).

Donc, en commençant par un point de repos, par ex. V0=100 ml et P0=1000 hPa, une compression de l'air à environ 66 ml (i.e. V1 = 2/3 * V0) se traduira par une pression d'environ 1500 hPa (P1= 3/2 de P0). Tirer le piston jusqu'à 125 ml (5/4 fois le volume) entraîne une pression d'environ 800 hPa (pression 4/5). Les mesures sont étonnamment précises pour un appareil aussi simple.

L'appareil vous permet d'avoir une impression haptique directe de la force nécessaire pour comprimer ou dilater la quantité relativement faible d'air dans la seringue.

Mais nous pouvons aussi effectuer quelques calculs et les vérifier expérimentalement. Supposons que nous comprimions l'air à 1500 hPa, à une pression barométrique basale de 1000 hPa. La différence de pression est donc de 500 hPa, soit 50 000 Pa. Pour ma seringue, le diamètre (d) du piston est d'environ 4 cm soit 0,04 mètre.

Vous pouvez maintenant calculer la force nécessaire pour maintenir le piston dans cette position. Soit P = F/A (la pression est la force divisée par la surface), ou transformé F = P*A. L'unité SI pour la force est "Newton" N, pour la longueur "Mètre" m, et 1 Pa est 1N par mètre carré. Pour un piston rond, la surface peut être calculée en utilisant A = ((d/2)^2)*pi, ce qui donne 0,00125 mètres carrés pour ma seringue. Donc

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

Sur Terre, 1 N correspond à un poids de 100 gr, donc 63 N équivaut à un poids de 6,3 kg.

Ceci peut être vérifié facilement à l'aide d'une balance. Poussez la seringue avec le piston sur l'échelle, jusqu'à une pression d'environ 1500 hPa, puis lisez l'échelle. Ou appuyez jusqu'à ce que la balance indique environ 6-7 kg, puis appuyez sur le bouton "A" et lisez la valeur affichée sur la matrice LED du micro:bit. Il s'est avéré que l'estimation basée sur les calculs ci-dessus n'était pas mauvaise. Une pression légèrement supérieure à 1500 hPa corrélée à un "poids" affiché d'environ 7 kg sur une balance corporelle (voir images). Vous pouvez également inverser ce concept et utiliser l'appareil pour créer une échelle numérique simple basée sur des mesures de pression.

Veuillez noter que la limite supérieure pour le capteur est d'environ 1540 hPa, donc toute pression supérieure ne peut pas être mesurée et peut endommager le capteur.

Outre des objectifs pédagogiques, on peut également utiliser le système pour certaines applications du monde réel, car il permet de mesurer quantitativement les forces qui tentent de déplacer le piston dans un sens ou dans l'autre. Ainsi, vous pouvez mesurer un poids placé sur le piston ou une force d'impact frappant le piston. Ou construisez un interrupteur qui active une lumière ou un buzzer ou joue un son après qu'une certaine valeur seuil a été atteinte. Ou vous pouvez construire un instrument de musique qui change la fréquence en fonction de la force appliquée au piston. Ou utilisez-le comme contrôleur de jeu. Utilisez votre imagination et jouez !

Étape 4: Le script MicroPython

Vous trouverez en pièce jointe mon script BMP280 pour le micro:bit. C'est un dérivé d'un script BMP/BME280 que j'ai trouvé quelque part sur le site Web de Banggood, combiné à la bibliothèque Microbit d'Adafruit. Le premier permet d'utiliser le capteur Banggood, le second simplifie la prise en main de l'écran LED 5x5. Mes remerciements vont aux développeurs des deux.

Par défaut, le script affiche les résultats des mesures de pression en 5 étapes sur l'écran LED 5x5 du micro:bit, permettant de voir les changements avec peu de retard. Les valeurs précises peuvent être affichées en parallèle sur le moniteur série Arduino IDE, ou un graphique plus détaillé peut être affiché sur le traceur sériel de l'Arduino IDE.

Si vous appuyez sur le bouton A, les valeurs de pression mesurées sont affichées sur le réseau de LED 5x5 du micro:bit. Si vous appuyez sur le bouton B, les valeurs de température s'affichent. Bien que cela permette de lire des données précises, cela ralentit considérablement les cycles de mesure.

Je suis sûr qu'il existe des moyens beaucoup plus élégants de programmer les tâches et d'améliorer le script. Toute aide est la bienvenue.

#inclure xxx

#include microbit Adafruit_Microbit_Matrix; #define BME280_ADDRESS 0x76 long int non signé hum_raw, temp_raw, pres_raw; signé long 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; // conteneurs pour les valeurs mesurées int value0; valeur int1; valeur int2; valeur int3; valeur int4; //------------------------------------------------ -------------------------------------------------- ------------------ void setup() { uint8_t osrs_t = 1; //Suréchantillonnage de température x 1 uint8_t osrs_p = 1; //Suréchantillonnage de pression x 1 uint8_t osrs_h = 1; //Suréchantillonnage d'humidité x 1 uint8_t mode = 3; //Mode normal uint8_t t_sb = 5; //Tstandby 1000ms uint8_t filter = 0; // Filtrer hors uint8_t spi3w_en = 0; //3-wire SPI Désactiver uint8_t ctrl_meas_reg = (osrs_t << 5) | (osrs_p << 2) | mode; uint8_t config_reg = (t_sb << 5) | (filtre << 2) | spi3w_fr; uint8_t ctrl_hum_reg = osrs_h; pinMode(PIN_BUTTON_A, ENTRÉE); pinMode(PIN_BUTTON_B, ENTRÉE); Serial.begin(9600); // Serial.println("Température [deg C]"); // Serial.print("\t"); Serial.print("Pression [hPa] "); // en-tête Wire.begin(); writeReg (0xF2, ctrl_hum_reg); writeReg(0xF4, ctrl_meas_reg); writeReg(0xF5, config_reg); readTrim(); // microbit.begin(); // microbit.print("x"); retard (1000); } //------------------------------------------------------------- -------------------------------------------------- -------- boucle vide() { double temp_act = 0.0, press_act = 0.0, hum_act=0.0; signé long int temp_cal; int long non signé press_cal, hum_cal; entier N; // définir les valeurs de seuil pour l'affichage matriciel à LED, en hPa double max_0 = 1100; double max_1 = 1230; double max_2 = 1360; double max_3 = 1490; readData(); temp_cal = calibration_T(temp_raw); press_cal = calibration_P(pres_raw); hum_cal = calibration_H(hum_raw); temp_act = (double)temp_cal / 100,0; press_act = (double) press_cal / 100,0; hum_act = (double)hum_cal / 1024,0; microbit.clear(); //réinitialiser la matrice LED /* 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)) { // l'affichage des valeurs en nombres retarde la mesure des cercles microbit.print("T: "); microbit.print(temp_act, 1); microbit.print(" 'C"); // Serial.println(""); } else if (! digitalRead(PIN_BUTTON_A)) { microbit.print("P: "); microbit.print(press_act, 0); microbit.print(" hPa"); }else{ // affichage des valeurs de pression sous forme de pixels ou de lignes à un certain niveau // 5 étapes: 1490 hPa // seuils définis par les valeurs max_n if (press_act > max_3){ (N=0); // ligne supérieure } else if (press_act > max_2){ (N=1); } else if (press_act > max_1){ (N=2); } else if (press_act > max_0){ (N=3); } autre { (N=4); // ligne de base } // Serial.println(N); // à des fins de développement // microbit.print(N); // en tant que ligne // microbit.drawLine(N, 0, 0, 4, LED_ON); // déplace les valeurs vers la ligne suivante value4 = value3; valeur3 = valeur2; valeur2 = valeur1; valeur1 = valeur0; valeur0 = N; // dessine l'image, colonne par colonne microbit.drawPixel(0, value0, LED_ON); // en tant que Pixel: colonne, ligne. 0, 0 coin supérieur gauche microbit.drawPixel(1, value1, LED_ON); microbit.drawPixel(2, valeur2, LED_ON); microbit.drawPixel(3, valeur3, LED_ON); microbit.drawPixel(4, value4, LED_ON); } // envoyer des données au moniteur série et au traceur série // Serial.println(press_act); // envoyer la ou les valeurs au port série pour l'affichage numérique, facultatif

Serial.print(press_act); // envoie la valeur au port série pour le traceur

// dessine des lignes indicatrices et corrige la plage affichée Serial.print("\t"); Serial.print(600); Serial.print("\t"); Serial.print(1100), Serial.print("\t"); Serial.println (1600); retard (200); // Mesure trois fois par seconde } //----------------------------------------- -------------------------------------------------- -------------------------------------------------- -- // ce qui suit est requis pour le capteur bmp/bme280, gardez comme il est void readTrim() { uint8_t data[32], i=0; // Correction de 2014/Wire.beginTransmission(BME280_ADDRESS); Wire.write(0x88); Wire.endTransmission(); Wire.requestFrom(BME280_ADDRESS, 24); // Correction de 2014/while(Wire.available()){ data = Wire.read(); je++; } Wire.beginTransmission(BME280_ADDRESS); // Ajout de 2014/Wire.write(0xA1); // Ajouter 2014/Wire.endTransmission(); // Ajouter 2014/Wire.requestFrom(BME280_ADDRESS, 1); // Ajouter 2014/data = Wire.read(); // Ajout de 2014/i++; // Ajouter 2014/Wire.beginTransmission(BME280_ADDRESS); Wire.write(0xE1); Wire.endTransmission(); Wire.requestFrom(BME280_ADDRESS, 7); // Correction de 2014/while(Wire.available()){ data = Wire.read(); je++; } dig_T1 = (données[1] << 8) | données[0]; dig_P1 = (données[7] << 8) | données[6]; dig_P2 = (données[9] << 8) | données[8]; dig_P3 = (données[11]<< 8) | données[10]; dig_P4 = (données[13]<< 8) | données[12]; dig_P5 = (données[15]<< 8) | données[14]; dig_P6 = (données[17]<< 8) | données[16]; dig_P7 = (données[19]<< 8) | données[18]; dig_T2 = (données[3] << 8) | données[2]; dig_T3 = (données[5] << 8) | données[4]; dig_P8 = (données[21]<< 8) | données[20]; dig_P9 = (données[23]<< 8) | données[22]; dig_H1 = données[24]; dig_H2 = (données[26]<< 8) | données[25]; dig_H3 = données[27]; dig_H4 = (données[28]<< 4) | (0x0F & données[29]); dig_H5 = (données[30] 4) & 0x0F); // Corrige 2014/dig_H6 = data[31]; // Correction de 2014/} void writeReg(uint8_t reg_address, uint8_t data) { Wire.beginTransmission(BME280_ADDRESS); Wire.write(reg_address); Wire.write(données); Wire.endTransmission(); }

annuler readData()

{ entier je = 0; données uint32_t[8]; Wire.beginTransmission(BME280_ADDRESS); Wire.write(0xF7); Wire.endTransmission(); Wire.requestFrom(BME280_ADDRESS, 8); while(Wire.available()){ data = Wire.read(); je++; } pre_raw = (data[0] << 12) | (données[1] 4); temp_raw = (données[3] << 12) | (données[4] 4); hum_raw = (données[6] << 8) | données[7]; }

signé long int calibration_T(signé long int adc_T)

{ signé long int var1, var2, T; var1 = ((((adc_T >> 3) - ((signé long int)dig_T1 11; var2 = (((((adc_T >> 4) - ((signé long int)dig_T1)) * ((adc_T>>4) - ((signé long int)dig_T1))) >> 12) * ((signé long int)dig_T3)) >> 14; t_fine = var1 + var2; T = (t_fine * 5 + 128) >> 8; retour T; } unsigned long int calibration_P(signé long int adc_P) { signé long int var1, var2; non signé long int P; var1 = (((signé long int)t_fine)>>1) - (signé long int)64000; var2 = (((var1>>2) * (var1>>2)) >> 11) * ((signé long int)dig_P6); var2 = var2 + ((var1*((signé long int)dig_P5))2) +(((signé long int)dig_P4)2)*(var1>>2)) >> 13)) >>3) + ((((signé long int)dig_P2) * var1)>>1))>> 18; var1 = ((((32768+var1))*((signé long int)dig_P1))>>15); if (var1 == 0) { return 0; } P = (((entier long non signé)(((entier long signé)1048576)-adc_P)-(var2>>12)))*3125; if(P<0x80000000) { P = (P <<1) / ((entier long non signé) var1); } else { P = (P / (entier long non signé)var1) * 2; } var1 = (((signé long int)dig_P9) * ((signé long int)(((P>>3) * (P>>3))>>13)))>>12; var2 = (((signé long int)(P>>2)) * ((signé long int)dig_P8))>>13; P = (entier long non signé)((entier long signé)P + ((var1 + var2 + dig_P7) >> 4)); retourner P; } non signé long int calibration_H(signé long int adc_H) { signé long int v_x1; v_x1 = (t_fine - ((signé long int)76800)); v_x1 = (((((adc_H << 14) -(((signé long int)dig_H4) 15) * (((((((v_x1 * ((signé long int)dig_H6)) >> 10) * (((v_x1 * ((signé long int)dig_H3)) >> 11) + ((signé long int) 32768))) >> 10) + ((signé long int)2097152)) * ((signé long int) dig_H2) + 8192) >> 14)); v_x1 = (v_x1 - (((((v_x1 >> 15) * (v_x1 >> 15)) >> 7) * ((signé long int)dig_H1)) >> 4)); v_x1 = (v_x1 419430400 ? 419430400: v_x1); return (unsigned long int)(v_x1 >> 12); }

Étape 5: Scripts MakeCode/JavaScript

Pimoroni a récemment sorti l'enviro:bit, qui est livré avec un capteur de pression BMP280, un capteur de lumière/couleur et un microphone MEMS. Ils proposent également un MicroPython et une bibliothèque MakeCode/JavaScript.

J'ai utilisé ce dernier pour écrire un script MakeCode pour le capteur de pression. Le fichier hexadécimal correspondant peut être copié directement sur votre micro:bit. Le code est affiché ci-dessous et peut être modifié à l'aide de l'éditeur en ligne MakeCode.

C'est une variante du script du micro:bit dive-o-meter. Par défaut, il affiche la différence de pression sous forme de graphique à barres. Un appui sur le bouton A règle la pression de référence, un appui sur le bouton B affiche la différence entre la pression réelle et la pression de référence en hPa.

En plus de la version code-barres de base, vous trouverez également une version "X", réticule et une version "L", destinée à faciliter la lecture.

laissez Colonne = 0

let rest = 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 (Mètre >= 400) { Rangée = 4 } else if (Mètre >= 300) { Rangée = 3 } else if (Mètre >= 200) { Rangée = 2 } else if (Mètre >= 100) { Rangée = 1 } else { Ligne = 0 } reste = Compteur - Ligne * 100 if (reste >= 80) { Colonne = 4 } else if (reste >= 60) { Colonne = 3 } else if (reste >= 40) { Colonne = 2 } else if (reste >= 20) { Column = 1 } else { Column = 0 } for (let ColA = 0; ColA <= Column; ColA++) { led.plot(ColA, Row) } base.pause(500) } })