Module BME280 : caractéristiques, librairie, et câblage I2C ou SPI (tutorial avec exemple de code arduino)

Besoin d’effectuer des mesures de température, pression, et taux d’humidité ? Alors le BME280 pourrait vous intéresser ! Mais encore faut-il savoir comment l’alimenter, et comment le raccorder à votre arduino. Car ce petit module, pouvant se brancher sur le bus i2c ou le bus SPI, se révèle parfois dur à appréhender, lorsqu’on débute. Qui plus est, encore faut-il trouver la « bonne librairie arduino », pour communiquer efficacement avec lui.

Tout ça, je vous propose que nous le voyions ici ! Avec en prime, comme d’habitude, un exemple de code arduino, vous montrant comment faire afficher, sur le moniteur série, les valeurs courantes de température, taux d’humidité, et pression ambiante. Ainsi, vous saurez comment interroger et recevoir les mesures de ce petit capteur, en toute simplicité 😉

Comme toujours, cet article s’adresse avant tout aux débutants en électronique, et plus précisément, ceux qui débutent avec arduino. Je passerai d’ailleurs pas mal de temps sur plusieurs points de détails concernant le BME280, afin que chacun puisse comprendre le plus précisément et facilement possible comment mettre en œuvre ce composant. Bien sûr, comme nul ne pouvant être infaillible, il est possible que des coquilles se soient glissées dans le présent tutoriel. Si c’est le cas, n’hésitez pas à m’en faire part en zone commentaire, pour que je puisse effectuer les corrections nécessaires ! Encore merci à vous !

Aperçu	Description	Lien achat
	Module BME280 I2C (fonctionne en 5V ou 3,3V)
	Module BME280 SPI/I2C (fonctionne en 3,3V uniquement)

Survol du BME280 (notamment vs BMP280)

Le BME280 est une puce conçue par Bosch. Celle-ci permet de faire des mesures de :

• Température (de -40 à +85 °C)
• Pression atmosphérique (de 300 à 1100 hPa)
• Et d’hygrométrie (de 0 à 100%)

Mais avant d’aller plus loin, il y a une chose à savoir. Ou plutôt, une erreur à ne pas commettre : il s’agit de ne pas confondre BME280 et BMP280. Car même si ceux-ci se ressemblent très fortement, ils n’en sont pas moins différents sur un point important, cependant. En effet :

• Le BME280 permet de faire des mesures de température, de pression, et d’hygrométrie (c’est le capteur étudié ici, dans ce tuto)
• Et le BMP280, quant à lui, ne permet pas la moindre mesure de taux d’humidité. En fait, il est « limité » à la mesure de température et de pression, seulement.

Extérieurement, on pourrait facilement confondre ces deux modèles. C’est pourquoi je me permets ce petit aparté ! Bien sûr, le BME280 sera évidemment plus cher que le BMP280 à l’achat, du fait de ses capacités plus « étendues ». Dans tous les cas, faites bien attention de commander la puce qui vous intéresse vraiment 😉

Remarque : faites très attention aux vendeurs « peu scrupuleux » qui vendent des BMP280 au lieu des BME280, en mettant des textes souvent vraiment trompeur, au niveau de leurs annonces. De base, un capteur BME280 coûte environ 10 à 15 euros, tandis qu’un BMP280 (la version « limitée ») ne coûte que quelques euros « seulement ». En clair, faites très attention avant de commander quoi que ce soit sur internet, en croyant faire une bonne affaire !

À noter que ces puces multifonctions sont le plus souvent vendues déjà soudées, sur une mini plaquette PCB. Cela nous arrange d’ailleurs grandement, car « l’extrême petitesse » de ces puces les rendent parfois difficiles à souder, surtout si vous débutez en électronique. Un second avantage des plaquettes PCB toutes prêtes, est le fait d’avoir à disposition des broches de connexion simples et rapides, et facilement identifiables grâce aux repères sérigraphiés (« Vin », « Gnd », « Scl », « Sda », …). Enfin, bon nombre de composants additionnels, tels que les régulateurs de tensions ou transistors de conversion de niveaux, sont souvent intégrés à ces PCB, permettant là encore de faciliter notre branchement dessus.

