Tutoriel - Bibliothèque STM32_BME680

Interface pour communiquer avec le capteur environnemental BME680 (Température, Humidité, Pression, Gaz/QAI).

Consultez la librairie sur GitHub.

Table des matières

1. Introduction au BME680

Le BME680 de Bosch Sensortec est un capteur environnemental numérique polyvalent qui combine plusieurs fonctions de mesure en un seul boîtier compact. Il est capable de mesurer :

  • Température ambiante
  • Humidité relative
  • Pression barométrique
  • Gaz Organiques Volatils (COV) / Qualité de l'Air Intérieur (QAI) via un capteur de gaz à oxyde métallique (MOX).

Il communique typiquement via I2C (utilisé par cette librairie) ou SPI et est conçu pour des applications à faible consommation.

2. Introduction à la Librairie STM32_BME680

La librairie STM32_BME680 a pour but de simplifier l'intégration et l'utilisation du capteur BME680 avec les microcontrôleurs STM32, en s'appuyant sur la couche d'abstraction matérielle (HAL) de STM32Cube. Elle encapsule l'API officielle de Bosch et l'adapte pour l'écosystème STM32.

Fonctionnalités principales :

  • Initialisation et configuration simplifiées.
  • Lecture des données de température, humidité, pression et résistance du gaz.
  • Fonctions d'assistance pour estimer un indice de qualité de l'air (QAI).
  • Gestion des modes d'alimentation (veille et forcé).

3. Compatibilité et Prérequis

Compatibilité Matérielle

  • Toutes les familles de microcontrôleurs STM32 supportant HAL et disposant d'un périphérique I2C.
  • Capteur BME680.

Prérequis Logiciels

  • Un microcontrôleur STM32.
  • STM32CubeIDE.
  • Le bus I2C sur lequel se troue votre capteur doit être configuré et initialisé dans votre projet.
  • La librairie HAL STM32_BME680 présente dans le répertoire STM32_Libraries.

4. Fichiers de la librairie

La librairie est composée de trois fichiers principaux :

  • STM32_BME680.h : Fichier d'en-tête exposant l'API publique de la librairie (fonctions de haut niveau, structures de données utilisateur).
  • STM32_BME680.c : Fichier source contenant l'implémentation des fonctions de STM32_BME680.h, y compris les wrappers I2C et délai spécifiques à STM32.
  • STM32_BME680_defs.h : Fichier d'en-tête contenant les définitions de bas niveau de l'API Bosch (adresses de registres, constantes, structures de données du capteur, etc.).

N'oubliez pas de vérifier et adapter si besoin l'inclusion du fichier HAL principal dans STM32_BME680.h : #include "stm32l0xx_hal.h" // Remplacez stm32l0xx_hal.h par ex: stm32f4xx_hal.h si vous utilisez une autre série.

5. Installation et Intégration

  1. Créez un dossier nommé STM32_BME680 (par exemple dans le répertoire Drivers de votre projet STM32) et copiez-y les trois fichiers STM32_BME680.h, STM32_BME680.c et STM32_BME680_defs.h.
  2. Ajoutez les chemins d'inclusion : dans les propriétés de votre projet STM32CubeIDE, allez dans "C/C++ General" > "Paths and Symbols" > Onglet "Includes". Dans la section "GNU C", ajoutez le chemin vers le dossier où vous avez placé les fichiers de la librairie (ex: Drivers/STM32_BME680).

N'oubliez pas d'activer le support des nombres flottants dans les propriétés du projet si vous souhaitez utiliser printf pour afficher des valeurs flottantes (température, humidité, etc.).

6. Utilisation simple sans qualité de l'air (QAI)

Voici les étapes pour intégrer et utiliser la librairie BME680 dans votre projet STM32 (typiquement dans main.c).

6.1 Inclusion

Incluez le fichier d'en-tête principal de la librairie dans la section USER CODE BEGIN Includes :


