Un Dive-O-Meter Micro:bit : 8 étapes (avec photos)

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

L'été est là, c'est l'heure de la piscine !

Une bonne occasion de sortir vous et votre micro:bit à l'extérieur, et dans ce cas même dans la piscine.

Le micro:bit dive-o-meter décrit ici est une simple jauge de profondeur de bricolage qui vous permet de mesurer à quelle profondeur vous plongez ou étiez en train de plonger. Il se compose simplement d'un micro:bit, d'une batterie ou d'un LiPo, d'un connecteur de bord pour le micro:bit, d'un capteur de pression barométrique BMP280 ou BME280 et de quelques câbles de démarrage. L'utilisation de Pimoroni enviro:bit rend les choses encore plus simples. Tout cela est emballé dans deux couches de sacs étanches en plastique transparent ou en silicone, avec quelques poids ajoutés pour compenser la force de flottabilité.

Il s'agit d'une application du dispositif de capteur de pression micro:bit que j'avais décrit dans un précédent instructable.

Vous pouvez utiliser l'appareil e. g. pour des compétitions de plongée avec des amis et la famille, ou pour découvrir la profondeur réelle de cet étang. Je l'ai testé en utilisant la piscine la plus profonde de mon quartier et j'ai constaté qu'il fonctionnait au moins jusqu'à une profondeur de 3,2 mètres. Environ cinq mètres est le maximum théorique. Jusqu'à présent, je n'ai pas testé sa précision en détail, mais les chiffres rapportés étaient au moins dans la plage attendue.

Quelques remarques: Ce n'est pas censé être un outil pour les vrais plongeurs. Votre micro:bit sera endommagé s'il est mouillé. Vous utilisez cette instructable à vos risques et périls.

Mise à jour du 27 mai: vous pouvez désormais trouver un script MakeCode HEX que vous pouvez charger directement sur votre micro:bit. Voir l'étape 6. Mise à jour du 13 juin: Ajout d'une version Enviro:bit et d'une version câble. Voir les étapes 7 et 8

Étape 1: La théorie derrière l'appareil

Nous vivons au fond d'un océan d'air. La pression ici est d'environ 1020 hPa (hectoPascal) car le poids de la colonne d'air ici dans l'espace est d'environ 1 kg par centimètre carré.

La densité de l'eau est beaucoup plus élevée, car un litre d'air pèse environ 1,2 g et un litre d'eau 1 kg, soit environ 800 fois. Ainsi, comme la chute de pression barométrique est d'environ 1 hPa pour 8 mètres de hauteur, le gain de pression est de 1 hPa pour chaque centimètre sous la surface de l'eau. A une profondeur d'environ 10 m, la pression est de 2000 hPa, soit deux atmosphères.

Le capteur de pression utilisé ici a une plage de mesure comprise entre 750 et 1500 hPa à une résolution d'environ un hPa. Cela signifie que nous pouvons mesurer des profondeurs allant jusqu'à 5 mètres avec une résolution d'environ 1 cm.

L'appareil serait un profondimètre de type Boyle Marriotte. Son assemblage est assez simple et décrit dans une étape ultérieure. Le capteur utilise le protocole I2C, donc un connecteur de bord pour le micro:bit est pratique. La partie la plus critique sont les sacs étanches, car toute humidité endommagera le micro:bit, le capteur ou la batterie. Comme de l'air sera emprisonné à l'intérieur des sacs, l'ajout de poids aide à compenser la force de flottabilité.

Étape 2: Utilisation de l'appareil

Le script, comme indiqué en détail à une étape ultérieure, est une variante d'un script que j'ai développé précédemment pour un manomètre. Pour tester l'appareil, vous pouvez utiliser la simple chambre de pression qui y est décrite.

Pour la plongée, il indique la profondeur en mètres, calculée à partir des mesures de pression, soit sous forme de graphique à barres par pas de 20 cm, soit, sur demande, en chiffres.

En utilisant le bouton A sur le micro:bit, vous définirez la pression actuelle comme valeur de pression de référence. Pour confirmer la saisie, la matrice clignote une fois.