Voici d’ailleurs un exemple de mini plaquette PCB, qu’on trouve communément dans le commerce (ici, il s’agit d’un modèle s’alimentant en 5 volts, avec communication I2C) :

Bien évidemment, il existe bon nombre d’autres modèles, fonctionnant par exemple sous 3,3 volts (au lieu de 5V), ou via le protocole de communication SPI (au lieu, ou parallèlement à l’I2C). En bref, il y en a pour tous les goûts 😉

Une chose cependant, à s’assurer : si vous achetez un module BME280 « compatible 5V », vérifiez bien que celui-ci soit équipé de transistors mosfet de mise à niveau des signaux. Car la puce BME280, en elle-même, ne peut supporter plus de 3,6 volts sur son alimentation, tout comme sur ses autres broches. Du coup, tout « bon » modèle 5 volts devra absolument posséder :

• Un régulateur de tension, pour transformer le +5V en +3,3 volts
• Des mosfets avec résistances de pull-up, pour transformer les signaux 5V en 3,3V, et vice versa, pour assurer une communication bidirectionnelle

Visuellement, vous devrez simplement vérifier la présence de ces composants autour ou « au dos » du BME280, comme visible sur la mini plaquette pcb exemple ci-dessous :

Nota : pour différentier le BME280 du BMP280 (le circuit intégré j’entends, pas la plaquette de circuit imprimé), il y a 2 façons de faire :
– soit jeter un coup d’œil au marquage du boitier ; en effet, si vous voyez la mention UP gravée sur le boitier, alors il s’agit d’un BME280, et si vous voyez la mention KS, KM, ou autre à la place, alors il s’agit plutôt d’un BMP280 (un grand merci à Jean pour cette info, qui nous a partagé cela en commentaire !)
– soit jeter un coup d’œil à la forme du boîtier ; s’il est carré, il s’agit d’une puce BME 280, et s’il est rectangulaire, il s’agit d’une puce BMP 280 (là du coup, un grand merci à Philippe, qui a remonté cette info en commentaire lui aussi !).

Caractéristiques du BME280 (issues du datasheet)

Cela étant dit, voyons à présent plus en détail les principales caractéristiques du BME280. En synthèse, cette puce permet de :

• Faire des mesures de température, pouvant être situées entre -45°C et +85°C, avec une tolérance de ± 1 °C environ
• Faire des mesures de pression, dans l’intervalle 300 hPa à 1100 hPa, avec une tolérance de ± 1 hPa environ
• Faire des mesures d’hygrométrie (taux d’humidité), entre 0 et 100%, avec une tolérance de ± 3% environ

Au niveau consommation, ce qui est d’ailleurs l’un des points forts de cette puce, le BME280 ne consomme que :

• 3,6 µA lors des mesures (pression, température, ou hygrométrie), typiquement
• Et 0,1 µA au repos (ce qui représente une consommation vraiment minimale !)

Au passage, si vous avez besoin de plus d’informations ou plus de précisions ici, je vous renvoie vers la documentation constructeur du BME280 (site Bosch). Ainsi, vous aurez beaucoup plus de détails sur cette puce électronique, afin d’approfondir le sujet 😉

Du reste, si comme moi vous êtes « bricoleur » ou amateur d’électronique, vous trouverez également cette puce déjà soudée sur une « plaquette mini PCB » à l’achat (voir photos ci-dessous), vous donnant ainsi facilement accès aux broches d’alimentation et de communication de ce mini capteur. Car, croyez moi : souder cette « micro » puce BME280, tout seul de son côté, n’est pas forcément une chose si facile que ça à faire, surtout si vous êtes débutant en électronique (car il s’agit d’un composant CMS de vraiment petite taille !).

