Bibliothèque pour BMP280 et BME280 : 7 étapes

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

introduction

Je n'avais pas l'intention d'écrire cette bibliothèque. C'est « arrivé » comme effet secondaire d'un projet que j'ai commencé et qui utilise un BMP280. Ce projet n'est pas encore terminé, mais je pense que la bibliothèque est prête à partager avec d'autres. Par la suite, j'ai eu besoin d'utiliser un BME280, qui ajoute la mesure de l'humidité à la capacité de pression et de température du BMP280. Le BME280 est "rétrocompatible" avec le BMP280 - c'est-à-dire que tous les registres et les étapes nécessaires pour lire la pression et la température du BME280 sont les mêmes que ceux utilisés pour le BMP280. Des registres et des étapes supplémentaires sont nécessaires pour lire l'humidité, applicables uniquement au BME280. Cela soulève la question, une bibliothèque pour les deux, ou deux bibliothèques distinctes. Le matériel pour les deux types d'appareils est entièrement interchangeable. Même de nombreux modules vendus (par exemple sur Ebay et AliExpress) sont étiquetés BME/P280. Pour savoir de quel type il s'agit, vous devez regarder l'écriture (minuscule) sur le capteur lui-même, ou tester l'octet d'identification de l'appareil. J'ai décidé d'aller pour une seule bibliothèque. Cela semble avoir bien fonctionné.

Les commentaires, en particulier les suggestions d'améliorations, seront appréciés.

Fonctionnalités et capacités de la bibliothèque

Une bibliothèque est un logiciel qui fournit une interface de programmation d'applications (API) permettant à un programmeur d'exercer les capacités de l'appareil, sans nécessairement avoir à gérer tous les détails. Il est souhaitable que l'API soit facile à démarrer pour un débutant avec des exigences simples, tout en permettant une exploitation complète des capacités de l'appareil. Il est souhaitable que la bibliothèque suive toutes les directives spécifiques du fabricant du périphérique, ainsi que les bonnes pratiques générales du logiciel. Je me suis efforcé de réaliser tout cela. Lorsque j'ai commencé avec le BMP280, j'ai trouvé 3 bibliothèques différentes: Adafruit_BMP280; Graine_BMP280; et un appelé BMP280 du fabricant de l'appareil. Ni Adafruit ni Seeed n'ont fourni de fonctionnalités étendues, bien qu'elles aient bien fonctionné et soient faciles à utiliser pour les applications de base. Je ne pouvais pas comprendre comment utiliser celui produit par le fabricant de l'appareil (Bosch Sensortec). C'est peut-être ma déficience plutôt que la leur. Cependant la bibliothèque était beaucoup plus compliquée que les deux autres, je n'ai pas pu trouver d'instructions ou d'exemples d'utilisation (j'ai par la suite trouvé des exemples dans le fichier "bmp280_support.c", cependant ceux-ci ne m'ont pas été particulièrement utiles).

En raison de ces facteurs, j'ai décidé d'écrire ma propre bibliothèque pour le BMP280.

En examinant la situation de la bibliothèque pour le BME280, j'ai trouvé des bibliothèques distinctes Adafruit_BME280, Seed_BME280 et une autre BME280_MOD-1022 écrite par Embedded Adventures. Aucun d'entre eux n'a combiné les fonctions du BMP280 dans une bibliothèque capable d'utiliser le BME280. Aucun d'entre eux n'a explicitement pris en charge la capacité des appareils à stocker quelques bits de données pendant que l'appareil et son microprocesseur de contrôle sont en veille (cette capacité est évidente dans la fiche technique et prise en charge dans la bibliothèque que j'ai écrite et décrite ici).

Une bibliothèque combinée doit prendre en charge toutes les capacités du BME280, mais lorsqu'elle est utilisée avec un BMP280, elle ne doit pas imposer de surcharge due aux fonctions inutilisées. Les avantages d'une bibliothèque combinée incluent moins de fichiers de bibliothèque à gérer, une combinaison facile de différents appareils dans le même projet et des modifications simplifiées pour la maintenance ou les mises à niveau qui ne doivent être effectuées qu'à un seul endroit plutôt qu'à deux. Celles-ci sont probablement toutes assez mineures, voire insignifiantes, mais…

Capacités de l'appareil