Vous pouvez l'utiliser soit pour voir à quelle profondeur vous plongez, soit pour enregistrer à quelle profondeur vous plongez.

Dans le premier cas, définissez la pression d'air extérieur actuelle comme référence. Dans le second cas, réglez la pression au point le plus profond où vous êtes comme référence de pression, ce qui vous permet ensuite de montrer à quelle profondeur vous avez été lorsque vous êtes de retour à la surface. Le bouton B affiche la profondeur, calculée à partir de la différence de pression, sous forme de valeur numérique en mètres.

Étape 3: Matériel requis

Un micro:bit. Par exemple. à 13 GBP/16 Euro chez Pimoroni UK/DE.

Un connecteur de bord (Kitronic ou Pimoroni), 5 GBP. J'ai utilisé la version Kitronic.

Un capteur BMP/BME280. J'ai utilisé un capteur BMP280 de Banggood, 4,33 euros pour trois unités.

Câbles de démarrage pour connecter le capteur et le connecteur de bord.

Une excellente alternative à la combinaison connecteur/capteur de bord ci-dessus pourrait être Pimoroni enviro:bit (non testé à ce jour, voir la dernière étape).

Une batterie ou LiPo pour le micro:bit.

Un câble d'alimentation avec un interrupteur (facultatif mais utile). Sacs transparents étanches. J'ai utilisé une pochette en silicone pour un téléphone portable et un ou deux petits sacs ziploc. Assurez-vous que le matériau est suffisamment épais pour que les broches du connecteur de bord n'endommagent pas les sacs.

Quelques poids. J'ai utilisé des morceaux de plomb qui sont utilisés pour la pêche.

Arduino IDE et plusieurs bibliothèques.

Étape 4: Assemblage

Installez l'IDE Arduino et les bibliothèques requises. Les détails sont décrits ici.

(Non requis pour le script MakeCode.) Étant donné que vous utilisez le connecteur de bordure Kitronik, soudez les broches aux ports I2C 19 et 20. Ceci n'est pas requis pour le connecteur de bordure Pimoroni. Soudez le connecteur à la sortie du capteur et connectez le capteur et le connecteur de bord à l'aide de câbles de démarrage. Connectez VCC à 3V, GND à 0 V, SCL au port 19 et SDA au port 20. Vous pouvez également souder les câbles directement à la sortie. Connectez le micro:bit à notre ordinateur via un câble USB. Ouvrez le script fourni et flashez-le sur le micro:bit. Utilisez le moniteur série ou le traceur, vérifiez si le capteur donne des données raisonnables. Déconnectez le micro:bit de votre ordinateur. Connectez la batterie ou le LiPo au micro:bit. Appuyez sur le bouton B, lisez la valeur Appuyez sur le bouton A. Appuyez sur le bouton B, lisez la valeur. Placez l'appareil dans deux couches de sacs hermétiques, en ne laissant que très peu d'air dans les sacs. Au cas où, placez un poids pour compenser la force de flottabilité. Vérifiez si tout est étanche. Allez à la piscine et jouez.

Étape 5: Le script MicroPython

Le script prend simplement la valeur de pression du capteur, la compare à la valeur de référence, puis calcule la profondeur à partir de la différence. Pour afficher les valeurs sous forme de graphique à barres, l'entier et le reste de la valeur de profondeur sont pris. Le premier définit la hauteur de la ligne. Le reste est divisé en cinq cases, qui définissent la longueur des barres. Le niveau supérieur est de 0 à 1 m, le plus bas de 4 à 5 m. Comme mentionné précédemment, une pression sur le bouton A règle la pression de référence, le bouton B affiche la "profondeur relative" en mètres, affichée sous forme de valeur numérique. À présent, les valeurs négatives et positives sont présentées sous forme de graphique à barres sur la matrice LED de la même manière. N'hésitez pas à optimiser le script en fonction de vos besoins. Vous pouvez réactiver certaines lignes pour présenter les valeurs sur le moniteur série ou le traceur de l'IDE Arduino. Pour émuler la fonction, vous pouvez construire l'appareil que j'ai décrit dans une précédente instructable.