Module	BME280 5V I2C	BME280 3,3V I2C/SPI
Photo
Bus compatibles	Bus I2C uniquement	Bus I2C et SPI
Alimentation	5V	3V3
Lien	BME280 5 volts I2C	BME280 3,3 volts I2C/SPI

Nous allons d’ailleurs à présent détailler ces mini cartes PCB, intégrant le BME280 avec ses composants additionnels !

Remarque : faites très attention aux vendeurs « peu scrupuleux », qui vendent des BMP280 au lieu des BME280 (en mettant des textes parfois très trompeur, au niveau de leurs annonces). Pour éviter de vous faire avoir, dites vous simplement qu’un capteur BME280 (le « bon ») coûte environ 10 à 15 euros, tandis qu’un BMP280 (la version « limitée »), ne coûte que quelques euros « seulement ». En clair, faites bien attention avant de commander quoi que ce soit sur internet, surtout si le prix vous parait suspect !

Comment raccorder le BME280 sur l’Arduino (alimentation 3,3 ou 5V, communication I2C ou SPI, …)

Nativement, la puce BME280 est compatible avec 2 protocoles de communication, qui sont :

• Le protocole I2C (nécessite 2 fils : SDA et SCL)
• Et le protocole SPI (nécessite 4 fils : MISO, MOSI, SCK, et CS)

Cela étant dit, lorsqu’on achète une « mini plaquette PCB » avec le BME280 déjà soudé dessus, on n’a pas forcément accès à ces deux protocoles. Car chaque fabricant décide par lui-même de mettre à disposition ou non, les broches qui permettent tel ou tel type de communication. Il vous revient donc de vérifier si le modèle que vous souhaitez acheter est bien compatible avec le mode de communication que vous envisagez d’utiliser.

Pour illustrer cela, voici des exemples de plaquettes PCB, intégrant un BME280 dessus. Comme vous verrez, on retrouve :

• Les deux protocoles de communication : I2C et/ou SPI
• La possibilité d’alimenter ces modules en +5V ou +3,3 volts

Comme vous l’aurez compris, ces modules BME280 ont chacun leurs avantages et inconvénients. Car :

• Celui de gauche, par exemple, peut s’alimenter en +5V, mais n’est pas pilotable en SPI (ce qui rend la plaquette plus simple à utiliser, mais se révèle plus limitée en terme de connectivité)
• Ceux du milieu et de droite sont utilisables en I2C ou en SPI, mais par contre, ne peuvent être alimentés qu’en +3,3 volts (ce qui contredit leur utilisation directe avec un arduino fonctionnant en 5V, comme l’Arduino Uno ou l’Arduino Nano, par exemple)

Au passage, pour ceux que ça intéresse d’entrer un peu plus dans le détail, voici la nomination des broches les plus courantes, figurant sur ces plaquettes pcb, et leur rôle respectif :

Au niveau de l’arduino, vous aurez possibilité de vous connecter via les broches :

• SDA et SCL, si vous souhaitez communiquer via le bus I2C
• MISO, MOSI, SCK, et CS, si vous souhaitez communiquer via le bus SPI

Si vous souhaitez fonctionner avec le bus i2c de votre arduino, alors les broches à utiliser sont communément :

Et pour le bus SPI :

Et pour éviter tout dommage électrique, assurez-vous de toujours prendre un module BME280 prévu pour une tension identique à celle de votre Arduino (tension de travail du microcontrôleur, j’entends). En clair :

• Si vous utilisez un Arduino intégrant un microcontrôleur travaillant sous 5V (l’ATmega328P, par exemple, équipant les Arduino Uno et Nano), prenez un BME280 compatible 5 volts
• Et si vous utilisez un Arduino (ou autre) intégrant un microcontrôleur fonctionnant sous 3,3 volts, alors prenez module BME280 3,3V

Sans quoi, à terme, vous risquez fort d’endommager certains de vos composants électroniques.

Du reste, au niveau raccordement du BME280 à l’Arduino Uno, voici un exemple de branchement d’un module BME280 5V I2C à l’arduino uno :