/* USER CODE BEGIN Includes */
#include <stdio.h>  // Pour utiliser printf
#include "STM32_BME680.h" // pour utiliser la librairie BME680
/* USER CODE END Includes */

6.2 Variable globale

Déclarez les variables globales dans la section USER CODE BEGIN PV :


/* USER CODE BEGIN PV */
struct bme680_dev gas_sensor;  // Structure pour le capteur BME680
struct bme680_field_data data; // Structure pour stocker les données de mesure
/* USER CODE END PV */

6.3 Redirection de printf

Pour afficher les résultats sur un terminal série (par exemple, via UART pour les messages d'initialisation ou les données simples), vous devez rediriger la sortie de printf. Voici un exemple pour l'UART2 dans la section USER CODE BEGIN 0 : 


/* USER CODE BEGIN 0 */
// Fonction de redirection de printf vers UART2
int __io_putchar(int ch)
{
    HAL_UART_Transmit(&huart2, (uint8_t *)&ch, 1, 0xFFFF); // Pour Envoyer le caractère via UART
    // ITM_SendChar(ch); // Option alternative pour envoyer le caractère via ITM
    return ch;
}
/* USER CODE END 0 */

6.4 initialisation

Configurez les paramètres d'initialisation dans la section USER CODE BEGIN 2 :


/* USER CODE BEGIN 2 */
HAL_Delay(250); // Attendre 250 ms pour permettre au système de se stabiliser
printf("Initialisation du BME680 avec les paramètres par défaut...\r\n");

int8_t status = BME680_OK; // Initialiser le statut à OK

// Initialiser le capteur BME680 avec la structure de périphérique, le gestionnaire I2C et les paramètres par défaut
status = BME680_Start(&gas_sensor, &hi2c1, NULL);
if (status == BME680_OK) // Vérifier si l'initialisation a réussi
{
    printf("BME680 initialisé avec succès !\r\n");
}
else // Si l'initialisation échoue, afficher le statut
{
    printf("Échec de l'initialisation du BME680 ! Statut : %d\r\n", status);
    Error_Handler();
}

// Configurer les paramètres de mesure
uint16_t meas_period; // Durée de mesure
bme680_get_profile_dur(&meas_period, &gas_sensor); // Calculer la durée de mesure
printf("Durée de mesure : %d ms\r\n", meas_period); // Afficher la durée de mesure
/* USER CODE END 2 */

6.5 Lecture des mesures

Pour lire les données (température, humidité, pression) en mode forcé, placez le code suivant dans la boucle while(1) (section USER CODE BEGIN WHILE) : 


/* USER CODE BEGIN WHILE */
while (1)
{
    status = bme680_set_sensor_mode(&gas_sensor); // Passer le capteur en mode forcé
    if (status != BME680_OK) // Si le passage en mode forcé a échoué
    {
        printf("Échec du passage du capteur en mode forcé, statut : %d\r\n", status);
        // Continuer pour voir si la lecture fonctionne quand même, mais c'est peu probable.
    }

    // Attendre que la mesure soit complète
    HAL_Delay(meas_period + 20); // meas_period est calculé par bme680_get_profile_dur

    // Lire les données
    status = bme680_get_sensor_data(&data, &gas_sensor); // Lire les données du capteur
    if (status == BME680_OK) // Si la lecture à réussie
    {
        // Afficher les données de température, pression et humidité
        printf("Température : %.2f C, Pression : %.2f hPa, Humidité : %.2f %%\r\n",
        data.temperature,
        data.pressure / 100.0f, // Conversion Pa vers hPa pour l'affichage
        data.humidity);
        // Si data.status est OK & BME680_NEW_DATA_MSK est faux, les données ne sont pas nouvelles.
        // Si data.status est OK & BME680_GASM_VALID_MSK est faux (pour le gaz) ou si d'autres bits d'erreur sont présents.
        // Pour TPH, BME680_NEW_DATA_MSK est le principal indicateur.
        if (!(data.status & BME680_NEW_DATA_MSK)) // Si les données ne sont pas nouvelles
        {
            printf("Avertissement : Les données pourraient ne pas être nouvelles ou valides. Statut : 0x%X\r\n", data.status);
        }
    }
    else // Si la lecture échoue
    {
        printf("Échec de la lecture des données du capteur, statut : %d\r\n", status);
    }
    HAL_Delay(1000); // Attendre 1 seconde avant le début de la prochaine mesure
    /* USER CODE END WHILE */

7. Utilisation avec qualité de l'air (QAI)

La librairie inclut des fonctions pour estimer un indice de QAI. Cet indice est basé sur les variations de la résistance du capteur de gaz, compensées par l'humidité.

  1. Initialisation du tracker QAI: Appelez initIAQTracker(&iaq_tracker, burn_in_cycles, humidity_slope); après avoir initialisé le BME680.
    • burn_in_cycles: Nombre de mesures pour stabiliser la ligne de base du gaz (ex: 300 pour 5 minutes si 1 mesure/sec).
    • humidity_slope: Pente pour la compensation d'humidité (valeur typique entre 0.01 et 0.09, à ajuster).
  2. Obtention de la QAI: Après chaque lecture de données du BME680, passez les valeurs (température, humidité, résistance du gaz) à la fonction getIAQ(&iaq_tracker, bme_data_for_iaq).
  3. Interprétation: La fonction getIAQCategory(iaq_value) convertit la valeur numérique de QAI (0-100) en une catégorie textuelle (Excellent, Bon, etc.). Pendant la période de "burn-in", getIAQ retourne NAN.

Voici les étapes pour intégrer et utiliser la librairie BME680 dans votre projet STM32 (typiquement dans main.c).

7.1 Inclusion

Incluez le fichier d'en-tête principal de la librairie dans la section USER CODE BEGIN Includes de votre main.c :


/* USER CODE BEGIN Includes */
#include <stdio.h>    // Pour utiliser printf
#include "STM32_BME680.h"   // pour utiliser la librairie BME680
/* USER CODE END Includes */

7.2 Variable globale

Déclarez les variables globales dans la section USER CODE BEGIN PV de votre main.c :


        /* USER CODE BEGIN PV */
        struct bme680_dev gas_sensor;               // Instance principale du capteur
        BME680_InitialSettings initial_settings;    // Paramètres d'initialisation
        IAQTracker iaq_tracker;                     // Optionnel, pour la QAI
        /* USER CODE END PV */

7.3 Redirection de printf

Pour afficher les résultats sur un terminal série (ex: via UART), vous devez rediriger la sortie de printf. Voici un exemple pour l'UART2 dans la section USER CODE BEGIN 0 : 


/* USER CODE BEGIN 0 */
// Fonction de redirection de printf vers UART2
int __io_putchar(int ch) {
    HAL_UART_Transmit(&huart2, (uint8_t*) &ch, 1, HAL_MAX_DELAY);   // Envoyer le caractère via UART
    return ch;                                                      // Retourner le caractère envoyé
}
/* USER CODE END 0 */

7.4 Configuration avec IAQ actif

Configurez les paramètres d'initialisation dans la section USER CODE BEGIN 2 de votre main.c :


/* USER CODE BEGIN 2 */
HAL_Delay(250); // Attendre 250 ms pour permettre au système de se stabiliser
printf("Initialisation du BME680 avec une configuration personnalisée pour IAQ...\r\n");

BME680_InitialSettings custom_settings;                     // Paramètres personnalisés pour l'initialisation

// Paramètres TPH (Température, Pression, Humidité)
custom_settings.tph_sett.os_hum = BME680_OS_2X;             // Oversampling humidité x2
custom_settings.tph_sett.os_pres = BME680_OS_4X;            // Oversampling pression x4
custom_settings.tph_sett.os_temp = BME680_OS_8X;            // Oversampling température x8
custom_settings.tph_sett.filter = BME680_FILTER_SIZE_3;     // Coefficient du filtre IIR

// Paramètres du capteur de gaz pour IAQ
custom_settings.gas_sett.run_gas = BME680_RUN_GAS_ENABLE;   // Activer la mesure de gaz
custom_settings.gas_sett.nb_conv = 0;                       // Utiliser le profil de chauffage/mesure 0
custom_settings.gas_sett.heatr_temp = 320;                  // Température de chauffage cible (ex: 320°C)
custom_settings.gas_sett.heatr_dur = 150;                   // Durée de chauffage (ex: 150 ms)

// Mode d'alimentation
custom_settings.power_mode = BME680_FORCED_MODE;            // Mode forcé pour des mesures ponctuelles

int8_t status = BME680_OK;                                  // Variable pour stocker le statut de l'initialisation

status = BME680_Start(&gas_sensor, &hi2c1, user_delay_ms, &custom_settings); // Initialiser le capteur BME680 avec les paramètres personnalisés

if (status == BME680_OK)                                                     // Si le statut de l'initialisation est OK
{
    printf("BME680 initialisé avec succès !\r\n");                           // Afficher le message de succès
}   
else                                                                         // Sinon
{
    printf("Échec de l'initialisation du BME680 ! Statut : %d\r\n", status); // Afficher le message d'erreur
    error_handler();                                                         // Gérer l'erreur (fonction à définir selon votre projet)
}

// Initialiser le tracker IAQ
// Ces valeurs (burn_in_cycles, iaq_slope) sont des exemples et peuvent nécessiter un ajustement.
// burn_in_cycles: nombre de cycles de mesure pour stabiliser la baseline du gaz (ex: 300 cycles = 5 minutes si 1 mesure/sec)
// iaq_slope: pente pour la compensation d'humidité de la résistance du gaz (valeur typique entre 0.01 et 0.09).
initIAQTracker(&iaq_tracker, 300, 0.03f);  // Initialiser le tracker IAQ avec 300 cycles de burn-in et une pente d'humidité de 0.03 (courant pour la plupart des applications)                                                                 
printf("Tracker IAQ initialisé. Phase de burn-in pour la calibration du gaz en cours...\r\n");

uint16_t meas_period;                                           // Variable pour contenir la durée de mesure calculée
bme680_get_profile_dur(&meas_period, &gas_sensor);              // Calcule de la durée de mesure

// Pour le mode forcé, nous devons déclencher la première mesure avant d'entrer dans la boucle.
if (gas_sensor.power_mode == BME680_FORCED_MODE)                // Si le mode d'alimentation est forcé
{
    status = bme680_set_sensor_mode(&gas_sensor);               // Déclencher la mesure
    if (status != BME680_OK)                                    // Si le statut n'est pas OK
    {
        printf("Échec du déclenchement initial du capteur en mode forcé, statut : %d\r\n", status);
        Error_Handler();                                        // Ou une autre gestion d'erreur appropriée
    }
}

struct bme680_field_data raw_data;                              // Structure pour stocker les données brutes du capteur   
/* USER CODE END 2 */

7.5 Lecture des mesures

Pour lire les données (température, humidité, pression, résistance du gaz) en mode forcé, placez le code suivant dans la boucle while(1) (section USER CODE BEGIN WHILE) :


/* USER CODE BEGIN WHILE */
while (1)
{
    // Attendre que la mesure (déclenchée à l'itération précédente ou avant la boucle) soit complète
    HAL_Delay(meas_period + 20);                                    // +20ms de marge

    status = bme680_get_sensor_data(&raw_data, &gas_sensor);        // Lire les données brutes du capteur

    if (status == BME680_OK)                                        // Si la lecture des données est réussie
    {
        BME680Data bme_data;
        bme_data.temperature = raw_data.temperature; // raw_data.temperature est déjà en °C
        bme_data.pressure = raw_data.pressure / 100.0f; // Conversion Pa vers hPa
        bme_data.humidity = raw_data.humidity; // raw_data.humidity est déjà en %RH
        // Initialiser gas_resistance en fonction de la validité des données de gaz

        int gas_measurement_is_valid = (raw_data.status & BME680_GASM_VALID_MSK);
        int was_burn_in_active = (iaq_tracker.burn_in_cycles_remaining > 0);

        if (gas_measurement_is_valid)
        {
            bme_data.gas_resistance = raw_data.gas_resistance; // raw_data.gas_resistance est en Ohms
            printf("Temperature: %.1f °C, Pressure: %.1f hPa, Humidity: %.1f %%, Gas: %.1f kOhms\r\n",
            bme_data.temperature, bme_data.pressure, bme_data.humidity, bme_data.gas_resistance / 1000.0);
        }
        else
        {
            bme_data.gas_resistance = NAN; // Not-A-Number, pour indiquer des données de gaz invalides à getIAQ
            printf("Temperature: %.1f °C, Pressure: %.1f hPa, Humidity: %.1f %%, Gas: N/A (not valid)\r\n",
            bme_data.temperature, bme_data.pressure, bme_data.humidity);
        }

        float iaq = getIAQ(&iaq_tracker, bme_data); // Toujours appeler pour la gestion du burn-in

        if (!isnan(iaq))
        {
            // IAQ est une valeur valide, donc le burn-in est terminé et les données de gaz étaient valides.
            printf("IAQ: %.2f%% - Qualité de l'air : %s\r\n", iaq, getIAQCategory(iaq));
        }
        else // iaq is NAN
        {
            if (was_burn_in_active) // Si le burn-in était la raison pour laquelle iaq est NAN
            {
                printf("IAQ Burn-in in progress... (Cycles restants: %d)\r\n", iaq_tracker.burn_in_cycles_remaining > 0 ?
                iaq_tracker.burn_in_cycles_remaining : 0);
            }
            else // Le burn-in est terminé, donc iaq est NAN à cause de données de gaz invalides
            {
                printf("IAQ: N/A (Gas data was not valid for current reading)\r\n");
            }
        }
    }
    else
    {
        printf("Failed to get sensor data, status: %d\r\n", status);
    }

    // Si on est en mode forcé, redéclencher une mesure pour la prochaine itération
    if (gas_sensor.power_mode == BME680_FORCED_MODE)
    {
        status = bme680_set_sensor_mode(&gas_sensor);
        if (status != BME680_OK)
        {
            printf("Failed to set sensor to forced mode again, status: %d\r\n", status);
        }
    }

    HAL_Delay(1000); // Délai avant la prochaine lecture/cycle de mesure
    /* USER CODE END WHILE */

8 Gestion des erreurs

La plupart des fonctions de la librairie retournent un statut de type int8_t. Il est crucial de vérifier cette valeur. Les codes de retour importants sont définis dans STM32_BME680_defs.h :

  • BME680_OK (0): Opération réussie.
  • BME680_E_NULL_PTR (-1): Pointeur nul passé en argument.
  • BME680_E_COM_FAIL (-2): Échec de communication I2C.
  • BME680_E_DEV_NOT_FOUND (-3): Capteur non détecté sur le bus I2C.
  • BME680_E_INVALID_LENGTH (-4): Longueur de données invalide.
  • BME680_W_NO_NEW_DATA (1): Avertissement, pas de nouvelles données disponibles (après une lecture).
  • BME680_I_MIN_CORRECTION, BME680_I_MAX_CORRECTION: Codes d'information liés à la compensation.

9. Fonctions et Structures détaillées

Voici quelques fonctions et structures clés de la librairie :

Structures Principales

  • struct bme680_dev gas_sensor: Instance principale représentant le capteur. Contient l'ID du chip, l'adresse I2C, les pointeurs de fonction pour la communication et le délai, les données de calibration, les paramètres de mesure (TPH et gaz), et le mode d'alimentation.
  • BME680_InitialSettings initial_settings: Utilisée avec BME680_Start pour une configuration initiale groupée et simplifiée.
  • struct bme680_field_data data: Contient les résultats des mesures : temperature (centi-°C), pressure (Pa), humidity (milli-%RH), gas_resistance (Ohms), et status (indiquant si de nouvelles données sont prêtes).
  • IAQTracker iaq_tracker: Structure pour le suivi et le calcul de la QAI.
  • BME680Data bme_data_for_iaq: Structure simplifiée pour passer les données à getIAQ, avec des valeurs en unités standards (float).

Fonctions Clés

  • int8_t BME680_Start(struct bme680_dev *dev, I2C_HandleTypeDef *i2c_handle, bme680_delay_fptr_t delay_fptr, const BME680_InitialSettings *settings): Fonction de haut niveau pour initialiser la librairie et le capteur. Configure les pointeurs de communication, détecte le capteur, lit les calibrations et applique les paramètres initiaux.
  • int8_t bme680_init(struct bme680_dev *dev): Initialisation de bas niveau (style API Bosch), appelée par BME680_Start. Lit l'ID, effectue un soft reset, et récupère les données de calibration.
  • int8_t bme680_set_sensor_settings(uint16_t desired_settings, struct bme680_dev *dev): Configure les paramètres TPH (suréchantillonnage, filtre) et gaz. Utilise des masques (BME680_OST_SEL, etc.) pour spécifier quels paramètres configurer.
  • int8_t bme680_set_sensor_mode(struct bme680_dev *dev): Définit le mode d'alimentation. En mode forcé (BME680_FORCED_MODE), cela déclenche une nouvelle mesure.
  • int8_t bme680_get_sensor_data(struct bme680_field_data *data, struct bme680_dev *dev): Lit les données brutes des registres et les convertit en valeurs compensées.
  • void bme680_get_profile_dur(uint16_t *duration, const struct bme680_dev *dev): Calcule la durée typique d'un cycle de mesure en fonction des paramètres actuels.
  • void initIAQTracker(IAQTracker *tracker, int burn_in_total_cycles, float ph_slope): Initialise la structure de suivi QAI.
  • float getIAQ(IAQTracker *tracker, BME680Data bme_data): Calcule la valeur QAI.
  • const char* getIAQCategory(float iaq): Convertit la valeur QAI en catégorie textuelle.

10. Calibration et Burn-in

Calibration du capteur TPH : Le BME680 stocke des coefficients de calibration en interne pour la température, la pression et l'humidité. Ces coefficients sont lus par la fonction bme680_init (appelée par BME680_Start) et utilisés automatiquement lors de la lecture des données pour fournir des valeurs compensées. Aucune calibration manuelle de ces paramètres n'est typiquement requise par l'utilisateur.

Capteur de Gaz et Burn-in pour la QAI : Le capteur de gaz MOX nécessite une période de stabilisation initiale, appelée "burn-in", pour que ses lectures deviennent fiables et que la ligne de base pour le calcul de la QAI puisse être établie.

  • Lorsqu'il est neuf ou après une longue période d'inactivité, le capteur de gaz peut prendre de quelques minutes à plusieurs heures pour se stabiliser complètement.
  • La fonction initIAQTracker permet de définir un nombre de cycles de mesure initiaux (burn_in_total_cycles) pendant lesquels la fonction getIAQ retournera NAN (Not a Number).
  • Pendant cette période, la librairie collecte des données pour établir une ligne de base de la résistance du gaz. Une fois le burn-in terminé, le calcul de la QAI devient actif.
  • La ligne de base de la QAI est adaptative, c'est-à-dire qu'elle continue de s'ajuster lentement en fonction des lectures récentes pour compenser les dérives à long terme du capteur.

11. Constantes importantes

La plupart des constantes sont définies dans STM32_BME680_defs.h :

  • Adresses I2C: BME680_I2C_ADDR_PRIMARY (0x76), BME680_I2C_ADDR_SECONDARY (0x77). La librairie essaie les deux.
  • ID du Chip: BME680_CHIP_ID (0x61).
  • Modes d'alimentation: BME680_SLEEP_MODE, BME680_FORCED_MODE.
  • Paramètres de suréchantillonnage (TPH): BME680_OS_NONE, BME680_OS_1X, ..., BME680_OS_16X.
  • Paramètres de filtre IIR (TP): BME680_FILTER_SIZE_0, ..., BME680_FILTER_SIZE_127.
  • Contrôle de la mesure de gaz: BME680_RUN_GAS_ENABLE, BME680_RUN_GAS_DISABLE.
  • Masques pour bme680_set_sensor_settings: BME680_OST_SEL, BME680_OSP_SEL, BME680_OSH_SEL, BME680_FILTER_SEL, BME680_GAS_SENSOR_SEL.
  • Constantes pour la QAI (dans STM32_BME680.h): GAS_CAL_DATA_WINDOW_SIZE, seuils pour les catégories de QAI.

12. Dépannage

  • Erreur d'initialisation (BME680_E_DEV_NOT_FOUND, BME680_E_COM_FAIL):
    • Vérifiez le câblage du capteur BME680 (SDA, SCL, VCC, GND).
    • Assurez-vous que les résistances de pull-up sont présentes sur les lignes SDA et SCL (généralement 4.7kΩ à 10kΩ).
    • Vérifiez l'adresse I2C du capteur. Le BME680 peut être à 0x76 ou 0x77 (souvent sélectionnable par une broche SDO). La librairie teste les deux.
    • Utilisez un scanner I2C pour vérifier si le capteur est détecté sur le bus.
    • Assurez-vous que le périphérique I2C du STM32 est correctement initialisé avant d'appeler BME680_Start.
  • Pas de nouvelles données (BME680_W_NO_NEW_DATA retourné par bme680_get_sensor_data):
    • Assurez-vous d'attendre suffisamment longtemps après avoir déclenché une mesure en mode forcé. Utilisez bme680_get_profile_dur pour obtenir la durée de mesure et attendez au moins cette durée.
  • Lectures de QAI incorrectes ou bloquées sur "burn-in":
    • Laissez suffisamment de temps pour la période de burn-in. Cela peut prendre plusieurs minutes.
    • Vérifiez les paramètres heatr_temp et heatr_dur. Des valeurs incorrectes peuvent affecter la sensibilité du capteur de gaz.
    • Le placement du capteur est crucial pour la QAI. Évitez les courants d'air, la lumière directe du soleil, et les sources de chaleur ou de COV à proximité.
    • Essayez d'ajuster le paramètre humidity_slope dans initIAQTracker si les lectures semblent fortement corrélées à l'humidité de manière incorrecte.
  • Pas de sortie printf:
    • Assurez-vous que l'UART est correctement configuré et que la fonction __io_putchar (ou équivalent) est implémentée et fonctionnelle.
    • Vérifiez que le support des flottants est activé pour printf si vous affichez des nombres décimaux.
  • Problèmes avec user_delay_ms:
    • La fonction user_delay_ms fournie dans STM32_BME680.c utilise HAL_Delay. Assurez-vous que HAL_Delay fonctionne correctement dans votre projet (dépend de la configuration du SysTick).

13. Conclusion

La bibliothèque STM32_BME680 vise à simplifier l'utilisation du capteur environnemental BME680 avec les microcontrôleurs STM32. En encapsulant la complexité de la communication I2C, la configuration du capteur, la compensation des données et le calcul de la QAI, elle permet aux développeurs de se concentrer sur l'application finale. En suivant ce tutoriel, vous devriez être en mesure de configurer, lire et interpréter les données de votre capteur BME680.