Je n'ai pas écrit la partie du script qui lit le capteur. Je ne suis pas sûr de la source, mais j'aime remercier les auteurs. Toute correction ou suggestion d'optimisation est la bienvenue.

#comprendre

#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; double press_norm = 1015; // une valeur de départ double profondeur; // profondeur calculée //-------------------------------------------- -------------------------------------------------- ---------------------- 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); // définit la vitesse du port série Serial.print("Pressure [hPa] "); // en-tête pour la sortie série 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; int M; double press_delta; // pression relative int profondeur_m; // profondeur en mètres, partie entière double depth_cm; // reste en cm 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 // Le bouton A définit la valeur réelle comme référence (P zéro) // Le bouton B affiche la valeur actuelle sous forme de profondeur en mètres (calculée à partir de la différence de pression) if (! digitalRead(PIN_BUTTON_A)) { // définit la pression atmosphérique normale comme zéro press_norm = press_act; // microbit.print("P0: "); // microbit.print(press_norm, 0); // microbit.print(" hPa"); microbit.fillScreen(LED_ON); // clignote une fois pour confirmer le délai (100); } else if (! digitalRead(PIN_BUTTON_B)) { // afficher la profondeur en mètres microbit.print(depth, 2); microbit.print("m"); // Serial.println(""); }else{ // calcule la profondeur à partir de la différence de pression press_delta = (press_act - press_norm); // calculer la profondeur de pression relative = (press_delta/100); // profondeur en mètres depth_m = int(abs(depth)); // profondeur en mètres profondeur_cm = (abs(profondeur) - profondeur_m); // reste /* // utilisé pour le développement Serial.println(depth); Serial.println(depth_m); Serial.println(profondeur_cm); */ // Étapes du bargraph if (depth_cm> 0.8){ // définir la longueur des barres (N=4); } else if (depth_cm > 0.6){ (N=3); } else if (depth_cm > 0.4){ (N=2); } else if (depth_cm > 0.2){ (N=1); } autre { (N=0); }