Une parenthèse, au passage, concernant le protocole I2C. Vous avez le choix entre 2 adresses possibles pour votre module BME280 :

• Soit 0x76, qui est l’adresse par défaut
• Soit 0x77, qui est une seconde adresse utilisable, si vous le souhaitez (qui faudra physiquement spécifier à même la carte PCB, en réalisant un pont de soudure)

Visuellement, cela se présente le plus souvent de la manière suivante :

À présent, nous allons laisser cette partie matérielle de côté, pour nous intéresser à la partie logicielle. Et pour commencer, nous allons voir ensemble un exemple de librairie BME280, pour bien débuter !

Aperçu	Description	Lien achat
	Module BME280 I2C (fonctionne en 5V ou 3,3V)
	Module BME280 SPI/I2C (fonctionne en 3,3V uniquement)

Librairie BME280 (gestionnaire de bibliothèque IDE Arduino)

Parmi toutes les librairies existantes dans le gestionnaire de bibliothèque arduino, il y en a une qui est idéale pour débuter avec le BME280. Il s’agit de la librairie BME280 d’Adafruit. Car elle est super simple à utiliser, et compatible avec de nombreux modules (i2c/spi). Bien sûr, si plus tard vous avez des besoins plus spécifiques, il faudra alors chercher une librairie plus poussée, et répondant plus spécifiquement à vos besoins propres.

Pour télécharger la librairie BME280 de Adafruit, il vous suffit de démarrer votre IDE Arduino, et d’aller dans le menu Outils > Gérer les bibliothèques. Une fois fait, vous devriez voir une fenêtre s’afficher, comme celle présentée juste après. Il faudra y taper le terme « bme280 » dans le champ de recherche (1), et appuyer sur la touche ENTRÉE de votre clavier, pour lancer la recherche.

Cela étant fait, il faut à présent sélectionner le bloc « Adafruit BME280 Library » (2), et cliquer sur Installer (3).

Au passage, il est possible que l’IDE arduino vous demande l’autorisation d’installer une librairie dépendante, nommée « Adafruit Unified Sensor ». Il faudra bien évidemment l’accepter, sans quoi la librairie BME280 ne pourra fonctionner. À l’inverse, si cette librairie a déjà été importée dans votre environnement, vous n’aurez alors aucun message.

Nota : pour vérifier si cette librairie complémentaire est bien installée, il vous suffit de taper « adafruit unified sensor » (4) dans votre barre de recherche, et de lancer la recherche. Vous devriez ainsi voir apparaître une ligne « Adafruit Unified Sensor » dans les résultats, avec le terme « INSTALLED » (5), écrit à côté du numéro de version de cette librairie.

Une fois ces librairies importées dans votre gestionnaire de bibliothèque Arduino, vous n’aurez plus qu’à insérer la ligne suivante, dans l’entête de votre programme arduino, pour faire appel à elles :

#include <Adafruit_BME280.h>

Et d’instancier un objet de cette librairie, selon si vous souhaitez fonctionner en I2C, ou en SPI :

// Utilisez 1 des deux lignes suivantes, selon si vous utilisez le protocole I2C ou SPI
Adafruit_BME280 bme;                                        // Si fonctionnement en "mode I2C"
Adafruit_BMP280 bme(BMP_CS, BMP_MOSI, BMP_MISO,  BMP_SCK);  // Si fonctionnement en "mode SPI" (**)

// (**) En remplaçant les valeurs BMP_CS, BMP_MOSI, BMP_MISO, et BMP_SCK, par les pins
// correspondantes du port SPI de votre arduino (comme vu dans le chapitre précédent)

Au final, l’objet « bme » vous permettra d’accéder à toutes les fonctions de cette librairie BME280, partout dans votre code de programmation arduino.

Initialisation de la librairie BME280 (fonction « begin »)

Pour initialiser la librairie, rien de plus simple : il suffit d’utiliser la commande « bme.begin(); »

Cette fonction renvoie une valeur booléenne, qui vaut :

