BME280 Arduino : température, humidité, pression et altitude

Le BME280 est un capteur environnemental numérique fabriqué par Bosch qui mesure la température, l'humidité relative et la pression atmosphérique dans une seule puce minuscule. Pour l'utiliser avec un Arduino, il te suffit de quatre fils (VCC, GND, SDA, SCL) et de la bibliothèque Adafruit BME280 ; en quelques lignes de code, tu vois les valeurs en °C, % et hPa dans le moniteur série. Comme il mesure la pression, il peut aussi calculer ta hauteur au-dessus du niveau de la mer, autrement dit l'altitude. Son petit frère, le BMP280, lui ressemble presque trait pour trait mais ne mesure pas l'humidité : il ne donne que la température et la pression.

Dans ce guide, tu vas découvrir la différence entre les deux capteurs, pourquoi l'adresse I2C est tantôt 0x76 tantôt 0x77, comment les brancher sur Arduino Uno, ESP32 et Raspberry Pi Pico, comment fonctionne la formule d'altitude et comment choisir la bonne pression au niveau de la mer. Ensuite, tu construiras une mini station météo ESP32 qui s'ouvre sur ton téléphone, tu feras tourner sur la Pico un pilote MicroPython sans bibliothèque et tu verras comment un seul sketch démasque le problème très répandu du "BMP280 vendu comme BME280".

Qu'est-ce que le BME280 et comment fonctionne-t-il ?

Le BME280 contient trois éléments de mesure. Le capteur de pression mesure, par effet piézorésistif, la déformation d'une fine membrane de silicium sous la poussée de l'air. Le capteur d'humidité est une couche de polymère dont la capacité varie à mesure qu'elle absorbe l'humidité de l'air. Le capteur de température donne la température ambiante et sert aussi à corriger les deux autres mesures. Chaque puce est étalonnée individuellement en usine et ses coefficients sont enregistrés dans sa mémoire interne ; la bibliothèque les lit au démarrage et convertit les valeurs brutes en unités réelles avec les formules de la datasheet. Le petit trou du capot métallique laisse l'air atteindre le capteur : ne le bouche jamais avec du ruban adhésif ou de la colle.

En bref, le BMP280 est un BME280 un peu moins cher, sans capteur d'humidité ; ses mesures de pression et de température sont tout aussi bonnes. Si tu n'as besoin que de l'altitude ou de la pression atmosphérique, un BMP280 suffit. Pour les projets où l'humidité compte, comme une station météo, une serre ou la surveillance du climat d'une pièce, choisis le BME280. Un cran au-dessus, le BME680/BME688 ajoute un capteur de gaz qui détecte les composés organiques volatils (COV) dans l'air, mais il coûte plusieurs fois plus cher.

BME280 ou DHT11/DHT22 ?

Les capteurs DHT sont bon marché et simples, mais lents ; ils renvoient parfois des erreurs de lecture et ne mesurent pas la pression. Le BME280 partage le même bus I2C avec d'autres appareils comme un écran, ne consomme presque rien en veille et convient parfaitement aux projets qui tournent des mois sur piles. Pour les détails du DHT11, consulte Capteur de température et d'humidité DHT11, et pour voir toutes les options côte à côte, le comparatif des capteurs de température.

Types de modules et alerte 3,3 V

La puce nue est si petite qu'on l'utilise toujours sur un module, et deux types sont courants. Les modules à 6 broches (souvent violets, vendus sous le nom GY-BME280-3.3 ou GY-BMP280-3.3) ont les broches VCC, GND, SCL, SDA, CSB et SDO ; la plupart n'ont pas de régulateur, et c'est exactement ce que signifie le 3.3 du nom : alimente-les uniquement en 3,3 V. Les modules à 4 broches (VIN, GND, SCL, SDA) embarquent généralement un petit régulateur 3,3 V et souvent des transistors d'adaptation de niveau pour les lignes I2C ; ils peuvent donc aller sur la broche 5V de l'Arduino Uno. Si tu ne sais pas quel type tu as, cherche sur la carte une petite puce de régulateur à trois pattes ; s'il n'y en a pas, utilise le 3,3 V.