if (depth_m == 4){ // définir le niveau == mètre

(M=4); } else if (depth_m == 3){ (M=3); } else if (profondeur_m == 2){ (M=2); } else if (profondeur_m == 1){ (M=1); } autre { (M=0); // ligne supérieure } /* // utilisé à des fins de développement Serial.print("m: "); Serial.println(depth_m); Serial.print("cm: "); Serial.println(profondeur_cm); Serial.print("M: "); Serial.println(M); // à des fins de développement Serial.print("N: "); Serial.println(N); // à des fins de développement delay(500); */ // dessine le bargraph microbit.drawLine(0, M, N, M, LED_ON); }

// envoie la valeur au port série pour le traceur

Serial.print(press_delta); // dessine des lignes indicatrices et corrige la plage affichée Serial.print("\t"); Serial.print(0); Serial.print("\t"); Serial.print(-500); Serial.print("\t"); Serial.println(500); retard (500); // Mesure deux 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(); } void readData() { int i = 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 = (data[6] 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; return 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 6: Une simplification majeure: le code MakeCode/JavaScript

En mai 2018, Pimoroni a sorti l'enviro:bit, qui est livré avec un capteur de pression/humidité/température BME280, un capteur de lumière et de couleur TCS3472 et un microphone MEMS. De plus, ils proposent une bibliothèque JavaScript pour l'éditeur MakeCode et une bibliothèque MicroPython pour ces capteurs.

J'ai utilisé leur bibliothèque MakeCode pour développer des scripts pour mon appareil. Vous trouverez ci-joint les fichiers hexadécimaux correspondants, que vous pouvez copier directement sur votre micro:bit.

Vous trouverez ci-dessous le code JavaScript correspondant. Les tests dans le pool ont bien fonctionné avec une version antérieure du script, donc je suppose qu'ils fonctionneront également. En plus de la version de base, bargraph, il existe également une version réticule (X) et une version L, destinées à faciliter la lecture, notamment dans des conditions de faible luminosité. Choisissez celui que vous préférez.

laissez Colonne = 0

laissez Meter = 0 laissez rester = 0 laissez Row = 0 laissez Delta = 0 laissez Ref = 0 laissez 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 + "." + rester + " 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) { Ligne = 1 } else { Ligne = 0 } reste = Mètre - Ligne * 100 if (reste >= 80) { Colonne = 4 } else if (reste >= 60) { Colonne = 3 } else if (reste >= 40) { Column = 2 } else if (reste >= 20) { Column = 1 } else { Column = 0 } for (let ColA = 0; ColA <= Column; ColA++) { led.plot(C olA, ligne) } basic.pause(500) } })

Étape 7: La version Enviro:bit

Entre-temps, j'ai reçu l'enviro:bit (20 GBP) et le power:bit (6 GBP), tous deux de Pimoroni.

Comme mentionné précédemment, l'enviro:bit est livré avec le capteur de pression, d'humidité et de température BME280, mais aussi un capteur de lumière et de couleur (voir une application ici) et un microphone MEMS.

Le power:bit est une bonne solution pour alimenter le micro:bit et est livré avec un interrupteur marche/arrêt.

Ce qui est bien, c'est qu'il suffit de cliquer et d'utiliser, pas de soudure, de câbles, de maquettes. Ajoutez l'enviro:bit au micro:bit, chargez votre code dans le micro:bit, utilisez-le.

Dans ce cas, j'ai utilisé micro, power et enviro:bit, je les ai placés dans un sac Ziploc, je l'ai placé dans un sac en plastique transparent étanche pour téléphones portables, prêt. Une solution très rapide et soignée. Voir les images. Le commutateur est assez grand pour l'utiliser à travers les couches de protection.

Il a été testé dans l'eau, fonctionnait bien. À une profondeur d'environ 1,8 m, la valeur mesurée était d'environ 1,7 m. Pas trop mal pour une solution rapide et pas chère, mais loin d'être parfaite. L'ajustement prend un certain temps, vous devrez donc peut-être rester à une certaine profondeur pendant environ 10 à 15 secondes.

Étape 8: Version du câble et de la sonde de capteur

C'était en fait la première idée d'un profondimètre micro:bit, la dernière à être construite.

Ici, j'ai soudé le capteur BMP280 à 5 m d'un câble à 4 fils et placé un cavalier femelle à l'autre extrémité. Pour protéger le capteur de l'eau, le câble a été passé dans un bouchon de vin usagé. Les extrémités du bouchon ont été scellées avec de la colle chaude. Avant, j'avais fait deux entailles dans le bouchon, les deux faisant le tour. Ensuite, j'ai emballé le capteur dans une boule en éponge, j'ai placé un ballon autour et j'ai fixé l'extrémité du ballon sur le bouchon (encoche inférieure). puis j'ai placé 3 morceaux de plomb de 40 g dans un deuxième ballon, je l'ai enroulé autour du premier, des poids placés sur le côté extérieur, et j'ai fixé l'extrémité du ballon au deuxième cran. L'air a été retiré du deuxième ballon, puis tout a été fixé avec du ruban adhésif. Voir les images, des plus détaillées peuvent suivre.

Les cavaliers ont été connectés au micro:bit via un connecteur de bord, l'appareil a été allumé et la pression de référence a été réglée. Ensuite, la tête du capteur a été relâchée lentement au fond de la piscine (tour de saut de 10 m, profondeur d'environ 4,5 m).

Résultats:

À mon grand étonnement, cela fonctionnait même avec ce long câble. D'un autre côté, mais sans surprise, l'erreur de mesure a semblé devenir plus importante à des pressions plus élevées, et une profondeur estimée de 4 m a été signalée comme étant d'environ 3 m.

Applications potentielles:

Avec quelques corrections d'erreurs, l'appareil peut être utilisé pour mesurer la profondeur jusqu'à environ 4 m.

En conjonction avec un Arduino ou un Raspberry Pi, cela pourrait être utilisé pour mesurer et contrôler le point de remplissage d'une piscine ou d'un réservoir d'eau, par ex. pour déclencher un avertissement si les niveaux d'eau passent au-dessus ou en dessous de certains seuils.

Finaliste du défi de fitness en plein air