• TRUE, si le BME280 a « répondu présent »
• Ou FALSE, si la connexion au BME280 n’a pas pu se faire

Au passage, si vous fonctionnez en mode I2C, cette fonction accepte un argument, qui est l’adresse I2C de votre module BME280. Ainsi, vous pouvez utiliser la commande :

• bme.begin(); pour communiquer avec votre BME280 via l’adresse 0x76 (valeur par défaut)
• bme.begin(0x76); pour faire la même chose que begin()
• bme.begin(0x77); pour communiquer via cette seconde adresse i2c possible

Lecture de la température ambiante (fonction « readTemperature »)

Pour lire la température ambiante, rien de plus simple ! Il suffit de faire appel à la fonction « bme.readTemperature(); »

Cela retourne une valeur de type float, exprimant la température mesurée en degrés Celsius. Donc nul besoin ici de faire des conversions avec les degrés Fahrenheit, comme c’est le cas avec certaines librairies (telle que celle utilisée pour le capteur de température DHT22, par exemple).

Lecture du taux d’humidité (fonction « readHumidity »)

Pour connaître le taux d’humidité ambiant, il suffit d’appeler la fonction « bme.readHumidity(); »

Cette fonction retourne également une valeur de type float, comprise entre 0 et 100. Cela représente tout simplement l’hygrométrie ambiante, allant de 0% à 100%.

Lecture de la pression atmosphérique (fonction « readPressure »)

Afin de connaître la pression atmosphérique ambiante, il suffit d’écrire la commande « bme.readPressure(); »

En retour, vous obtiendrez une valeur de type float, vous indiquant la valeur de la pression ambiante, exprimée en Pascal (Pa). Par contre, comme on préfère généralement exprimer les pressions atmosphériques en « hectopascals » (hPa), il faudra alors diviser cette valeur par 100 (comme 1 hPa = 100 Pa).

Estimation de l’altitude (fonction « readAltitude »)

Enfin, pour estimer l’altitude à laquelle vous vous situez, à quelques centimètres ou mètres près (peu précis, je vous l’accorde !), c’est la commande « bme.readAltitude(pressionAuNiveauDeLaMer); » qu’il faudra utiliser.

Au passage, il faudra bien évidemment remplacer la valeur de « pressionAuNiveauDeLaMer » par la valeur de pression actuelle au niveau de la mer, proche de chez vous, exprimée en hPa. Ainsi, en fonction de cette donnée et de la pression ambiante actuellement lue au niveau du BME280, vous obtiendrez une estimation de votre altitude (l’altitude 0 étant bien évidemment celle située au niveau de la mer).

Là encore, c’est une valeur float qui est retournée, donnant l’altitude approximative à laquelle vous vous trouvez, exprimée en mètres, par rapport au niveau de la mer. Et je parle bien d’estimation et de valeur approximative, car la pression au niveau de la mer varie constamment, ce qui rend l’estimation de l’altitude assez hasardeuse, parfois 😉

Du reste, je vous illustrerai cette fonction dans l’exemple qui suit, afin que ce soit un peu plus parlant ! Alors, en avant !

Aperçu	Description	Lien achat
	Module BME280 I2C (fonctionne en 5V ou 3,3V)
	Module BME280 SPI/I2C (fonctionne en 3,3V uniquement)

Code arduino : exemple permettant d’afficher la température, l’hygrométrie, et la pression ambiante

Maintenant que nous avons vu la théorie, passons à la pratique ! Car quoi de plus parlant qu’un bon exemple de code, montrant comment se servir de toutes ces choses, concrètement !

Pour ce faire, je vous propose de réaliser le montage suivant :

Comme vous le voyez, le câblage est on ne peut plus simple. Car il suffit simplement de raccorder un module BME280 5V/I2C à un Arduino Uno (microcontrôleur ATmega328P, fonctionnant sous 5 volts), via le bus i2c. C’est d’ailleurs le genre de montage idéal pour apprendre l’électronique, lorsqu’on débute, avant de passer à des choses plus complexes, plus techniques, ou plus poussées.