Branchement du BME280 : Arduino Uno, ESP32 et Pico

C'est sur l'adresse que la plupart des gens bloquent. Si la broche SDO de la puce est à GND, l'adresse est 0x76 ; si elle est à 3,3 V, c'est 0x77. La plupart des modules bon marché tirent SDO à GND par une résistance et utilisent donc 0x76, alors que les cartes Adafruit utilisent 0x77, et la bibliothèque essaie 0x77 par défaut. C'est pourquoi il vaut mieux écrire l'adresse explicitement dans le code. Si la broche CSB est à GND à la mise sous tension, la puce passe en mode SPI et ne répond plus en I2C ; si tu utilises l'I2C, relie CSB au 3,3 V ou vérifie que le module la tire déjà vers le haut. Tu trouveras les broches I2C de ta carte dans l'outil Pinout et le fonctionnement du bus dans Qu'est-ce que l'I2C ?.

Pour mettre deux capteurs sur le même bus, relie la broche SDO de l'un d'eux au 3,3 V afin de passer son adresse à 0x77 ; sur les modules à 4 broches, cela se fait généralement avec un pont de soudure au dos. Au-delà de deux capteurs, le SPI convient mieux : SCL va sur SCK (13 sur l'Uno), SDA sur MOSI (11), SDO sur MISO (12) et la broche CSB de chaque capteur sur sa propre broche numérique ; dans le code, il suffit de déclarer l'objet avec Adafruit_BME280 bme(10);. Comme l'Uno en 5 V pilote directement les lignes SPI, un adaptateur de niveau est indispensable entre lui et un module 3,3 V.

Installer la bibliothèque Adafruit BME280

1. Dans l'Arduino IDE, ouvre Outils > Gérer les bibliothèques et cherche Adafruit BME280.
2. Quand tu cliques sur Installer, choisis Install all dans la fenêtre qui parle des dépendances, pour installer aussi Adafruit Unified Sensor et Adafruit BusIO.
3. Si ton capteur est un BMP280, installe de la même façon la bibliothèque Adafruit BMP280 ; la bibliothèque du BME280 ne reconnaît pas le BMP280.
4. Si tu veux, ouvre Fichier > Exemples > Adafruit BME280 Library > bme280test, mais n'oublie pas de mettre l'adresse (0x76) dans la ligne begin().

Premier sketch : lire température, humidité et pression avec le BME280

1#include <Wire.h>
2#include <Adafruit_Sensor.h>
3#include <Adafruit_BME280.h>
4
5#define DENIZ_SEVIYESI_HPA 1013.25   // bugünkü deniz seviyesi basıncı / today's sea-level pressure
6
7Adafruit_BME280 bme;
8
9void setup() {
10  Serial.begin(9600);
11  // Önce 0x76, olmazsa 0x77 dene / try 0x76 first, then 0x77
12  if (!bme.begin(0x76) && !bme.begin(0x77)) {
13    Serial.println(F("BME280 bulunamadi! Kablolari ve adresi kontrol et."));
14    Serial.print(F("Chip ID: 0x"));
15    Serial.println(bme.sensorID(), HEX);       // 0x58 ise bu bir BMP280 / 0x58 means BMP280
16    while (true) delay(10);
17  }
18  Serial.println(F("BME280 hazir"));
19}
20
21void loop() {
22  float sicaklik = bme.readTemperature();          // °C
23  float nem      = bme.readHumidity();             // % bağıl nem / % relative humidity
24  float basinc   = bme.readPressure() / 100.0F;    // Pa -> hPa
25  float irtifa   = bme.readAltitude(DENIZ_SEVIYESI_HPA);   // metre / meters
26
27  Serial.print(F("Sicaklik: ")); Serial.print(sicaklik, 1); Serial.println(F(" C"));
28  Serial.print(F("Nem:      ")); Serial.print(nem, 1);      Serial.println(F(" %"));
29  Serial.print(F("Basinc:   ")); Serial.print(basinc, 1);   Serial.println(F(" hPa"));
30  Serial.print(F("Irtifa:   ")); Serial.print(irtifa, 0);   Serial.println(F(" m"));
31  Serial.println();
32  delay(2000);
33}

Une fois le sketch téléversé et le moniteur série ouvert à 9600 bauds, tu verras dans une pièce des valeurs d'environ 23,4 °C, 45 % d'humidité et 1009,8 hPa. La pression évolue lentement au fil des heures ; souffle sur le capteur et tu verras l'humidité grimper en quelques secondes, touche-le du doigt et la température monte. Par défaut, la bibliothèque mesure en continu en mode normal avec le suréchantillonnage le plus élevé (x16) ; c'est idéal pour un premier essai, mais comme tu le verras plus bas, un autre réglage donne des résultats plus précis pour les mesures météo sur la durée.

Modes de mesure : forced, normal et le bon réglage

Le BME280 a trois modes. En mode sleep, il ne mesure rien et consomme 0,1 µA. En mode forced, il fait une seule mesure puis se rendort ; pour chaque nouvelle valeur, tu appelles takeForcedMeasurement(). En mode normal, il mesure en continu de lui-même avec le temps de veille que tu as réglé. Le suréchantillonnage (oversampling) mesure plusieurs fois la même valeur et en fait la moyenne pour réduire le bruit, et le filtre IIR lisse les sauts de pression brusques (une porte qui claque, une rafale de vent). Dans sa datasheet, Bosch recommande ces réglages selon l'usage :

Pression au niveau de la mer et calcul de l'altitude

La pression de l'air diminue avec l'altitude, on peut donc calculer l'altitude à partir de la pression mesurée. La bibliothèque utilise cette formule barométrique : h = 44330 × (1 − (P / P0)^0,1903). Ici, P est la pression que tu mesures et P0 la pression actuelle au niveau de la mer (les deux en hPa). L'atmosphère standard prend P0 = 1013,25 hPa et, près du niveau de la mer, un écart de 1 hPa correspond à environ 8,3 mètres.

Le piège, c'est que P0 n'est pas fixe : elle varie en gros entre 990 et 1035 hPa selon la météo. Si la vraie valeur du jour est de 1023 hPa et que tu laisses 1013,25 dans le code, le capteur affichera une altitude inférieure d'environ 80 mètres. Pour des résultats justes, tu dois tenir P0 à jour : utilise la "pression ramenée au niveau de la mer" publiée par les services météo ou la valeur Q du METAR de l'aéroport le plus proche (par exemple Q1018, soit 1018 hPa). Tu peux aussi faire l'inverse : si tu connais l'altitude de ton emplacement, calcule P0 avec seaLevelForAltitude(altitude, pression). Par exemple, si le capteur mesure 905 hPa à Ankara (environ 938 m), la pression ramenée au niveau de la mer vaut environ 1012,6 hPa, exactement le chiffre que tu vois dans les applis météo.

Pour l'altitude absolue, la précision absolue de ±1 hPa représente une incertitude d'environ ±8 mètres. En mesure relative, en revanche, le capteur est bien meilleur : ±0,12 hPa ≈ ±1 m. Un étage d'immeuble fait environ 3 mètres, soit 0,36 hPa, donc le BME280 repère sans peine à quel étage tu te trouves ou si un ascenseur bouge. Le sketch ci-dessous prend comme référence la moyenne de 20 mesures au démarrage, puis affiche la hauteur par rapport à ce point et la pression au niveau de la mer calculée à partir d'une altitude connue :

1#include <Wire.h>
2#include <Adafruit_Sensor.h>
3#include <Adafruit_BME280.h>
4
5#define BILINEN_IRTIFA 938.0   // bulunduğun yerin rakımı (m), örnek Ankara / your altitude (m), e.g. Ankara
6
7Adafruit_BME280 bme;
8float referansHpa;             // açılıştaki basınç / pressure at start-up
9
10void setup() {
11  Serial.begin(9600);
12  if (!bme.begin(0x76)) {
13    Serial.println(F("BME280 bulunamadi!"));
14    while (true) delay(10);
15  }
16  // İç mekan navigasyonu ayarı: düşük gürültü / indoor navigation preset: low noise
17  bme.setSampling(Adafruit_BME280::MODE_NORMAL,
18                  Adafruit_BME280::SAMPLING_X2,    // sıcaklık / temperature
19                  Adafruit_BME280::SAMPLING_X16,   // basınç / pressure
20                  Adafruit_BME280::SAMPLING_X1,    // nem / humidity
21                  Adafruit_BME280::FILTER_X16,     // IIR filtre / IIR filter
22                  Adafruit_BME280::STANDBY_MS_0_5);
23  delay(1000);                                      // filtre otursun / let the filter settle
24
25  float toplam = 0;
26  for (int i = 0; i < 20; i++) {                   // 20 ölçümün ortalaması / average of 20 readings
27    toplam += bme.readPressure() / 100.0F;
28    delay(50);
29  }
30  referansHpa = toplam / 20;
31}
32
33void loop() {
34  float basinc = bme.readPressure() / 100.0F;                               // istasyon basıncı / station pressure
35  float denizSeviyesi = bme.seaLevelForAltitude(BILINEN_IRTIFA, basinc);    // hPa
36  float bagilYukseklik = bme.readAltitude(referansHpa);                     // başlangıca göre / relative to start
37
38  Serial.print(F("Istasyon basinci: "));   Serial.print(basinc, 2);         Serial.println(F(" hPa"));
39  Serial.print(F("Deniz seviyesi (QNH): ")); Serial.print(denizSeviyesi, 1); Serial.println(F(" hPa"));
40  Serial.print(F("Baslangica gore: "));    Serial.print(bagilYukseklik, 2); Serial.println(F(" m"));
41  Serial.println();
42  delay(1000);
43}

Si tu soulèves la carte du sol jusqu'au-dessus de ta tête, tu verras la valeur "Baslangica gore" (par rapport au départ) augmenter d'environ 2 mètres. Comme la pression atmosphérique varie de quelques hPa au cours de la journée, cette mesure relative dérive au bout de quelques heures ; en usage prolongé, il faut donc renouveler la référence de temps en temps. Pour stabiliser encore les valeurs, tu peux ajouter la moyenne glissante de l'article Filtrer les données d'un capteur.

Mini station météo avec ESP32 : une page web à ouvrir sur ton téléphone

Grâce au Wi-Fi de l'ESP32, tu peux consulter les mesures du BME280 sur une page web depuis n'importe quel téléphone ou ordinateur du même réseau. Le sketch ci-dessous utilise la bibliothèque WebServer fournie avec le core ESP32 : aucune bibliothèque supplémentaire n'est nécessaire. La page principale se charge une fois, puis un petit JavaScript va chercher du JSON sur /veri toutes les 5 secondes et met à jour les valeurs sans recharger la page. Le capteur fonctionne en mode forced, il ne mesure donc que lorsque quelqu'un regarde la page, et la pression est affichée ramenée au niveau de la mer pour que tu puisses la comparer aux prévisions météo. Si c'est ta première fois avec l'ESP32, commence par Qu'est-ce que l'ESP32 ?.

1. Branche le BME280 comme dans le tableau : VCC sur 3V3, SDA sur GPIO 21, SCL sur GPIO 22.
2. Saisis les informations de ton réseau dans les champs WIFI_ADI (nom du réseau) et WIFI_SIFRE (mot de passe) du code, et l'altitude de ton emplacement dans RAKIM_M.
3. Choisis la carte ESP32 Dev Module et téléverse le sketch.
4. Ouvre le moniteur série à 115200 bauds ; une fois connecté, il affiche l'adresse IP.
5. Tape cette adresse (par exemple 192.168.1.42) dans le navigateur d'un téléphone connecté au même réseau Wi-Fi ; les cartes de température, d'humidité et de pression apparaissent.

1#include <WiFi.h>
2#include <WebServer.h>
3#include <Wire.h>
4#include <Adafruit_Sensor.h>
5#include <Adafruit_BME280.h>
6
7const char* WIFI_ADI   = "WiFiAdin";      // kendi ağ adın / your network name
8const char* WIFI_SIFRE = "WiFiSifren";    // kendi şifren / your password
9const float RAKIM_M    = 938.0;           // bulunduğun yerin rakımı / your local altitude
10
11Adafruit_BME280 bme;
12WebServer server(80);
13
14// Telefonda açılan sayfa, 5 sn'de bir /veri'yi okur / phone page, reads /veri every 5 s
15const char SAYFA[] PROGMEM = R"rawliteral(
16<!DOCTYPE html><html><head><meta charset="utf-8">
17<meta name="viewport" content="width=device-width,initial-scale=1">
18<title>Mini Hava İstasyonu</title>
19<style>
20body{font-family:sans-serif;text-align:center;background:#0f172a;color:#e2e8f0;margin:0;padding:16px}
21.k{display:inline-block;min-width:140px;margin:8px;padding:16px;border-radius:14px;background:#1e293b}
22.d{font-size:2.2em;font-weight:bold;margin:6px 0}
23</style></head><body>
24<h2>Mini Hava İstasyonu</h2>
25<div class="k">Sıcaklık<div class="d" id="t">--</div>°C</div>
26<div class="k">Nem<div class="d" id="h">--</div>%</div>
27<div class="k">Basınç<div class="d" id="p">--</div>hPa</div>
28<script>
29async function guncelle() {
30  const v = await (await fetch('/veri')).json();
31  document.getElementById('t').textContent = v.t.toFixed(1);
32  document.getElementById('h').textContent = v.h.toFixed(0);
33  document.getElementById('p').textContent = v.p.toFixed(1);
34}
35guncelle();
36setInterval(guncelle, 5000);
37</script>
38</body></html>
39)rawliteral";
40
41void anaSayfa() {
42  server.send(200, "text/html", SAYFA);
43}
44
45void veriGonder() {
46  bme.takeForcedMeasurement();                     // tek ölçüm al, sonra uyu / one measurement, then sleep
47  float p = bme.readPressure() / 100.0F;
48  String json = "{\"t\":" + String(bme.readTemperature(), 2) +
49                ",\"h\":" + String(bme.readHumidity(), 1) +
50                ",\"p\":" + String(bme.seaLevelForAltitude(RAKIM_M, p), 1) + "}";
51  server.send(200, "application/json", json);
52}
53
54void setup() {
55  Serial.begin(115200);
56  Wire.begin(21, 22);                              // SDA, SCL
57  if (!bme.begin(0x76)) {
58    Serial.println("BME280 bulunamadi!");
59    while (true) delay(10);
60  }
61  // Hava durumu izleme ayarı: kendi kendini ısıtmayı azaltır / weather monitoring preset: less self-heating
62  bme.setSampling(Adafruit_BME280::MODE_FORCED,
63                  Adafruit_BME280::SAMPLING_X1,    // sıcaklık / temperature
64                  Adafruit_BME280::SAMPLING_X1,    // basınç / pressure
65                  Adafruit_BME280::SAMPLING_X1,    // nem / humidity
66                  Adafruit_BME280::FILTER_OFF);
67
68  WiFi.mode(WIFI_STA);
69  WiFi.begin(WIFI_ADI, WIFI_SIFRE);
70  while (WiFi.status() != WL_CONNECTED) {
71    delay(500);
72    Serial.print(".");
73  }
74  Serial.print("\nTarayicida ac / open in browser: http://");
75  Serial.println(WiFi.localIP());
76
77  server.on("/", anaSayfa);
78  server.on("/veri", veriGonder);
79  server.begin();
80}
81
82void loop() {
83  server.handleClient();
84}

BME280 avec la Raspberry Pi Pico (MicroPython)

MicroPython n'intègre aucun module pour le BME280. Au lieu de télécharger un fichier de pilote, le code ci-dessous embarque un petit pilote : il lit les coefficients d'étalonnage, fait prendre au capteur une seule mesure en mode forced et calcule le résultat avec les formules de la datasheet. Comme il vérifie le chip ID, il fonctionne aussi avec le BMP280 et saute tout seul la ligne d'humidité. Branche le capteur sur GP4 (SDA), GP5 (SCL) et 3V3(OUT), puis enregistre le code sur la Pico depuis Thonny sous le nom main.py. Si la Pico est nouvelle pour toi, Qu'est-ce que la Raspberry Pi Pico ? et Les bases de MicroPython te faciliteront la tâche.

1from machine import Pin, I2C
2import struct, time
3
4i2c = I2C(0, sda=Pin(4), scl=Pin(5), freq=400000)
5ADR = 0x76                                   # olmazsa 0x77 dene / try 0x77 if it fails
6P0 = 1013.25                                 # deniz seviyesi basıncı (hPa) / sea-level pressure (hPa)
7
8def s8(x):                                   # işaretli 8 bit / signed 8-bit
9    return x - 256 if x > 127 else x
10
11chip = i2c.readfrom_mem(ADR, 0xD0, 1)[0]
12BME = chip == 0x60                           # 0x60 BME280, 0x58 BMP280
13print("Chip ID:", hex(chip), "BME280" if BME else "BMP280 (nem yok / no humidity)")
14
15# Fabrika kalibrasyon katsayıları / factory calibration coefficients
16T1, T2, T3, P1, P2, P3, P4, P5, P6, P7, P8, P9 = struct.unpack("<HhhHhhhhhhhh", i2c.readfrom_mem(ADR, 0x88, 24))
17if BME:
18    H1 = i2c.readfrom_mem(ADR, 0xA1, 1)[0]
19    e = i2c.readfrom_mem(ADR, 0xE1, 7)
20    H2 = struct.unpack("<h", e[0:2])[0]
21    H3 = e[2]
22    H4 = (s8(e[3]) << 4) | (e[4] & 0x0F)
23    H5 = (s8(e[5]) << 4) | (e[4] >> 4)
24    H6 = s8(e[6])
25    i2c.writeto_mem(ADR, 0xF2, b"\x01")      # nem x1 (ctrl_meas'tan önce) / humidity x1 (before ctrl_meas)
26
27def oku():
28    i2c.writeto_mem(ADR, 0xF4, b"\x25")      # sıcaklık x1, basınç x1, forced mod / temp x1, press x1, forced mode
29    time.sleep_ms(15)                        # ölçümün bitmesini bekle / wait for the measurement
30    d = i2c.readfrom_mem(ADR, 0xF7, 8 if BME else 6)
31    adc_p = (d[0] << 12) | (d[1] << 4) | (d[2] >> 4)
32    adc_t = (d[3] << 12) | (d[4] << 4) | (d[5] >> 4)
33
34    # Sıcaklık (datasheet formülü) / temperature (datasheet formula)
35    v1 = (adc_t / 16384 - T1 / 1024) * T2
36    v2 = (adc_t / 131072 - T1 / 8192) ** 2 * T3
37    t_fine = v1 + v2
38    t = t_fine / 5120
39
40    # Basınç, Pa / pressure, Pa
41    v1 = t_fine / 2 - 64000
42    v2 = v1 * v1 * P6 / 32768 + v1 * P5 * 2
43    v2 = v2 / 4 + P4 * 65536
44    v1 = (P3 * v1 * v1 / 524288 + P2 * v1) / 524288
45    v1 = (1 + v1 / 32768) * P1
46    p = 1048576 - adc_p
47    p = (p - v2 / 4096) * 6250 / v1
48    p = p + (P9 * p * p / 2147483648 + p * P8 / 32768 + P7) / 16
49
50    h = None
51    if BME:                                  # nem, % / humidity, %
52        adc_h = (d[6] << 8) | d[7]
53        x = t_fine - 76800
54        x = (adc_h - (H4 * 64 + H5 / 16384 * x)) * (H2 / 65536 * (1 + H6 / 67108864 * x * (1 + H3 / 67108864 * x)))
55        x = x * (1 - H1 * x / 524288)
56        h = min(max(x, 0), 100)
57    return t, p / 100, h                     # °C, hPa, %
58
59while True:
60    t, p, h = oku()
61    irtifa = 44330 * (1 - (p / P0) ** 0.1903)    # metre / meters
62    print("Sicaklik: %.1f C  Basinc: %.1f hPa  Irtifa: %.0f m" % (t, p, irtifa))
63    if h is not None:
64        print("Nem: %.1f %%" % h)
65    time.sleep(2)

Quelques détails du code méritent ton attention. Le réglage d'humidité (registre 0xF2) ne prend effet qu'après une écriture dans 0xF4 ; c'est pourquoi on envoie d'abord le réglage d'humidité, puis l'ordre de mesure. La valeur 0x25 écrite dans 0xF4 signifie "température x1, pression x1, mode forced" ; avec ces réglages, une mesure dure au plus 10 ms environ, donc attendre 15 ms suffit. Testé avec les valeurs d'étalonnage d'exemple de la datasheet du BMP280 de Bosch, le code renvoie 25,08 °C et 1006,5 hPa : ses calculs correspondent exactement aux formules de Bosch.

Le BMP280 vendu comme BME280 : quel capteur as-tu vraiment ?

Comme les deux puces se montent sur le même circuit, certains vendeurs vendent des modules BMP280 comme des BME280 ; parfois, la carte indique seulement "BME/BMP280". Le symptôme est toujours le même : la bibliothèque Adafruit BME280 affiche "Could not find a valid BME280 sensor, check wiring, address, sensor ID!" et juste en dessous SensorID was: 0x58. D'autres bibliothèques n'affichent aucune erreur mais indiquent toujours une humidité de 0 ou nan. Ton câblage n'y est pour rien : ta puce est un BMP280, qui ne mesure pas l'humidité.

• Regarde la forme de la puce : si le capot métallique est carré (2,5 × 2,5 mm), c'est un BME280 ; s'il est nettement rectangulaire (2,0 × 2,5 mm), c'est un BMP280. Avec le zoom de l'appareil photo du téléphone, la différence se voit facilement.
• Lis le chip ID : la méthode la plus fiable est le sketch ci-dessous ; il lit l'identifiant dans le registre 0xD0 de la puce et t'indique de quel capteur il s'agit.
• Méfie-toi du prix : un vrai BME280 coûte nettement plus cher qu'un BMP280 ; sois méfiant face aux modules "BME280" vendus bien en dessous du prix du marché.

1#include <Wire.h>
2
3void setup() {
4  Serial.begin(9600);
5  Wire.begin();
6  bool bulundu = false;
7
8  for (uint8_t adres = 0x76; adres <= 0x77; adres++) {
9    Wire.beginTransmission(adres);
10    if (Wire.endTransmission() != 0) continue;   // bu adreste cihaz yok / no device at this address
11
12    Wire.beginTransmission(adres);
13    Wire.write(0xD0);                             // chip ID register'ı / chip ID register
14    Wire.endTransmission();
15    Wire.requestFrom(adres, (uint8_t)1);
16    uint8_t id = Wire.read();
17    bulundu = true;
18
19    Serial.print(F("Adres 0x"));
20    Serial.print(adres, HEX);
21    Serial.print(F("  Chip ID 0x"));
22    Serial.print(id, HEX);
23    if (id == 0x60)                    Serial.println(F("  -> BME280 (sicaklik + nem + basinc)"));
24    else if (id >= 0x56 && id <= 0x58) Serial.println(F("  -> BMP280 (nem olcmez)"));
25    else if (id == 0x61)               Serial.println(F("  -> BME680 / BME688"));
26    else if (id == 0x55)               Serial.println(F("  -> BMP180"));
27    else                               Serial.println(F("  -> bilinmeyen yonga / unknown chip"));
28  }
29
30  if (!bulundu) Serial.println(F("0x76 ve 0x77'de sensor yok: kablolari kontrol et"));
31}
32
33void loop() {
34}

Si le résultat est 0x58, pas de panique : les mesures de température et de pression du BMP280 sont aussi bonnes que celles du BME280. Installe la bibliothèque Adafruit BMP280 et utilise le sketch ci-dessous ; si tu as besoin de l'humidité, ajoute un DHT22 séparé au projet ou renvoie le produit. Il arrive aussi de tomber sur des échantillons de BMP280 avec l'ID 0x56 ou 0x57 ; pour eux, écris la ligne begin sous la forme bmp.begin(0x76, 0x56).

1#include <Wire.h>
2#include <Adafruit_BMP280.h>
3
4Adafruit_BMP280 bmp;
5
6void setup() {
7  Serial.begin(9600);
8  if (!bmp.begin(0x76) && !bmp.begin(0x77)) {
9    Serial.println(F("BMP280 bulunamadi! Kablolari ve adresi kontrol et."));
10    while (true) delay(10);
11  }
12  // Datasheet'in önerdiği varsayılan ayarlar / default settings from the datasheet
13  bmp.setSampling(Adafruit_BMP280::MODE_NORMAL,
14                  Adafruit_BMP280::SAMPLING_X2,     // sıcaklık / temperature
15                  Adafruit_BMP280::SAMPLING_X16,    // basınç / pressure
16                  Adafruit_BMP280::FILTER_X16,      // IIR filtre / IIR filter
17                  Adafruit_BMP280::STANDBY_MS_500); // bekleme süresi / standby time
18}
19
20void loop() {
21  Serial.print(F("Sicaklik: ")); Serial.print(bmp.readTemperature(), 1);       Serial.println(F(" C"));
22  Serial.print(F("Basinc:   ")); Serial.print(bmp.readPressure() / 100.0F, 1); Serial.println(F(" hPa"));
23  Serial.print(F("Irtifa:   ")); Serial.print(bmp.readAltitude(1013.25), 0);   Serial.println(F(" m"));
24  Serial.println();
25  delay(2000);
26}

Idées de projets avec le BME280

• Station météo de bureau : affiche température, humidité et pression sur un écran OLED ou un écran LCD I2C branché sur le même bus I2C.
• Prévision météo au baromètre : enregistre la pression toutes les heures ; une baisse de plus de 2 hPa en 3 heures annonce en général une dégradation du temps, alors qu'une hausse régulière annonce un ciel dégagé.
• Point de rosée et alerte moisissure : calcule le point de rosée avec la formule de Magnus (a = 17,62, b = 243,12 °C) et déclenche une alerte quand la température du mur s'en approche.
• Serre connectée : commande un ventilateur ou une pompe de brumisation selon l'humidité et la température ; tous les détails dans le projet de serre connectée avec Arduino.
• Enregistreur de données : écris les mesures sur un module carte SD ou, avec un ESP32, dans Google Sheets et trace une courbe hebdomadaire.
• Capteur domotique : envoie les valeurs depuis un ESP32 vers Home Assistant via MQTT.
• Station extérieure sur piles : réveille l'ESP32 de son deep sleep toutes les 10 minutes ; le BME280 ne consomme que 0,1 µA en veille.
• Compteur d'étages : utilise le sketch d'altitude relative pour afficher l'étage atteint dans l'ascenseur ou dans l'escalier.

Erreurs fréquentes et solutions

Le BME280 assure sur une seule petite carte toutes les mesures de base d'une station météo : commence par vérifier l'adresse et le chip ID, choisis ensuite le mode de mesure selon ton objectif et, pour l'altitude, garde la pression au niveau de la mer à jour. Dans l'application BlueGrays, tu trouveras des projets à combiner avec ce guide, comme la mesure de température et d'humidité avec le DHT11 et le DHT22, des écrans météo ESP32, un enregistreur de température et un serveur web ESP32, chacun avec schémas de circuit et code pas à pas.