Aller au contenu

Tutorial BME280 : caractéristiques, librairie, câblage i2c ou spi, et exemple de code arduino

Tutorial BME280 arduino avec librairie et exemple de code, tuto mesure température pression et hygrométrie, avec tutoriel programmation et câblage 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é 😉

Ce contenu vous plaît ? Alors abonnez-vous à la Newsletter pour ne rien louper !

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 !

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 😉

À 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) :

Module BME280 arduino, pour mesure plage température, taux d'humidité, et pression atmosphérique, mini plaquette PCB i2c 5V idéal Arduino

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 :

Tension BME280 5V ou 3,3 volts avec convertisseur de tension intégré, et mosfets de mise à niveau signaux I2C, idéal pour branchement Arduino 5 volts

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 !).

ModuleBME280 5V I2CBME280 3,3V I2C/SPI
Photo Module BME280 5 volts I2C, permettant de brancher cette plaquette PCB sur un Arduino Uno, Mega, ou Nano, en 5V via les broches SCL et SDA séries, fils dupont Module BME280 3,3 volts I2C ou SPI, fonctionnant sur Arduino basse tension, via broches SDA et SCL, ou MOSI MISO SS et SCK, selon branchement des fils
Bus compatiblesBus I2C uniquementBus I2C et SPI
Alimentation5V3V3
LienBME280 5 volts I2C Lien externe produit ou composant électronique, pour projet ou montage à faire soi-même, external link passion élec BME280 3,3 volts I2C/SPI Lien externe produit ou composant électronique, pour projet ou montage à faire soi-même, external link passion élec

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
Branchement BME280 arduino en I2C ou SPI, via broches SDA et SCL, ou MISO MOSI SCK et CS, avec câblage des bus sur Arduino Uno, Nano, et Mega

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 :

BrocheFonction
VCCAlimentation 5V ou 3,3V (la puce BME280, en interne, ne s’alimentant que jusqu’à 3,6 volts max)
GNDMasse
SDILigne de données (SDA en mode I2C, et MOSI en mode SPI)
SDKLigne d’horloge (SCL en mode I2C, et SCK en mode SPI)
CSBSélecteur de mode de communication :
– si CSB=1, alors la communication devra se faire en I2C (c’est le « mode par défaut »)
– si CSB=0, alors la communication se fera sous le protocole SPI (ligne « SS »)
SDOLigne à double usage :
– si fonctionnement en I2C, alors SDO = sélecteur d’adresse (0x76 si SDO=0, par défaut, ou 0x77 si SDO=1)
– si fonctionnement en SPI, alors SDO = ligne MISO

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 :

Type de carteMicrocontrôleurBroche SDABroche SCL
Arduino Nano
Arduino Mini
Arduino Uno
ATmega328PA4A5
Arduino MicroATmega32U4D2D3
Arduino MegaATmega2560D20D21

Et pour le bus SPI :

Type de carteMicrocontrôleurBroche MOSIBroche MISOBroche SCKBroche CS
Arduino Nano
Arduino Mini
Arduino Uno
ATmega328PD11D12D13D10
Arduino MicroATmega32U4Notée MOSINotée MISONotée SCKNotée SS
Arduino MegaATmega256051505253

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 :

Raccordement BMP280 arduino uno en I2C, via pins SCL et SDA, alimentation 5 volts depuis carte Arduino, câblage des fils pilotage bme280 i2c 5V

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 :

Adresse BME280 i2c à brancher sur Arduino, avec adresses 0x76 ou 0x77, suivant configuration pont de soudure, sur mini plaquette module PCB bmp280

À 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 !

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.

Installation librairie BME280 arduino de Adafruit, depuis gestionnaire de bibliothèque de l'IDE Arduino, pour mesure température, humidité et pression

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.

Dépendance librairie Adafruit Unified Sensor installée, pour pilotage BME280 depuis un arduino, via le gestionnaire de librairie IDE Arduino et installation

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 hectopascals (hPa).

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 !

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 :

Branchement BME280 arduino nano 5V I2C, depuis les pins SDA et SCL, convertisseur de tension alimentation et signaux intégré, modèle 5 volts i2c câblé

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.

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

Câblage BME280 avec Arduino Nano sur breadboard, pour mesure de température, d'hygrométrie, et de pression ambiante, avec code de programmation IDE arduino

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 :

Scanner I2C retrouver adresse BME280 branché sur arduino, logiciel de recherche modules câblés sur pins SCL et SDA, idéal pour vérifier raccordement bmp280

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…"));
  } 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 :

Programme test BME280 arduino, avec affichage de la température ambiante, ainsi que du taux d'humidité, pression et altitude estimée, avec code exemple

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 :

Pression au niveau de la mer pour calibration BME280 dans code arduino, exemple d'estimation altitude depuis pression atmosphérique ambiante

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 !

Du reste, voici les composants utilisés pour réaliser ces essais :

AperçuMatériel utilisé QtéLien
Arduino Nano R3 petit format, pour débuter en électronique facilement, et faire des montages pour débutants, avec code de programmation facile et pratique Arduino Nano R3 (microcontrôleur ATmega328)x1 Lien externe produit ou composant électronique, pour projet ou montage à faire soi-même, external link passion élec
Petit module BME280 alimenté en 5 volts, fonctionnant en I2C, idéal pour faire ses premiers pas en électronique pratique, avec code exemple mesures Module BME280 (modèle 5 volts / I2C)x1 Lien externe produit ou composant électronique, pour projet ou montage à faire soi-même, external link passion élec

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)

Ce contenu vous plaît ? Alors abonnez-vous à la Newsletter pour ne rien louper !

(*) Mis à jour le 10/10/2021

2 commentaires sur “Tutorial BME280 : caractéristiques, librairie, câblage i2c ou spi, et exemple de code arduino”

  1. Bonjour Jérôme,

    J’ai moi même fait l’essai de ce composant dans sa version SPI, et j’ajouterai uniquement à ton article le fait que l’on peu étalonner en compensant la valeur de la température par la commande : setTemperatureCompensation(+/- valeur) ; ce qui permet effectivement d’avoir un compensant très fiable pour la lecture de la température. L’étalonnage reste quand même toujours compliqué pour nous amateur 🙂

    Cordialement,
    Stéphane

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée.

Symbole danger point d'exclamation site PSE, triangle jaune avec contour noir, texte noir alerte au milieu Afin de filtrer au maximum les messages de type "spam" ou "inappropriés", chaque commentaire est soumis à modération, et validé manuellement. Du coup, il se peut que certains commentaires ne soient pas publiés, ou sinon, avec un peu de retard.