Aperçu	Matériel utilisé		Qté	Lien
	Arduino Nano R3 (microcontrôleur ATmega328)	x	1
	Module BME280 (modèle 5 volts / I2C)	x	1

De mon côté, voici ce que ça donne, une fois monté sur breadboard :

Remarque : avant d’aller plus loin, et si vous avez bien lu tout ce que j’ai mis plus haut, vous savez que l’adresse i2c d’un BME280 peut prendre deux valeurs : 0x76 ou 0x77. Or, ici, nous ne savons pas (de manière sûre) quelle est l’adresse réelle de ce capteur.

Ce que je vous propose donc, avant d’aller plus loin, est de vérifier quelle est l’adresse I2C de ce module BME280. Pour cela, nous allons utiliser un simple « scanner I2C », qui va nous retourner l’adresse i2c qui aura « répondu présent » ! En pratique, ce scanner I2C est en fait un simple programme arduino, dont voici le code :

/*
   ______               _                  _///_ _           _                   _
  /   _  \             (_)                |  ___| |         | |                 (_)
  |  [_|  |__  ___  ___ _  ___  _ __      | |__ | | ___  ___| |_ _ __ ___  _ __  _  ___  _   _  ___
  |   ___/ _ \| __|| __| |/ _ \| '_ \_____|  __|| |/ _ \/  _|  _| '__/   \| '_ \| |/   \| | | |/ _ \
  |  |  | ( ) |__ ||__ | | ( ) | | | |____| |__ | |  __/| (_| |_| | | (_) | | | | | (_) | |_| |  __/
  \__|   \__,_|___||___|_|\___/|_| [_|    \____/|_|\___|\____\__\_|  \___/|_| |_|_|\__  |\__,_|\___|
                                                                                      | |
                                                                                      \_|
  Fichier :       scannerI2C.ino
  
  Description :   Scanne les 127 adresses i2c possibles, à la recherche de périphériques connectés sur l'Arduino
                  (affiche l'adresse des périphériques détectés)

  Auteur :        Jérôme TOMSKI (https://passionelectronique.fr/)
  Créé le :       25.07.2021

*/

#include <Wire.h>                         // Inclus la bibliothèque Wire.h, afin de pouvoir envoyer des instructions sur le port i2c

byte nombreDePeripheriquesTrouves = 0;    // Variable indiquant combien de périphériques I2C ont répondu "présent"

// ========================
// Initialisation programme
// ========================
void setup() {

  // Initialisation de la liaison série, côté PC (pour y faire afficher des infos, via le moniteur série de l'IDE Arduino)
  Serial.begin(9600);
  Serial.println(F("                                    ~~ SCANNER I2C ~~                                       "));
  Serial.println(F("Scanne toutes les adresses i2c, afin de repérer tous les périphériques connectés à l'arduino"));
  Serial.println(F("============================================================================================"));
  Serial.println();

  // Initialisation de la liaison i2C
  Wire.begin();

  // Boucle de parcous des 127 adresses i2c possibles
  for (byte adresseI2C = 0; adresseI2C < 127; adresseI2C++)
  {
    Wire.beginTransmission(adresseI2C);             // Interrogation de l'adresse i2c ciblée
    if (Wire.endTransmission () == 0)               // Si cela s'est bien passé, c'est qu'il y a un périphérique connecté à cette adresse
    {
      Serial.print(F("Périphérique i2c trouvé à l'adresse : "));
      Serial.print(adresseI2C, DEC);                // On affiche son adresse au format décimal
      Serial.print(F(" (0x"));
      Serial.print(adresseI2C, HEX);                // … ainsi qu'au format hexadécimal (0x..)
      Serial.println(F(")"));
      
      nombreDePeripheriquesTrouves++;
      delay(1);                                     // Temporisation, avant de passer au scan de l'adresse suivante
    }
  }

  // Affichage final, indiquant le nombre total de périphériques trouvés sur le port I2C de l'arduino
  if (nombreDePeripheriquesTrouves == 0) {
    Serial.println(F("Aucun périphérique I2C trouvé…"));
  }
  else if (nombreDePeripheriquesTrouves == 1) {
    Serial.println();
    Serial.println(F("1 périphérique trouvé !"));
  }
  else {
    Serial.println();
    Serial.print(nombreDePeripheriquesTrouves);
    Serial.println(F("périphériques trouvés !"));
  }
  Serial.println(F("Scan terminé."));  
  
}

