Pilote logiciel (Driver) d'un composant BME280 pour Pico
Le composant BME280 est très utile pour des mesures de météorologie. Ce petit pilote permet son intégration simple dans un programme.
Installation
Commencez par télécharger le fichier suivant : Driver_DS3231.tar.gz
Copier le fichier téléchargé vers le répertoire "/home/pi" puis extraire ce fichier. L'extraction créera un répertoire nommé "Driver_BME280" :
tar zxvf Driver_BME280.tar.gz
Le répertoire "Driver_BME280" contiendra la code source sous la forme d'un fichier d'entête et d'un fichier source nommés "bme280.h" et "bme280.cpp". Il contient également un fichier nommé "CMakeLists.txt" et un programme d'exemple "pico_bme280.cpp".
Si vous souhaitez modifier le code source, je vous conseille de créer un autre répertoire et d'y copier le contenu du répertoire "/home/pi/Driver_BME280" vers un autre répertoire. Cela vous évitera de "polluer" le répertoire "/home/pi/Driver_BME280" et de conserver une version d'origine du code source.
Utilisation
Classe CBME280
Le pilote logiciel BME280 est implémentée sous la forme d'une classe nommée CBME280. Cette classe est classique et son utilisation est standard :
pBME = new CBME280(i2c0);
Avant de faire des mesures
Avant de faire des mesures il est, au minimum nécessaire d'initialiser le composant et de configurer ses paramètres de mesures. L'initialisation se fait via la méthode initialize. Cette méthode vérifie que le BME280 est bien accessible et que le composant à l'adresse d'un BME280 est bien un BME280. Ensuite elle vient lire les constantes de calibration stockées dans les registres du composant. En cas de succès elle retourne true, sinon elle retourne false.
La configuration se fait via la méthode configure. Cette dernièrre applique les paramètres de mesures : nombre de conversions par mesure pour chaque type de mesures (oversampling), et pour le mode normal (voir les rubriques : Stratégies de mesures et Mode de mesure normal (Cyclique)) le délai entre chaque mesure et le poids du filtre intégrateur (filtre IIR).
Ci dessous un exemple typique d'initialisation et de configuration :
pBME = new CBME280(i2c0);
if(!pBME280->initialize())
{
#ifdef DEBUG_MODE
printf("Error while initializing the BME280 !\n");
#endif
}
pBME280->configure(BME280_TEMP_OVERSAMPLING_8, BME280_PRESS_OVERSAMPLING_4, BME280_HUM_OVERSAMPLING_4);
Stratégies de mesures
Le BME280 propose deux stratégies permettant de faire des mesures de température, pression atmosphérique et humidité relative. La première stratégie, nommée mode normal (cyclique), effectue des mesures de manière continue. Une fois mis en service par la méthode start, on peut lire les mesures à tout instant, on lira toujours la dernière mesure disponible, quel que soit le moment précdent à auquel elle a été effectuée. Pour des mesures simples de météorologie, c'est une stratégie parfaitement adaptée, étant donné que les variations de température, pression et humidité sont relativement lentes. Voir le paragraphe Mode de mesure normal (Cyclique).
La seonde stratégie consiste à utiliser le mode forçé. Dans ce mode, on déclenche une mesure unique via la méthode trigger. Après un délai, on peut alors lire les résultats. Ce délai dépend principalement des paramètres d'oversampling passés à la méthode configure. Cette stratégie est à privilégier lorsque l'on souhaite synchroniser les prises de mesure à un autre évènement de l'application. A titre d'exemple, on pourrai décider de synchroniser les mesures sur la modification d'une entrée numérique. C'est cependant, une stratégie rarement utile.
Les deux paragraphe suivants détaillent la mise en service de ces deux stratégies.
Mode de mesure normal (Cyclique)
Après initialisation via la méthode initialize et configuration via la méthode configure on met en service ce mode via la méthode start. On le stoppe via la méthode stop.
A partir du moment ou ce mode est actif, on peut venir lire les mesures à n'importe quel moment, via, par exemple, la méthode read. Les mesures retournées seront toujours les dernières disponibles.
Ci dessous un exemple typique d'utilisation du mode normal :
pBME = new CBME280(i2c0);
if(!pBME280->initialize())
{
#ifdef DEBUG_MODE
printf("Error while initializing the BME280 !\n");
#endif
}
pBME280->configure(BME280_TEMP_OVERSAMPLING_8, BME280_PRESS_OVERSAMPLING_4, BME280_HUM_OVERSAMPLING_4);
if(!pBME280->start())
{
#ifdef DEBUG_MODE
printf("Error while starting measurements on the BME280 !\n");
#endif
}
while(true)
{
sleep_ms(1000);
if(!pBME280->read())
{
#ifdef DEBUG_MODE
printf("Error while reading measurements from the BME280 !\n");
#endif
}
else
{
printf("\033[2J");
printf("- Temperature : %.2f °\n", pBME280->temperature());
printf("- Pressure : %.2f mb\n", pBME280->pressure());
printf("- Humidity : %.2f%% hr\n", pBME280->humidity());
}
}
Mode de mesure forçé
Après initialisation via la méthode initialize et configuration via la méthode configure on déclenche une mesure via la méthode trigger. On peut venir lire les mesures après un délai d'attente, via, par exemple, la méthode read.
Ci dessous un exemple typique d'utilisation du mode forçé :
pBME = new CBME280(i2c0);
if(!pBME280->initialize())
{
#ifdef DEBUG_MODE
printf("Error while initializing the BME280 !\n");
#endif
}
pBME280->configure(BME280_TEMP_OVERSAMPLING_8, BME280_PRESS_OVERSAMPLING_4, BME280_HUM_OVERSAMPLING_4, BME280_STANDBY_DELAY_250MS, BME280_IIR_FILTER_WEIGHT_OFF);
while(true)
{
if(!pBME280->trigger())
{
#ifdef DEBUG_MODE
printf("Error while starting measurements on the BME280 !\n");
#endif
}
sleep_ms(3000);
if(!pBME280->read())
{
#ifdef DEBUG_MODE
printf("Error while reading measurements from the BME280 !\n");
#endif
}
else
{
printf("\033[2J");
printf("- Temperature : %.2f °\n", pBME280->temperature());
printf("- Pressure : %.2f mb\n", pBME280->pressure());
printf("- Humidity : %.2f%% hr\n", pBME280->humidity());
}
}
Lecture des mesures
La manière la plus simple pour lire les mesures effectuées consiste à utiliser la méthode read. Si vous lui passez des pointeurs vers des double, ceux-ci seront remplis avec les mesures relevées, si vous ne passez pas ces pointerus les mesures relevées seont diponibles via les méthodes temperature, pressure et humidity.
Il est également possible de ne relever que certaines mesures. A titre d'exemple, pour ne relever que la mesure de tenéprature, vous pouvez utiliser la méthode readRawTemperature suivie de la méthode toTemperature.
Types
Le pilote BME280 définie les types suivants :
Adresse I2C possibles pour ce composant
{
BME280_I2C_ADDRESS_0X76 = 0x76,
BME280_I2C_ADDRESS_0X77 = 0x77,
} BME280_I2C_ADDRESS;
Définie les valeurs d'oversampling en mesure de pression d'un composant BME-280.
Plus la valeur est élevée, meilleure est la résolution.
{
BME280_PRESS_OVERSAMPLING_1 = 0x04,
BME280_PRESS_OVERSAMPLING_2 = 0x08,
BME280_PRESS_OVERSAMPLING_4 = 0x0C,
BME280_PRESS_OVERSAMPLING_8 = 0x10,
BME280_PRESS_OVERSAMPLING_16 = 0x14,
} BME280_PRESS_OVERSAMPLING;
Définie les valeurs d'oversampling en mesure de température d'un composant BME-280.
Plus la valeur est élevée, meilleure est la résolution.
{
BME280_TEMP_OVERSAMPLING_1 = 0x20,
BME280_TEMP_OVERSAMPLING_2 = 0x40,
BME280_TEMP_OVERSAMPLING_4 = 0x60,
BME280_TEMP_OVERSAMPLING_8 = 0x80,
BME280_TEMP_OVERSAMPLING_16 = 0xA0,
} BME280_TEMP_OVERSAMPLING;
Définie les valeurs d'oversampling en mesure d'humidité d'un composant BME-280.
Plus la valeur est élevée, meilleure est la résolution.
{
BME280_HUM_OVERSAMPLING_1 = 0x01,
BME280_HUM_OVERSAMPLING_2 = 0x02,
BME280_HUM_OVERSAMPLING_4 = 0x03,
BME280_HUM_OVERSAMPLING_8 = 0x04,
BME280_HUM_OVERSAMPLING_16 = 0x05,
} BME280_HUM_OVERSAMPLING;
Définie les valeurs d'attente entre les mesures en mode normal cyclique.
Inutile en mode forcé.
{
BME280_STANDBY_DELAY_500US = 0x00,
BME280_STANDBY_DELAY_62_5MS = 0x20,
BME280_STANDBY_DELAY_125MS = 0x40,
BME280_STANDBY_DELAY_250MS = 0x60,
BME280_STANDBY_DELAY_500MS = 0x80,
BME280_STANDBY_DELAY_1S = 0xA0,
BME280_STANDBY_DELAY_10MS = 0xC0,
BME280_STANDBY_DELAY_20MS = 0xE0,
} BME280_STANDBY_DELAY;
Définie les valeurs de filtrage IIR en mode normal cyclique.
Inutile en mode forcé.
{
BME280_IIR_FILTER_WEIGHT_OFF = 0x00,
BME280_IIR_FILTER_WEIGHT_2 = 0x04,
BME280_IIR_FILTER_WEIGHT_4 = 0x08,
BME280_IIR_FILTER_WEIGHT_8 = 0x0C,
BME280_IIR_FILTER_WEIGHT_16 = 0x10,
} BME280_IIR_FILTER_WEIGHT;
Constructeur
| CBME280(i2c_inst_t* pI2c, const BME280_I2C_ADDRESS& eBME280I2CAddress) |
Méthodes publiques génériques
| bool | initialize() |
| void | configure(const BME280_TEMP_OVERSAMPLING& eTempOverSampling = BME280_TEMP_OVERSAMPLING_4, const BME280_PRESS_OVERSAMPLING& ePressOverSampling = BME280_PRESS_OVERSAMPLING_4, const BME280_HUM_OVERSAMPLING& eHumOverSampling = BME280_HUM_OVERSAMPLING_4, const BME280_STANDBY_DELAY& eStandbyDelay = BME280_STANDBY_DELAY_500MS, const BME280_IIR_FILTER_WEIGHT& eIIRFilterWeight = BME280_IIR_FILTER_WEIGHT_OFF) |
| bool | reset() |
| bool | check(bool* pTFCheck) |
| bool | readCalibrationConstants() |
Méthodes publiques de mise en service des mesures
| bool | trigger() |
| bool | start() |
| bool | stop() |
Méthodes publiques de lecture
| bool | read(double* pdTemperature = nullptr, double* pdPressure = nullptr, double* pdHumidity = nullptr) |
| bool | readRaw(uint32_t* punRawTemperature = nullptr, uint32_t* punRawPressure = nullptr, uint32_t* punRawHumidity = nullptr) |
| bool | readRawTemperature(uint32_t* punRawTemperature = nullptr) |
| bool | readRawPressure(uint32_t* punRawPressure = nullptr) |
| bool | readRawHumidity(uint32_t* punRawHumidity = nullptr) |
| void | linearize(double* pdTemperature = nullptr, double* pdPressure = nullptr, double* pdHumidity = nullptr) |
| double | toTemperature(const uint32_t& unRawTemp) |
| double | toPressure(const uint32_t& unRawPres) |
| double | toHumidity(const uint32_t& unRawHum) |
| uint32_t | rawTemperature() |
| uint32_t | rawPressure() |
| uint32_t | rawHumidity() |
| double | temperature() |
| double | pressure() |
| double | humidity() |
Détails des Méthodes
Constructeur
Description : Constructeur d'une instance de la classe CBME280.
Paramètre : pI2c - type i2c_inst_t* - Identificateur du bus I2C auquel est reliée le composant BME280.
Paramètre : eBME280I2CAddress - type const BME280_I2C_ADDRESS& - Adresse duc omposant BME280 sur le vus I2C.
Méthodes publiques génériques
Description : Initialise l'objet. Cette méthode doit être appelée avant toute autre méthode de la classe (Exception faite des méthodes check et reset). Cette méthode initialise les membres internes, véréifie la présence du BME280 et lit ses constantes de calibration.
Valeur de retour : Booléen indiquant le succès ou l'echec de la méthode.
Description : Réinitialise le BME280 à son état lors de sa mise sous tension.
Valeur de retour : Booléen indiquant le succès ou l'echec de la méthode.
Description : Vérifie que le périphérique est bien un BME280.
Paramètre : pTFCheck - type bool* - Ce pointeur prend la valeur true ou false en sortie de la fonction pour indiquer que le composant est un BME280 ou non.
Valeur de retour : Booléen indiquant le succès ou l'echec de la méthode.
Description : Méthode permettant de lire les constantes de calibration du BME280. Cette méthode est appelée par la méthode initialize.
Valeur de retour : Booléen indiquant le succès ou l'echec de la méthode.
Description : Cette méthode reçoit les paramètres de mesure. Elle n'accès pas au composant. LEs paramètres spécifiés seront utilisés par la suite lors de l'utilisation des méthodes start ou trigger. Les paramètres "eStandbyDelay" et "eIIRFilterWeight" ne concernent que la stratégie de mesure normale (cyclique) mise en oeuvre par la méthode start. Lors de l'utilisation de la stratégie en mode forcé, ils ne sont pas utilisés et peuvent être laissés à leurs valerus par défaut.
Paramètre : eTempOverSampling - const BME280_TEMP_OVERSAMPLING& - Nombre de mesures de température moyennées pendant un cycle de mesure pour calculer la température finale. Plus la valeur est grande, plus la mesure est précise, mais plus la mesure est longue à être effectuée.
Paramètre : ePressOverSampling - const BME280_PRESS_OVERSAMPLING& - Nombre de mesures de pression moyennées pendant un cycle de mesure pour calculer la pression finale. Plus la valeur est grande, plus la mesure est précise, mais plus la mesure est longue à être effectuée.
Paramètre : eHumOverSampling - const BME280_HUM_OVERSAMPLING& - Nombre de mesures d'humidité moyennées pendant un cycle de mesure pour calculer l'humidité finale. Plus la valeur est grande, plus la mesure est précise, mais plus la mesure est longue à être effectuée.
Paramètre : eStandbyDelay - const BME280_STANDBY_DELAY& - Délai imposée entre chaque mesure en mode normal (cyclique). Globalement équivalent à une période de mesure sur un convertisseur analogique digital.
Paramètre : eIIRFilterWeight - const BME280_IIR_FILTER_WEIGHT& - Poids du filtre IIR en mode normal (cyclique).
Méthodes publiques de mise en service des mesures
Description : Mise en service du mode normal (cyclique). Voir les paragraphes Stratégies de mesure et Mode de mesure normal (cyclique).
Valeur de retour : Booléen indiquant le succès ou l'echec de la méthode.
Description : Arrêt du mode normal (cyclique). Voir les paragraphes Stratégies de mesure et Mode de mesure normal (cyclique).
Valeur de retour : Booléen indiquant le succès ou l'echec de la méthode.
Description : Décvlenche une mesure en mode forcé. Voir les paragraphes Stratégies de mesure et Mode de mesure forçé.
Valeur de retour : Booléen indiquant le succès ou l'echec de la méthode.
Méthodes publiques de lecture
Description : A la suite de l'utilisation des méthodes start ou trigger, les mesures effectuées et exprimées en grandeurs physiques peuvent être lues par cette méthode.
Cette méthode met à jour les variables internes qui peuvent ensuite être lues via les méthodes temperature, pressure et humidity. En plus de mettre à jour ces variables, la méthode reçoit 3 pointeurs qui, s'ils ne sont pas nul (nullptr), reçoivent également les valeurs de mesures relevées exprimées en grandeurs physiques.
- La température est exprimée en degrés Celsius (°C).
- La pression est exprimée en degrés millibars (mb).
- L'humidité est exprimée en pourcent d'humidité relative (%HR).
Paramètre : pdTemperature - type double* - Si non nul, reçoit la valeur de température en sortie de la méthode.
Paramètre : pdPressure - type double* - Si non nul, reçoit la valeur de pression en sortie de la méthode.
Paramètre : pdHumidity - type double* - Si non nul, reçoit la valeur d'humidité en sortie de la méthode.
Valeur de retour : Booléen indiquant le succès ou l'echec de la méthode.
Description : A la suite de l'utilisation des méthodes start ou trigger, les mesures brutes (telles qu'issues du convertisseur analogique) physiques peuvent être lues par cette méthode.
Cette méthode met à jour les variables internes qui peuvent ensuite être lues via les méthodes rawTemperature, rawPressure et rawHumidity. En plus de mettre à jour ces variables, la méthode reçoit 3 pointeurs qui, s'ils ne sont pas nul (nullptr), reçoivent également les valeurs de mesures brutes.
Cette méthode est appelée en interne par la méthode read.
Paramètre : punRawTemperature - type uint32_t* - Si non nul, reçoit la valeur de température en sortie de la méthode.
Paramètre : punRawPressure - type uint32_t* - Si non nul, reçoit la valeur de pression en sortie de la méthode.
Paramètre : punRawHumidity - type uint32_t* - Si non nul, reçoit la valeur d'humidité en sortie de la méthode.
Valeur de retour : Booléen indiquant le succès ou l'echec de la méthode.
Description : A la suite de l'utilisation des méthodes start ou trigger, les mesures brutes de température (telles qu'issues du convertisseur analogique) physiques peuvent être lues par cette méthode.
Cette méthode met à jour la variable interne qui peut ensuite être lue via la méthodes rawTemperature. En plus de mettre à jour cette variable, la méthode reçoit 1 pointeur qui, s'ils n'est pas nul (nullptr), reçoit également la valeur de mesure brute.
Cette méthode est appelée en interne par la méthode readRaw.
Paramètre : punRawTemperature - type uint32_t* - Si non nul, reçoit la valeur de température en sortie de la méthode.
Valeur de retour : Booléen indiquant le succès ou l'echec de la méthode.
Description : A la suite de l'utilisation des méthodes start ou trigger, les mesures brutes de pression (telles qu'issues du convertisseur analogique) physiques peuvent être lues par cette méthode.
Cette méthode met à jour la variable interne qui peut ensuite être lue via la méthodes rawPressure. En plus de mettre à jour cette variable, la méthode reçoit 1 pointeur qui, s'ils n'est pas nul (nullptr), reçoit également la valeur de mesure brute.
Cette méthode est appelée en interne par la méthode readRaw.
Paramètre : punRawPressure - type uint32_t* - Si non nul, reçoit la valeur de pression en sortie de la méthode.
Valeur de retour : Booléen indiquant le succès ou l'echec de la méthode.
Description : A la suite de l'utilisation des méthodes start ou trigger, les mesures brutes d'humidité (telles qu'issues du convertisseur analogique) physiques peuvent être lues par cette méthode.
Cette méthode met à jour la variable interne qui peut ensuite être lue via la méthodes rawHumidity. En plus de mettre à jour cette variable, la méthode reçoit 1 pointeur qui, s'ils n'est pas nul (nullptr), reçoit également la valeur de mesure brute.
Cette méthode est appelée en interne par la méthode readRaw.
Paramètre : punRawHumidity - type uint32_t* - Si non nul, reçoit la valeur d'humidité en sortie de la méthode.
Valeur de retour : Booléen indiquant le succès ou l'echec de la méthode.
Description : A la suite de l'utilisation de la méthode readRaw ou trigger, cette méthode permet de calculer les valeurs finales exprimées en grandeurs physisque.
Cette méthode met à jour les variables internes qui peuvent ensuite être lues via les méthodes temperature, pressure et humidity. En plus de mettre à jour ces variables, la méthode reçoit 3 pointeurs qui, s'ils ne sont pas nul (nullptr), reçoivent également les valeurs de mesures relevées exprimées en grandeurs physiques.
Cette méthode est appelée en interne par la méthode read.
- La température est exprimée en degrés Celsius (°C).
- La pression est exprimée en degrés millibars (mb).
- L'humidité est exprimée en pourcent d'humidité relative (%HR).
Paramètre : pdTemperature - type double* - Si non nul, reçoit la valeur de température en sortie de la méthode.
Paramètre : pdPressure - type double* - Si non nul, reçoit la valeur de pression en sortie de la méthode.
Paramètre : pdHumidity - type double* - Si non nul, reçoit la valeur d'humidité en sortie de la méthode.
Valeur de retour : Booléen indiquant le succès ou l'echec de la méthode.
Description : Cette méthode permet de convertir une mesure de température exprimée en valeur brute issue du convertisseur analogique en grandeur physique exprimée en degré Celsius (°C).
Paramètre : unRawTemp - type const uint32_t& - Mesure de température brute.
Valeur de retour : valeur double exprimée en grandeur physique.
Description : Cette méthode permet de convertir une mesure de pression exprimée en valeur brute issue du convertisseur analogique en grandeur physique exprimée en millibars (mb).
Paramètre : unRawPress - type const uint32_t& - Mesure de pression brute.
Valeur de retour : valeur double exprimée en grandeur physique.
Description : Cette méthode permet de convertir une mesure d'humidité exprimée en valeur brute issue du convertisseur analogique en grandeur physique exprimée en pourcent d'humidité relative (%HR).
Paramètre : unRawHum - type const uint32_t& - Mesure d'humidité brute.
Valeur de retour : valeur double exprimée en grandeur physique.
Description : Retourne la dernière mesure de température en valeur brute issue du convertisseur.
Valeur de retour : Mesure brute.
Description : Retourne la dernière mesure de pression en valeur brute issue du convertisseur.
Valeur de retour : Mesure brute.
Description : Retourne la dernière mesure d'humidité en valeur brute issue du convertisseur.
Valeur de retour : Mesure brute.
Description : Retourne la dernière mesure de température en degrés Celsius (°C).
Valeur de retour : Mesure en grandeur physique.
Description : Retourne la dernière mesure de pressions en millibars (mb).
Valeur de retour : Mesure en grandeur physique.
Description : Retourne la dernière mesure d'humidité en pourcent d'humidité relative (%HR).
Valeur de retour : Mesure en grandeur physique.