Aller au contenu

Module BME280 : caractéristiques, librairie, et câblage I2C ou SPI (tutorial avec 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 !

Aperçu Description Lien achat
Module bme280 5v i2c compatible arduino, pour montages électronique avec mesures de pression et autres valeurs numériques, mini plaquette pcb Module BME280 I2C (fonctionne en 5V ou 3,3V) Caddie plein 24x24, icone passion électronique fr, achat de matériels d'élec, idéal débutant et amateurs d'électronique
Module bme280 spi 3v3 pour montage arduino ou autre électronique, capteur de pression intégré dans puce de mesure, monté sur pcb mini circuit Module BME280 SPI/I2C (fonctionne en 3,3V uniquement) Caddie plein 24x24, icone passion électronique fr, achat de matériels d'élec, idéal débutant et amateurs d'électronique

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

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

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

ModuleBME280 5V I2CBME280 3,3V I2C/SPI
PhotoModule 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 dupontModule 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 élecBME280 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 !

Aperçu Description Lien achat
Module bme280 5v i2c compatible arduino, pour montages électronique avec mesures de pression et autres valeurs numériques, mini plaquette pcb Module BME280 I2C (fonctionne en 5V ou 3,3V) Caddie plein 24x24, icone passion électronique fr, achat de matériels d'élec, idéal débutant et amateurs d'électronique
Module bme280 spi 3v3 pour montage arduino ou autre électronique, capteur de pression intégré dans puce de mesure, monté sur pcb mini circuit Module BME280 SPI/I2C (fonctionne en 3,3V uniquement) Caddie plein 24x24, icone passion électronique fr, achat de matériels d'élec, idéal débutant et amateurs d'électronique

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 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 5v i2c compatible arduino, pour montages électronique avec mesures de pression et autres valeurs numériques, mini plaquette pcb Module BME280 I2C (fonctionne en 5V ou 3,3V) Caddie plein 24x24, icone passion électronique fr, achat de matériels d'élec, idéal débutant et amateurs d'électronique
Module bme280 spi 3v3 pour montage arduino ou autre électronique, capteur de pression intégré dans puce de mesure, monté sur pcb mini circuit Module BME280 SPI/I2C (fonctionne en 3,3V uniquement) Caddie plein 24x24, icone passion électronique fr, achat de matériels d'élec, idéal débutant et amateurs d'électronique

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.

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 pratiqueArduino Nano R3 (microcontrôleur ATmega328)x1Lien 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 mesuresModule BME280 (modèle 5 volts / I2C)x1Lien externe produit ou composant électronique, pour projet ou montage à faire soi-même, external link passion élec

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

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 !

Aperçu Description Lien achat
Module bme280 5v i2c compatible arduino, pour montages électronique avec mesures de pression et autres valeurs numériques, mini plaquette pcb Module BME280 I2C (fonctionne en 5V ou 3,3V) Caddie plein 24x24, icone passion électronique fr, achat de matériels d'élec, idéal débutant et amateurs d'électronique
Module bme280 spi 3v3 pour montage arduino ou autre électronique, capteur de pression intégré dans puce de mesure, monté sur pcb mini circuit Module BME280 SPI/I2C (fonctionne en 3,3V uniquement) Caddie plein 24x24, icone passion électronique fr, achat de matériels d'élec, idéal débutant et amateurs d'électronique

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 18/01/2024

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

  1. Site passionelectronique.fr

    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

  2. Site passionelectronique.fr

    Bonjour,

    Superbe tuto, bien présenté, structuré, expliqué… J’attends mon BME pour mardi, plutôt confiant dans ma future réussite !

    Merci.

  3. Site passionelectronique.fr

    Bonjour,

    Bien reçu mon BME280. Par contre, je suis 9 mètres au dessus du niveau de la mer, et la fonction readPressure() me renvoie 101900 et des bricoles.

    Dans votre point 4.4 vous indiquez que readPressure() renvoie une valeur en hPa et dans votre code vous divisez la valeur /100. Vu la valeur que je récupère, j’aurais effectivement plutôt envie de diviser par 100 !

    Je ne reviens pas sur mon commentaire du 28, votre tuto reste super, mais je pense qu’il y a sur ce point une petite modif à apporter…

    1. Site passionelectronique.fr

      Salut Renaud !

      Oui, c’est très bien vu, merci. Une erreur s’était effectivement glissée dans le point 4.4, dans ce que j’avais écris (c’est corrigé, à présent).

      En fait, la fonction « readPressure » retourne bien une valeur en pascals, d’où la nécessiter de la diviser par 100, pour l’exprimer en hectopascal.

      Encore merci à toi !
      Jérôme.

  4. Site passionelectronique.fr

    Bonjour

    Merci pour ce tuto.

    Apres avoir modifié la valeur de la pression au niveau de la mer, mon altitude semble correcte. Et pourtant la pression atmosphérique est incorrecte. Il fait très beau sur la Vendée aujourd’hui (comme toujours d’ailleurs 😉), 1034Hp sur tout le département (j’ai vérifié sur le site Info climat), mais je mesure 1021Hp. Comment l’altitude peut être bonne alors que la pression est erronée ?

    Apparemment il n’y a pas de setPressureCompensation, dommage. Je vais surveiller la régularité et ferai un +13 pour compenser.

    Merci
    Anthony

    1. Site passionelectronique.fr

      Salut Anthony !

      Là, j’avoue que ça dépasse mes compétences (la météorologie, et les écarts qu’on peut constater avec nos mesures).

      Je pense que je ferai comme toi pour commencer, c’est à dire rajouter un offset de 13, pour voir s’il n’y a pas un « simple » décalage à compenser. Sinon, j’approfondirais le datasheet du fabricant, ainsi que la librairie Arduino, pour voir si quelque chose ne nous aurait pas échappé.

      Désolé de ne pouvoir t’aider davantage,
      Jérôme.

  5. Site passionelectronique.fr

    Merci pour ton attention

    En fait sur le site Info climat, il affiche la pression atmosphérique ramenée au niveau de la mer pour avoir des valeurs comparables.

    Du coup J’ai trouvé sur le site « www.123calculus.com/calculer-pression-altitude-page-8-30-300.html » la formule très compliquée pour calculer la pression à une altitude donnée (en renseignant 2 ou 3 valeurs le site fait le calcul à notre place). J’ai donc rentré la pression atmosphérique au niveau de la mer mon altitude … et je suis retombé à une valeur proche de celle lue sur l’arduino.

    L’erreur est juste.
    Bonne soirée

  6. Site passionelectronique.fr

    (réponse à Anthony)

    Conclusion il faut reprendre la formule pour que le capteur affiche une pression atmosphérique ramenée au niveau de la mer. On a donc :
    P(ramenée niveau mer)=P(lue bmp280)*exp((0.0289644*9.80655*altitude/((8.31432*(température°C+273.15)))

  7. Site passionelectronique.fr

    (réponse à dmlk)

    Merci oui c’est bien ça.
    C’est la formule que j’ai mise en pratique.
    C’est l’exposant qui m’a posé problème (pow) en arduino c’était une première rencontre.

    Bonne soirée

  8. Site passionelectronique.fr

    Bonjour,

    J’ai utilisé ce programme avec mon BM280 « jamais servi », mais j’obtiens un échec d’initialisation suivi de résultats étranges :

    Initialisation du BME280, à l’adresse (0x76)
    –> ECHEC
    Température: nan °C
    Humidité = 0.00%
    Pression atmosphérique = nan hPa
    Altitude estimée = nan m

    Ce qui me laisse penser que le BME280 n’a pas été initialisé vu le message « ECHEC ». Pourtant son adresse est bien 0x76.

    Une solution ?
    Merci

    1. Site passionelectronique.fr

      Bonsoir !

      Si le programme te remonte un « échec », c’est que ton module n’a pas pu être initialisé (démarré). Les raisons qui me viennent à l’esprit sont :

      • soit le modèle que tu utilises n’est pas le bon (un BMP à la place d’un BME, par exemple)
      • soit ton modèle est « HS »
      • soit l’adresse n’est pas correcte (le « 0x76 » n’est pas la seule valeur possible)
      • soit il y a un mauvais câblage, au niveau des lignes de communication ou de l’alim de ton modèle

      Je pense que tu peux déjà commencer par là, pour identifier ton problème 😉

      Bon courage à toi,
      Jérôme.

      Nota : j’ai rajouté une « boucle infinie » dans le programme, afin qu’il « s’arrête » en cas d’échec de l’initialisation. Car c’est effectivement inutile d’aller plus loin dans le programme, dans ce cas là !

  9. Site passionelectronique.fr

    Excellent tuto ! Magnifique ! Merci pour le partage !

    Moi je me suis fait avoir car j’ai pris 6 modèles 5V mais j’avais pas noté que je n’aurai pas de SPI …
    – pour deux BME280 en IC2 : modifier l’adresse de l’un des deux
    – pour plus que deux BME280 en I2C : utiliser un multiplexeur type TCA9548A

  10. Site passionelectronique.fr

    Bonjour Jérôme,

    Juste un petit complément : le marquage sur le boîtier permet de distinguer les BME280 et les BMP280. Pour un BME280, c’est ‘UP’, tandis que pour un BMP280 c’est ‘K*’, avec * pouvant être P, U, N, W ou S. Donc la première lettre (U ou bien K) permet de différencier ces deux produits.

    Bien cordialement
    Jano

  11. Site passionelectronique.fr

    Bonjour.

    Merci pour ce tuto. Excellent travail de votre part. Merci.

    Ajout d’une précision pour différencier BME et BMP 280 :
    – le chip BME280 est carré.
    – le chip BMP280 est rectangulaire.

    Bien cordialement.

    1. Site passionelectronique.fr

      Salut Philippe !

      Excellente remarque, merci ! Effectivement, après vérification sur les docs du fabricant (Bosch) :
      – la puce BME 280 fait 2,5mm x 2,5mm (L x l)
      – et la puce BMP 280 fait 2mm x 2,5 mm (L x l)

      Encore merci pour ce tip 😉

      Bonne journée à toi,
      Jérôme.

  12. Site passionelectronique.fr

    Bonjour,

    Merci beaucoup pour le tuto !

    Cependant, j’ai un petit problème, que ce soit avec le scanner i2c ou le code servant à faire fonctionner le capteur. La carte que j’utilise est une Nano, et sur le capteur il n’y a pas de port VIN mais un port 3V3, que j’ai connecté à la patte 3V3 de la nano. En ce qui concerne le scanner i2c, il s’arrête à la ligne 32 du code sur la page, c’est-à-dire qu’il affiche uniquement « scanne toutes les adresses i2c, afin de récupérer tous les périphériques connectés à l’arduino ». Ensuite, pour le programme test du bme280, j’ai juste « programme test du BME280 » puis « initialisation du BME280, à l’adresse [0x76] ».

    Dans les 2 cas, j’ai fait un copié/collé des codes présents sur la page (que je vous remercie d’avoir publié au passage haha). J’espère que j’ai suffisamment bien détaillé mon problème pour que vous ayez une idée de résolution possible !

    Merci d’avance

    1. Site passionelectronique.fr

      Salut Théodore,

      Hum… c’est bizarre, en effet ! En tout cas, au niveau câblage, tout me semble bon. Car tu as bien fourni du 3,3 volts sur les broches d’alim de ton BME280 3V3, et comme les résistances pull-up i2c sont normalement situées de ce côté, les signaux SDA/SCL seront du type 0V / 3,3V (ce qui est compatible avec le 0V/5V du microcontrôleur de la carte Nano).

      Reste que si le programme « scanner I2C » plante au milieu de son exécution, le soucis vient peut-être de ton Arduino Nano en lui-même, de sa connexion vers ton PC, ou de ton câblage. Perso, je commencerai à vérifier ces points là, avant tout 😉

      Voilà ! Bon courage à toi.
      Jérôme.

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Symbole danger point d'exclamation site PSE, triangle jaune avec contour noir, texte noir alerte au milieuAfin 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. Par ailleurs, j'ai malheureusement plus de messages à traiter que de temps pour y répondre ; c'est pourquoi je ne pourrais pas répondre à tout le monde. Désolé …