// =================
// Boucle principale
// =================
void loop() {
  // Aucun code ici, car tout se passe dans la fonction setup !
}

Une fois ce programme uploadé dans votre arduino, il vous suffira d’ouvrir le moniteur série de votre IDE Arduino, pour voir le résultat. Ainsi, vous devriez obtenir un résultat similaire au mien, vous donnant l’adresse de votre BME280 :

Comme vous pouvez le constater, l’adresse retournée est 0x76, ce qui correspond bien à une des deux adresses possibles, pour une puce BME280. On va donc noter cette valeur, et s’en servir dans le programme suivant, qui est l’exemple permettant de faire afficher les mesures de température, pression, et hygrométrie de l’air ambiant.

Voici donc, à présent, le programme principal :

/*
   ______               _                  _///_ _           _                   _
  /   _  \             (_)                |  ___| |         | |                 (_)
  |  [_|  |__  ___  ___ _  ___  _ __      | |__ | | ___  ___| |_ _ __ ___  _ __  _  ___  _   _  ___
  |   ___/ _ \| __|| __| |/ _ \| '_ \_____|  __|| |/ _ \/  _|  _| '__/   \| '_ \| |/   \| | | |/ _ \
  |  |  | ( ) |__ ||__ | | ( ) | | | |____| |__ | |  __/| (_| |_| | | (_) | | | | | (_) | |_| |  __/
  \__|   \__,_|___||___|_|\___/|_| [_|    \____/|_|\___|\____\__\_|  \___/|_| |_|_|\__  |\__,_|\___|
                                                                                      | |
                                                                                      \_|
  Fichier :       programme-test-bme280.ino
  
  Description :   Programme permettant de tester un BME280 branché sur les pins SDA et SCL d'un Arduino (bus I2C)

  Auteur :        Jérôme TOMSKI (https://passionelectronique.fr/)
  Créé le :       30.09.2021

  Librairie Adafruit BME280 utilisée : https://github.com/adafruit/Adafruit_BME280_Library (importée depuis le Gestionnaire de bibliothèques Arduino)

*/

#include <Adafruit_BME280.h>                            // Inclusion de la librairie BME280 d'Adafruit

// Constantes du programme
#define adresseI2CduBME280                0x76            // Adresse I2C du BME280 (0x76, dans mon cas, ce qui est souvent la valeur par défaut)
#define pressionAuNiveauDeLaMerEnHpa      1024.90         // https://fr.wikipedia.org/wiki/Pression_atmospherique (1013.25 hPa en moyenne, valeur "par défaut")
#define delaiRafraichissementAffichage    1500            // Délai de rafraîchissement de l'affichage (en millisecondes)

// Instanciation de la librairie BME280
Adafruit_BME280 bme;


// ========================
// Initialisation programme
// ========================
void setup() {
  
  // Initialisation du port série (pour l'envoi d'infos via le moniteur série de l'IDE Arduino)
  Serial.begin(9600);
  while(!Serial);
  Serial.println("Programme de test du BME280");
  Serial.println("===========================");
  Serial.println();

  // Initialisation du BME280
  Serial.print(F("Initialisation du BME280, à l'adresse [0x"));
  Serial.print(adresseI2CduBME280, HEX);
  Serial.println(F("]"));
  
  if(!bme.begin(adresseI2CduBME280)) {
    Serial.println(F("--> ÉCHEC…"));
    while(1);                              // Arrêt du programme, en cas d'échec de l'initialisation
  } else {
    Serial.println(F("--> RÉUSSIE !"));
  }
  Serial.println();
  
}