Les BMP280 et BME280 sont des appareils à montage en surface d'environ 5 mm de côté et 1 mm de haut. Il y a 8 plots d'interface, dont 2 plots d'entrée d'alimentation séparés et deux plots de masse. Ils sont disponibles sur eBay sous forme de module avec 4 ou 6 broches sorties. Le module à 4 broches a une adresse I2C fixe et ne peut pas être configuré pour utiliser le protocole SPI.

Le module à 6 broches ou l'appareil nu peut être utilisé avec les protocoles I2C ou SPI. En mode I2C, il peut avoir deux adresses différentes, obtenues en connectant la broche SDO soit à la masse (pour l'adresse de base = 0x76) soit à Vdd (pour l'adresse de base +1 = 0x77). En mode SPI, il a la disposition habituelle de 1 horloge, 2 données (une pour chaque direction) et une broche de sélection de périphérique (CS).

La bibliothèque que j'ai écrite et décrite ici ne prend en charge que I2C. Les bibliothèques Adafruit_BMP280 et BME_MOD-1022 prennent en charge à la fois i2C et SPI.

La bibliothèque est téléchargeable ici:

github.com/farmerkeith/BMP280-library

Étape 1: configuration du matériel

Avant que la bibliothèque puisse être utile, il est nécessaire de connecter un microcontrôleur au BMP280 (ou à deux d'entre eux si vous le souhaitez).

J'ai utilisé un WeMos D1 mini pro, je vais donc montrer ses connexions. Les autres microcontrôleurs seront similaires, il vous suffit de connecter correctement les broches SDA et SCL.

Dans le cas du WeMos D1 mini pro, les connexions sont:

Fonction broche WeMos broche BMP280 Remarques

SDA D2 SDA SCL D1 SCL Vdd 3V3 Vin Nominal 3.3V Masse GND Contrôle d'adresse SDO Masse ou Vdd I2C sélectionne CSB Vdd (GND sélectionne SPI)

Notez que la broche SDO de certains modules MP280 est étiquetée SDD et que la broche Vdd peut être étiquetée VCC. Remarque: les lignes SDA et SCL doivent avoir des résistances de rappel entre la ligne et la broche Vin. Typiquement, une valeur de 4,7K devrait être OK. Certains modules BMP280 et BME280 ont des résistances pull-up de 10K incluses dans le module (ce qui n'est pas une bonne pratique, car mettre plusieurs périphériques sur le bus I2C peut le charger excessivement). Cependant, l'utilisation de 2 modules BME/P280 chacun avec une résistance de 10K ne devrait pas être un problème dans la pratique tant qu'il n'y a pas trop d'autres appareils sur le même bus également avec des résistances pull-up.

Une fois le matériel connecté, vous pouvez facilement vérifier si votre appareil est un BMP280 ou un BME280 en exécutant le sketch I2CScan_ID que vous pouvez trouver ici:

Vous pouvez également vérifier si vous avez un BMP280 ou un BME280 en regardant l'appareil lui-même. J'ai trouvé nécessaire d'utiliser un microscope numérique pour ce faire, mais si votre vue est très bonne, vous pourrez peut-être le faire sans aucune aide. Il y a deux lignes d'impression sur le boîtier de l'appareil. La clé est la première lettre de la deuxième ligne, qui dans le cas des appareils BMP280 est un "K" et dans le cas des appareils BME280 est un "U".

Étape 2: API fournies par la bibliothèque

Inclure la bibliothèque dans un croquis

La bibliothèque est incluse dans une esquisse de manière standard en utilisant l'instruction

#include "farmerkeith_BMP280.h"

Cette instruction doit être incluse dans la première partie de l'esquisse avant le début de la fonction setup().

Création d'un objet logiciel BME ou BMP

Il existe 3 niveaux de création de l'objet logiciel BMP280. Le plus simple est juste

nom_objet bme280; ou bmp280 objectName;

par exemple, BMP280 bmp0;

Cela crée un objet logiciel avec l'adresse par défaut de 0x76 (c'est-à-dire pour SDO connecté à la terre).

Le niveau suivant pour créer un objet logiciel BME280 ou BMP280 a un paramètre de 0 ou 1, comme suit:

bme280 nom_objetA(0);

bmp280 objectNameB(1);

Le paramètre (0 ou 1) est ajouté à l'adresse de base I2C, afin que deux appareils BME280 ou BMP280 puissent être utilisés sur le même bus I2C (dont un de chaque).

Le troisième niveau de création d'un objet logiciel BME ou BMP280 comporte deux paramètres. Le premier paramètre, qui vaut 0 ou 1, est pour l'adresse, comme pour le cas précédent. Le deuxième paramètre contrôle l'impression de débogage. S'il est défini sur 1, chaque transaction avec l'objet logiciel génère des sorties Serial.print qui permettent au programmeur de voir les détails de la transaction. Par exemple:

bmp280 objectNameB(1, 1);

Si le paramètre d'impression de débogage est défini sur 0, l'objet logiciel revient à un comportement normal (pas d'impression).

Cette ou ces instructions doivent être incluses après le #include et avant la fonction setup().

Initialisation de l'objet logiciel BME ou BMP

Avant de l'utiliser, il est nécessaire de lire les paramètres d'étalonnage de l'appareil et de le configurer pour le mode de mesure, le suréchantillonnage et les paramètres de filtre appropriés.

Pour une initialisation simple et générale, l'instruction est:

objectName.begin();

Cette version de begin() lit les paramètres d'étalonnage de l'appareil et définit osrs_t=7 (16 mesures de température), osrs_p=7 (16 mesures de pression), mode=3 (continu, Normal), t_sb=0 (0,5 ms de veille entre ensembles de mesures), filter=0 (K=1, donc pas de filtrage) et spiw_en=0 (SPI désactivé, donc utilisez I2C). Dans le cas du BME280, il existe un paramètre supplémentaire osrs_h=7 pour 16 mesures d'humidité.

Il existe une autre version de begin() qui prend les six (ou 7) paramètres. L'équivalent de l'énoncé ci-dessus est

objectName.begin (7, 7, 3, 0, 0, 0); // osrs_t, osrs_p, mode, t_sb, filtre, spiw_en

ou objectName.begin (7, 7, 3, 0, 0, 0, 7); // osrs_t, osrs_p, mode, t_sb, filtre, spiw_en, osrs_h

La liste complète des codes et leurs significations se trouve dans la fiche technique BME280 et BMP280, ainsi que dans les commentaires du fichier.cpp de la bibliothèque.

Mesure simple de la température et de la pression

Pour obtenir une mesure de température, le moyen le plus simple est

double temperature=objectName.readTemperature (); // mesure la température

Pour obtenir une mesure de pression, le moyen le plus simple est

double pression=objectName.readPressure (); // mesure la pression

Pour obtenir une mesure d'humidité, le moyen le plus simple est

double humidité=objectName.readHumidity (); // mesure de l'humidité (BME280 uniquement)

Pour obtenir à la fois la température et la pression, les deux instructions ci-dessus peuvent être utilisées l'une après l'autre, mais il existe une autre option, à savoir:

température double;

double pression=objectName.readPressure (température); // mesure la pression et la température

Cette instruction lit les données du dispositif BME280 ou BMP280 une seule fois et renvoie à la fois la température et la pression. Ceci est une utilisation légèrement plus efficace du bus I2C et garantit que les deux lectures correspondent au même cycle de mesure.

Pour le BME 280, une déclaration combinée qui obtient les trois valeurs (humidité, température et pression) est:

double température, pression;double humidité=objectName.readHumidity (température, pression); // mesure l'humidité, la pression et la température

Cette instruction ne lit les données du périphérique BMP280 qu'une seule fois et renvoie les trois valeurs. Ceci est une utilisation légèrement plus efficace du bus I2C et garantit que les trois lectures correspondent au même cycle de mesure. Notez que les noms des variables peuvent être changés en tout ce que l'utilisateur aime, mais leur ordre est fixe - la température vient en premier et la pression vient en second.

Ces cas d'utilisation sont couverts par des exemples de croquis fournis avec la bibliothèque, à savoir basicTemperature.ino, basicPressure.ino, basicHumidity.ino, basicTemperatureAndPressure.ino et basicHumidityAndTemperatureAndPressure.ino.

Mesure de température et de pression plus sophistiquée

Bien que la série d'instructions ci-dessus fonctionne sans problème, il existe quelques problèmes:

1. l'appareil fonctionne en continu et consomme donc de l'énergie à son niveau maximum. Si l'énergie provient d'une batterie, il peut être nécessaire de la réduire.
2. en raison de la puissance consommée, l'appareil subira un réchauffement et, par conséquent, la température mesurée sera supérieure à la température ambiante. Je couvrirai cela plus en détail dans une étape ultérieure.

Un résultat qui consomme moins d'énergie et donne une température plus proche de l'ambiante peut être obtenu en utilisant begin() avec des paramètres qui le mettent en veille (par exemple mode=0). Par exemple:

nom_objet.begin(1, 1, 0, 0, 0, 0[, 1]); // osrs_t, osrs_p, mode, t_sb, filtre, spiw_en [, osrs_h]

Ensuite, lorsqu'une mesure est souhaitée, réveillez l'appareil avec une commande de configuration dans les registres F2 (si nécessaire) et F4 qui définit les valeurs appropriées de osrs_h, osrs_t et osrs_p, plus mode=1 (mode monocoup). Par exemple:

[objectName.updateF2Control(1);] // osrs_h - jamais nécessaire pour BMP280, // et non nécessaire pour BME280 si le nombre de mesures n'est pas modifié // par rapport à la valeur fournie dans begin(). objectName.updateF4Control(1, 1, 1); // osrs_t, osrs_p, mode

Après avoir réveillé l'appareil, il commencera à mesurer, mais le résultat ne sera pas disponible pendant quelques millisecondes - au moins 4 ms, peut-être jusqu'à 70 ms ou plus, selon le nombre de mesures spécifiées. Si la commande de lecture est envoyée immédiatement, l'appareil renvoie les valeurs de la mesure précédente - ce qui peut être acceptable dans certaines applications, mais dans la plupart des cas, il est probablement préférable de retarder jusqu'à ce que la nouvelle mesure soit disponible.

Ce délai peut se faire de plusieurs manières.

1. attendre un laps de temps fixe pour couvrir le délai le plus long attendu
2. attendez un laps de temps calculé à partir du temps de mesure maximum par mesure (c'est-à-dire 2,3 ms) multiplié par le nombre de mesures, plus les frais généraux, plus une marge.
3. attendez un temps plus court calculé comme ci-dessus, mais en utilisant le temps de mesure nominal (c'est-à-dire 2 ms) plus le temps système, puis commencez à vérifier le bit "Je mesure" dans le registre d'état. Lorsque le bit d'état affiche 0 (c'est-à-dire qu'il ne mesure pas), obtenez les lectures de température et de pression.
4. commencez immédiatement à vérifier le registre d'état et obtenez les lectures de température et de pression lorsque le bit d'état indique 0,

Je montrerai un exemple d'une façon de le faire un peu plus tard.

Opérations de registre de configuration

Pour que tout cela se produise, nous avons besoin de plusieurs outils que je n'ai pas encore introduits. Elles sont:

octet readRegister(reg)

void updateRegister(reg, value)

Chacun d'eux a plusieurs commandes dérivées dans la bibliothèque, ce qui simplifie un peu le logiciel pour des actions spécifiques.

L'exemple powerSaverPressureAndTemperature.ino utilise la méthode n ° 3. La ligne de code qui effectue la vérification répétée est

while (bmp0.readRegister(0xF3)>>3); // boucle jusqu'à F3bit 3 ==0

Notez que ce croquis est pour un microcontrôleur ESP8266. J'ai utilisé un mini pro WeMos D1. L'esquisse ne fonctionnera pas avec les microcontrôleurs Atmega, qui ont des instructions différentes pour dormir. Cette esquisse exerce plusieurs autres commandes, je vais donc toutes les présenter avant de décrire cette esquisse plus en détail.

Lorsque le microcontrôleur dort en parallèle avec le capteur BMP280, la configuration du capteur pour les mesures souhaitées peut se faire dans la commande begin(), à l'aide des 6 paramètres. Cependant, si le microcontrôleur ne dort pas, mais que le capteur l'est, alors au moment de la mesure, le capteur doit être réveillé et informé de sa configuration de mesure. Cela peut être fait directement avec

updateRegister(reg, valeur)

mais c'est un peu plus facile avec les trois commandes suivantes:

updateF2Control(osrs_h); // BME280 uniquement

updateF4Control(osrs_t, osrs_p, mode); updateF5Config(t_sb, filtre, spi3W_en);

Une fois la mesure terminée, si le mode utilisé est Single shot (mode forcé), l'appareil se remettra automatiquement en veille. Cependant, si l'ensemble de mesures implique plusieurs mesures en mode continu (Normal), le BMP280 devra être remis en veille. Cela peut être fait avec l'une des deux commandes suivantes:

updateF4Control16xSleep();

updateF4ControlSleep(valeur);

Ces deux éléments définissent les bits de mode sur 00 (c'est-à-dire le mode veille). Cependant le premier met osrs_t et osrs_p à 111 (soit 16 mesures) tandis que le second stocke les 6 bits de poids faible de "value" dans les bits 7:2 du registre 0xF4.

De même, l'instruction suivante stocke les six bits de poids faible de "valeur" dans les bits 7:2 du registre 0xF5.

updateF5ConfigSleep(valeur);

L'utilisation de ces dernières commandes permet de stocker 12 bits d'information dans les registres F4 et F5 du BMP280. Au moins dans le cas de l'ESP8266, lorsque le microcontrôleur se réveille après une période de veille, il démarre au début de l'esquisse sans connaître son état avant la commande de veille. Pour stocker la connaissance de son état avant la commande de veille, les données peuvent être stockées dans la mémoire flash, en utilisant soit les fonctions EEPROM, soit en écrivant un fichier à l'aide de SPIFFS. Cependant la mémoire flash a une limitation du nombre de cycles d'écriture, de l'ordre de 10 000 à 100 000. Cela signifie que si le microcontrôleur passe par un cycle veille-sommeil toutes les quelques secondes, il peut dépasser la mémoire d'écriture autorisée. limite dans quelques mois. Le stockage de quelques bits de données dans le BMP280 n'a pas une telle limitation.

Les données stockées dans les registres F4 et F5 peuvent être récupérées lors du réveil du microcontrôleur à l'aide des commandes

readF4Sleep();

readF5Sleep();

Ces fonctions lisent le registre correspondant, décalent le contenu pour supprimer les 2 LSB et renvoient les 6 bits restants. Ces fonctions sont utilisées dans l'exemple d'esquisse powerSaverPressureAndTemperatureESP.ino comme suit:

// lit la valeur de EventCounter à partir de bmp0

octet bmp0F4value= bmp0.readF4Sleep(); // 0 à 63 octets bmp0F5value= bmp0.readF5Sleep(); // 0 à 63 eventCounter= bmp0F5value*64+bmp0F4value; // 0 à 4095

Ces fonctions lisent le registre correspondant, décalent le contenu pour supprimer les 2 LSB et renvoient les 6 bits restants. Ces fonctions sont utilisées dans l'exemple d'esquisse powerSaverPressureAndTemperature.ino comme suit:

// lit la valeur de EventCounter à partir de bmp1

octet bmp1F4value= bmp1.readF4Sleep(); // 0 à 63 octets bmp1F5value= bmp1.readF5Sleep(); // 0 à 63 eventCounter= bmp1F5value*64+bmp1F4value; // 0 à 4095

Fonctions température et pression brutes

Les fonctions de base readTemperature, readPressure et readHumidity ont deux composants. Tout d'abord, les valeurs brutes de température et de pression de 20 bits sont obtenues à partir du BME/P280, ou la valeur d'humidité brute de 16 bits est obtenue à partir du BME280. Ensuite, l'algorithme de compensation est utilisé pour générer les valeurs de sortie en degrés Celsius, hPa ou %RH.

La bibliothèque fournit des fonctions distinctes pour ces composants, de sorte que les données brutes de température, de pression et d'humidité puissent être obtenues et peut-être manipulées d'une manière ou d'une autre. L'algorithme pour dériver la température, la pression et l'humidité de ces valeurs brutes est également fourni. Dans la bibliothèque, ces algorithmes sont implémentés en utilisant une arithmétique à virgule flottante double longueur. Cela fonctionne bien sur l'ESP8266 qui est un processeur 32 bits et utilise 64 bits pour les variables flottantes "doubles". Rendre ces fonctions accessibles peut être utile pour évaluer et éventuellement modifier le calcul pour d'autres plateformes.

Ces fonctions sont:

readRawPressure (rawTemperature); // lit les données brutes de pression et de température de BME/P280readRawHumidity (rawTemperature, rawPressure); // lit les données brutes d'humidité, de température et de pression du BME280 calcTemperature (rawTemperature, t_fine); calcPressure (rawPressure, t_fine); calcHumidity (rawHumidity, t_fine)

L'argument "t-fin" de ces fonctions mérite quelques explications. Les algorithmes de compensation de pression et d'humidité incluent un composant dépendant de la température qui est obtenu grâce à la variable t_fine. La fonction calcTemperature écrit une valeur dans t_fine en fonction de la logique de l'algorithme de compensation de température, qui est ensuite utilisée comme entrée à la fois dans calcPressure et calcHumidity.

Un exemple d'utilisation de ces fonctions peut être trouvé dans l'exemple de croquis rawPressureAndTemperature.ino, ainsi que dans le code de la fonction readHumidity() dans le fichier.cpp de la bibliothèque.

Altitude et pression au niveau de la mer

Il existe une relation connue entre la pression atmosphérique et l'altitude. La météo influence également la pression. Lorsque les organismes météorologiques publient des informations sur la pression atmosphérique, ils l'ajustent généralement en fonction de l'altitude et la "carte synoptique" montre donc des isobares (lignes de pression constante) normalisées au niveau moyen de la mer. Il y a donc vraiment 3 valeurs dans cette relation, et en connaître deux permet de déduire la troisième. Les 3 valeurs sont:

• altitude au-dessus du niveau de la mer
• pression atmosphérique réelle à cette altitude
• pression atmosphérique équivalente au niveau de la mer (plus strictement, niveau moyen de la mer, car le niveau instantané de la mer change constamment)

Cette bibliothèque fournit deux fonctions pour cette relation, comme suit:

calcAltitude (pression, seaLevelhPa);

calcPression Normalisée (pression, altitude);

Il existe également une version simplifiée, qui suppose la pression standard au niveau de la mer de 1013,15 hPa.

calcAltitude (pression); // standard seaLevelPressure supposé

Étape 3: Détails du périphérique BMP280

Capacités matérielles

Le BMP280 dispose de 2 octets de données de configuration (aux adresses de registre 0xF4 et 0xF5) qui sont utilisés pour contrôler plusieurs options de mesure et de sortie de données. Il fournit également 2 bits d'informations d'état et 24 octets de paramètres d'étalonnage qui sont utilisés pour convertir les valeurs brutes de température et de pression en unités de température et de pression conventionnelles. Le BME280 a des données supplémentaires comme suit:

• 1 octet supplémentaire de données de configuration à l'adresse de registre 0xF2 utilisé pour contrôler plusieurs mesures d'humidité;
• 8 octets supplémentaires de paramètres d'étalonnage utilisés pour convertir la valeur d'humidité brute en pourcentage d'humidité relative.

Les registres de température, de pression et d'état du BME280 sont les mêmes que pour le BMP280, à quelques exceptions près:

• les bits "ID" du BME280 sont mis à 0x60, il peut donc être distingué du BMP280 qui peut être 0x56, 0x57 ou 0x58
• le contrôle du temps de repos (t_sb) est modifié de sorte que les deux temps longs dans le BMP280 (2000 ms et 4000 ms) sont remplacés dans le BME280 par des temps courts de 10 ms et 20 ms. Le temps de veille maximal dans le BME280 est de 1000 ms.
• Dans le BME280, les valeurs brutes de température et de pression sont toujours de 20 bits si un filtrage est appliqué. L'utilisation de valeurs de 16 à 19 bits est limitée aux cas sans filtrage (c'est-à-dire filtre=0).

La température et la pression sont chacune des valeurs de 20 bits, qui doivent être converties en température et pression conventionnelles via un algorithme assez complexe utilisant 3 paramètres d'étalonnage 16 bits pour la température et 9 paramètres d'étalonnage 16 bits plus la température pour la pression. La granulatité de la mesure de température est de 0,0003 degrés Celsius pour un changement de bit le moins significatif (lecture de 20 bits), augmentant jusqu'à 0,0046 degrés Celsius si la lecture de 16 bits est utilisée.

L'humidité est une valeur de 16 bits qui doit être convertie en humidité relative via un autre algorithme complexe utilisant 6 paramètres d'étalonnage qui sont un mélange de 8, 12 et 16 bits.

La fiche technique indique la précision absolue de la lecture de la température à +-0,5 C à 25 C et +-1 C sur la plage de 0 à 65 C.

La granularité de la mesure de pression est de 0,15 Pascals (soit 0,0015 hectoPascals) à une résolution de 20 bits, ou de 2,5 Pascals à une résolution de 16 bits. La valeur de la pression brute est affectée par la température, de sorte qu'autour de 25C, une augmentation de température de 1 degré C diminue la pression mesurée de 24 Pascals. La sensibilité à la température est prise en compte dans l'algorithme d'étalonnage, de sorte que les valeurs de pression fournies doivent être précises à différentes températures.

La fiche technique indique la précision absolue de la lecture de la pression à +-1 hPa pour des températures comprises entre 0 C et 65 C.

La précision de l'humidité est indiquée dans la fiche technique comme +-3% RH et +-1% hystérésis.

Comment ça fonctionne

Les 24 octets de données d'étalonnage de température et de pression, ainsi que dans le cas du BME280 les 8 octets de données d'étalonnage d'humidité, doivent être lus à partir de l'appareil et stockés dans des variables. Ces données sont programmées individuellement dans l'appareil en usine, de sorte que différents appareils ont des valeurs différentes - au moins pour certains des paramètres. Un BME/P280 peut être dans l'un des deux états. Dans un état, il mesure. Dans l'autre état, il attend (sommeil).

L'état dans lequel il se trouve peut être vérifié en regardant le bit 3 du registre 0xF3.

Les résultats de la mesure la plus récente peuvent être obtenus à tout moment en lisant la valeur de données correspondante, que l'appareil soit en veille ou en mesure.

Il existe également deux manières d'utiliser le BME/P280. L'un est le mode continu (appelé mode normal dans la fiche technique) qui alterne à plusieurs reprises entre les états de mesure et de veille. Dans ce mode, l'appareil effectue une série de mesures, puis se met en veille, puis se réveille pour une autre série de mesures, et ainsi de suite. Le nombre de mesures individuelles et la durée de la partie veille du cycle peuvent tous être contrôlés via les registres de configuration.

L'autre façon de faire fonctionner le BME/P280 est le mode Single Shot (appelé mode Forcé dans la fiche technique). Dans ce mode, l'appareil est réveillé du sommeil par une commande de mesure, il effectue une série de mesures, puis se rendort. Le nombre de mesures individuelles dans l'ensemble est contrôlé dans la commande de configuration qui réveille l'appareil.

Dans le BMP280, si une seule mesure est effectuée, les 16 bits les plus significatifs de la valeur sont renseignés et les quatre bits les moins significatifs de la lecture de la valeur sont tous des zéros. Le nombre de mesures peut être défini sur 1, 2, 4, 8 ou 16 et à mesure que le nombre de mesures augmente, le nombre de bits remplis de données augmente, de sorte qu'avec 16 mesures, tous les 20 bits sont remplis de données de mesure. La fiche technique qualifie ce processus de suréchantillonnage.

Dans le BME280, la même disposition s'applique tant que le résultat n'est pas filtré. Si le filtrage est utilisé, les valeurs sont toujours de 20 bits, quel que soit le nombre de mesures prises dans chaque cycle de mesure.

Chaque mesure individuelle prend environ 2 millisecondes (valeur typique; la valeur maximale est de 2,3 ms). Ajoutez à cela un temps système fixe d'environ 2 ms (généralement un peu moins) signifie qu'une séquence de mesure, qui peut comprendre de 1 à 32 mesures individuelles, peut durer de 4 ms à 66 ms.

La fiche technique fournit un ensemble de combinaisons recommandées de suréchantillonnage de température et de pression pour diverses applications.

Registres de contrôle de configuration

Les deux registres de contrôle de configuration du BMP280 se trouvent aux adresses de registre 0xF4 et 0xF5 et sont mappés sur 6 valeurs de contrôle de configuration individuelles. 0xF4 se compose de:

• 3 bits osrs_t (mesure la température 0, 1, 2, 4, 8 ou 16 fois);
• 3 bits osrs_p (mesure la pression 0, 1, 2, 4, 8 ou 16 fois); et
• Mode 2 bits (Veille, Forcé (c'est-à-dire Single Shot), Normal (c'est-à-dire continu).

0xF5 se compose de:

• 3 bits t_sb (temps de veille, 0,5 ms à 4000 ms);
• filtre 3 bits (voir ci-dessous); et
• 1 bit spiw_en qui sélectionne SPI ou I2C.

Le paramètre de filtre contrôle un type d'algorithme de décroissance exponentielle, ou filtre à réponse impulsionnelle infinie (IIR), appliqué aux valeurs brutes de mesure de pression et de température (mais pas aux valeurs d'humidité). L'équation est donnée dans la fiche technique. Une autre présentation est:

Valeur(n) = Valeur(n-1) * (K-1)/K + mesure(n) / K

où (n) indique la valeur de mesure et de sortie la plus récente; et K est le paramètre de filtre. Le paramètre de filtre K et peut être défini sur 1, 2, 4, 8 ou 16. Si K est défini sur 1, l'équation devient simplement Valeur(n) = mesure(n). Le codage du paramètre de filtre est:

• filtre = 000, K=1
• filtre = 001, K=2
• filtre = 010, K=4
• filtre = 011, K=8
• filtre = 1xx, K=16

Le BME 280 ajoute un registre de contrôle de configuration supplémentaire à l'adresse 0xF2, "ctrl_hum" avec un seul paramètre de 3 bits osrs_h (mesure l'humidité 0, 1, 2, 4, 8 ou 16 fois).

Étape 4: Mesure et synchronisation de lecture

Je prévois d'ajouter ceci plus tard, montrant le timing des commandes et des réponses de mesure.

Iddt - courant à la mesure de la température. Valeur typique 325 uA

Iddp - courant à la mesure de la pression. Valeur typique 720 uA, max 1120 uA

Iddsb - courant en mode veille. Valeur typique 0,2 uA, max 0,5 uA

Iddsl - actuel en mode veille. Valeur typique 0,1 uA, max 0,3 uA

Étape 5: Directives relatives au logiciel

Mode rafale I2C

La fiche technique du BMP280 fournit des conseils sur la lecture des données (section 3.9). Il dit "il est fortement recommandé d'utiliser une lecture en rafale et de ne pas adresser chaque registre individuellement. Cela évitera une éventuelle confusion d'octets appartenant à différentes mesures et réduira le trafic d'interface." Aucune indication n'est donnée concernant la lecture des paramètres de compensation/étalonnage. Vraisemblablement, ce ne sont pas un problème car ils sont statiques et ne changent pas.

Cette bibliothèque lit toutes les valeurs contiguës en une seule opération de lecture - 24 octets pour les paramètres de compensation de température et de pression, 6 octets pour la température et la pression combinées et 8 octets pour l'humidité, la température et la pression combinées. Lorsque la température seule est vérifiée, seuls 3 octets sont lus.

Utilisation de macros (#define etc.)

Il n'y a pas de macros dans cette bibliothèque autre que la macro habituelle "include guard" de la bibliothèque qui empêche la duplication.

Toutes les constantes sont définies à l'aide du mot-clé const et l'impression de débogage est contrôlée avec des fonctions C standard.

Cela a été la source d'une certaine incertitude pour moi, mais le conseil que je reçois en lisant de nombreux articles sur ce sujet est que l'utilisation de #define pour la déclaration de constantes (au moins) et (probablement) le contrôle d'impression de débogage est inutile et indésirable.

Le cas de l'utilisation de const plutôt que de #define est assez clair - const utilise les mêmes ressources que #define (c'est-à-dire nil) et les valeurs résultantes suivent les règles de portée, réduisant ainsi les risques d'erreurs.

Le cas du contrôle d'impression de débogage est un peu moins clair, car la façon dont je l'ai fait signifie que le code final contient la logique des instructions d'impression de débogage, même si elles ne sont jamais exercées. Si la bibliothèque doit être utilisée dans un grand projet sur un microcontrôleur avec une mémoire très limitée, cela peut devenir un problème. Étant donné que mon développement était sur un ESP8266 avec une grande mémoire flash, cela ne semblait pas être un problème pour moi.

Étape 6: Performances de température

Je prévois d'ajouter ceci plus tard.

Étape 7: Performances de pression

Je prévois d'ajouter ceci plus tard.