// ======================================
// Boucle principale (boucle perpétuelle)
// ======================================
void loop() {

  // Affichage de la TEMPÉRATURE
  Serial.print(F("Température = "));
  Serial.print(bme.readTemperature());
  Serial.println(F(" °C"));

  // Affichage du TAUX D'HUMIDITÉ
  Serial.print(F("Humidité = "));
  Serial.print(bme.readHumidity());
  Serial.println(F(" %"));
  
  // Affichage de la PRESSION ATMOSPHÉRIQUE
  Serial.print(F("Pression atmosphérique = "));
  Serial.print(bme.readPressure() / 100.0F);
  Serial.println(F(" hPa"));

  // Affichage de l'estimation d'ALTITUDE
  Serial.print(F("Altitude estimée = "));
  Serial.print(bme.readAltitude(pressionAuNiveauDeLaMerEnHpa));
  Serial.println(F(" m"));


  // ... et on répète ce cycle à l'infini !
  delay(delaiRafraichissementAffichage);                // Avec x secondes d'attente, avant chaque rebouclage
  Serial.println();                                     // … et un saut de ligne pour faire joli ;)

}

Très simplement, ce bout de programme permet d’interroger le BME280 de manière cyclique, en lui demandant d’effectuer des mesures de température, de taux d’humidité, et de pression atmosphérique. On en déduit au passage l’estimation de l’altitude, grâce à la fonction intégrée « readAltitude », fournie avec cette librairie.

Côté moniteur série, voici ce que j’ai obtenu, au moment de mes essais :

Au passage, cette « altitude estimée » n’est vraiment qu’une estimation. Et d’ailleurs, pour affiner cette estimation, j’ai dû manuellement saisir la pression au niveau de la mer, à proximité de chez moi (proche de Bordeaux). Pour ce faire, je suis allé sur la page Pression au niveau de la mer (site Info Climat), et reporté la valeur de pression dans le programme arduino (d’où la valeur : « #define pressionAuNiveauDeLaMerEnHpa 1024.90 », au début du programme).

Car au moment où j’ai fait à mes essais (le 30 septembre à 18h50), la pression au niveau de la mer, à côté de là où j’habite (Bordeaux), était de 1024,9 hPa, comme visible à écran ci-dessous :

Comme vous l’aurez compris, cette « valeur de pression au niveau de la mer » sera à ajuster de votre côté, si jamais vous souhaitez estimer votre altitude. Mais, encore une fois, le manque de précision est tel que je trouve finalement cette fonction peu utile, en l’état. Car elle peut vous donner des valeurs complètement erronées, avec plusieurs dizaines de mètres d’erreur d’altitude, selon le moment où sont faites vos mesures. Du reste, cela n’enlève rien à toutes les qualités du BME280, qui reste vraiment compact et relativement précis, pour faire des mesures de pression, température, et hygrométrie !

Aperçu	Description	Lien achat
	Module BME280 I2C (fonctionne en 5V ou 3,3V)
	Module BME280 SPI/I2C (fonctionne en 3,3V uniquement)

Tutorial BME 280 arduino : conclusion !

Voilà ! Je pense que nous avons à présent fait le tour du BME280, et vu toutes les bases indispensables de ce composant compact et performant, afin que vous puissiez faire vos premiers pas avec ! J’espère en tout cas que tout ceci vous servira dans vos projets personnels, présents ou à venir 😉

À très bientôt !

Jérôme.

À découvrir aussi : réalisation d’un Thermomètre Hygromètre Arduino (avec schéma et code de programmation)

JEROME

Passionné par tout ce qui touche à l'électronique, sans toutefois en être expert, j'ai à coeur de vous partager ici, peu à peu, tout ce que j'ai appris, découvert, réalisé, et testé jusqu'à présent ! En espérant que tout cela puisse vous servir, ainsi qu'au plus grand nombre !

(*) Mis à jour le 18/01/2024