Matière ESP32 : Température et humidité avec BME280 (Arduino)

Matière ESP32 : Température et humidité avec BME280 (Arduino)

Ce guide vous montre comment créer un appareil compatible Matter ESP32 qui envoie des mesures de température, d’humidité et de pression à partir d’un capteur BME280. L’appareil peut être mis en service dans Apple Home, Google Home, Amazon Alexa, Home Assistant ou d’autres contrôleurs Matter. L’ESP32 sera programmé avec Arduini IDE.

Température et humidité de la matière ESP32 avec BME280 Arduino Alexa Apple Home Google

Conditions préalables

Avant de poursuivre ce tutoriel, vous devez avoir installé les cartes ESP32 dans votre IDE Arduino :

Vous aurez également besoin d’un modèle de carte de développement ESP32 de votre choix et d’un contrôleur domotique comme Amazon Echo Dot Max (Alexa).

Introduction au protocole de matière

Matter, anciennement connu sous le nom de Project CHIP (Connected Home over IP), est un protocole de connectivité open source et standard de l’industrie pour les appareils domestiques intelligents. Le protocole Matter a été développé par la Connectivity Standards Alliance (CSA) avec la contribution de grandes entreprises, notamment Apple, Google, Amazon, Samsung et d’autres. Matter vise à résoudre le problème de fragmentation où chaque entreprise construit son propre protocole propriétaire pour interagir avec ses appareils.

Logo de l'icône de la matière

Principales caractéristiques du protocole Matter :

  • Interopérabilité : les appareils de différents fabricants fonctionnent ensemble de manière transparente dans le même écosystème (Apple Home, Google Home, Amazon Alexa, Home Assistant, Samsung SmartThings, etc…).
  • Contrôle local : la communication s’effectue principalement sur le réseau local (Wi-Fi, Thread ou Ethernet). La connectivité Cloud est facultative.
  • Sécurité : communication cryptée intégrée et mise en service sécurisée.
  • Configuration simple : les appareils sont mis en service à l’aide d’un code QR ou d’un code d’appairage manuel.
  • Prise en charge multi-administrateur : un seul appareil peut être contrôlé simultanément par plusieurs contrôleurs de maison intelligente.
  • Basé sur IP : fonctionne sur des réseaux IP standard.
Protocole Matter avec topologie de présentation ESP32

Quelques concepts à connaître avant de vous plonger dans ce guide :

  • Nœud : un seul appareil Matter (exemple : dans ce guide, l’ESP32 est un nœud).
  • Endpoint : une unité fonctionnelle à l’intérieur d’un nœud. Un seul nœud (appareil Matter) peut exposer plusieurs points de terminaison (exemple : capteur de température/humidité).
  • Cluster : un groupe d’attributs et de commandes associés liés à une fonction (exemple : le cluster de mesure de température a un attribut MeasuredValue).
  • Fabric : le réseau logique créé lorsqu’un contrôleur (Apple Home, Google Home, Alexa, Home Assistant, etc…) met en service votre appareil. Un nœud peut appartenir à plusieurs structures à la fois.
  • Mise en service : le processus d’attribution d’un appareil Matter (nœud) à une structure, à l’aide d’un code QR ou d’un code d’appairage manuel à 11 chiffres. Cela se fait généralement via BLE ou Wi-Fi.
  • Wi-Fi : Matter fonctionne sur IP et les nœuds (exemple : appareils ESP32) peuvent rejoindre un réseau Matter via Wi-Fi.

L’ESP32 Arduino Core depuis la version 3.1.0 est livré avec la bibliothèque Matter, vous n’avez donc pas besoin d’installer de bibliothèques supplémentaires dans votre IDE Arduino.

Flux de travail typique du périphérique de matière

Le diagramme suivant illustre le flux de travail complet d’un appareil Matter, depuis sa mise hors service jusqu’à son fonctionnement normal et son partage facultatif sur plusieurs écosystèmes de contrôleurs de maison intelligente.

Séquence typique du flux de travail du périphérique de topologie de protocole de matière

1. Appareil/nœud non mis en service

  • Première utilisation de l’appareil (ou après réinitialisation)
  • Affiche le code QR + le code d’appairage manuel
  • L’utilisateur scanne le code QR ou saisit le code d’appairage manuel dans un contrôleur de maison intelligente (tissu) : Alexa, Apple Home, Google Home, Home Assistant, etc…

2. Mise en service

  • La session d’appairage sécurisée démarre (PASE)
  • Confirme qu’il s’agit d’un appareil Matter
  • Les informations d’identification Wi-Fi sont fournies (généralement via BLE)
  • L’appareil rejoint le tissu Matter (exemple : Alexa – Echo Dot Max)

3. Rejoint le réseau

  • Se connecte au Wi-Fi
  • Devient accessible via IPv6 + mDNS

4. Fonctionnement normal

  • Les contrôleurs découvrent et contrôlent l’appareil Matter
  • Toutes les communications sont cryptées
  • Fonctionne localement même sans Internet

5. Multi-administrateur (facultatif)

  • Le code QR/de couplage d’origine ne peut pas être réutilisé
  • Ouvrez le mode d’appairage depuis la première application connectée pour générer/partager l’appareil en créant un nouveau code d’appairage manuel temporaire
  • Utilisez le nouveau code généré pour ajouter l’appareil à un autre écosystème : Apple Home, Google Home, Home Assistant, etc…
  • Le même appareil Matter appartient à plusieurs structures et peut être contrôlé par plusieurs écosystèmes en même temps

Puces ESP32 prises en charge

Les puces ESP32 suivantes prennent en charge le protocole Matter. De plus, il montre également lesquels prennent en charge CHIPoBLE. Pour les puces qui ne le prennent pas en charge, les informations d’identification doivent être insérées dans le croquis. Dans les autres scénarios, ils sont transférés via BLE depuis le contrôleur.

Ébrécher Chemin de mise en service CHIPOBBLE *
ESP32 Wi-Fi (entrez le SSID/mot de passe dans le croquis) Désactivé
ESP32-S2 Wi-Fi (entrez le SSID/mot de passe dans le croquis) Désactivé
ESP32-S3 Wi-Fi (tissu/contrôleur) Sur
ESP32-C3 Wi-Fi (tissu/contrôleur) Sur
ESP32-C5 Wi-Fi (tissu/contrôleur) Sur
ESP32-C6 Wi-Fi (tissu/contrôleur) Sur
ESP32-H2 Thread (tissu/contrôleur) Sur

* CHIPoBLE signifie CHIP (Connected Home over IP), le nom original du protocole Matter, sur BLE (Bluetooth Low Energy).

Pièces requises

Pour réaliser ce didacticiel, vous avez besoin des pièces suivantes :

Vous pouvez utiliser les liens précédents ou vous rendre directement sur MakerAdvisor.com/tools pour trouver toutes les pièces pour vos projets au meilleur prix !

1794555436 840 Matiere ESP32 Temperature et humidite avec BME280 Arduino

Le module capteur BME280 lit la pression barométrique, la température et l’humidité. Il existe plusieurs versions de ce module capteur. Nous utilisons le module illustré dans la figure ci-dessous.

Le module I2C du capteur BME280 lit la pression, la température et l'humidité.

Ce capteur communique via le protocole de communication I2C. Vous pouvez utiliser les broches ESP32 I2C par défaut comme indiqué dans le tableau suivant :

BME280 ESP32 ESP32-S3
Vin 3,3 V 3,3 V
GND GND GND
SCL GPIO22 GPIO9
SDA GPIO21 GPIO8

Si vous possédez un autre modèle de carte ESP32, vérifiez son brochage pour localiser les broches I2C par défaut.

Schéma – ESP32 avec BME280 utilisant I2C

Câblez le capteur BME280 aux broches ESP32 SDA et SCL, comme indiqué dans le schéma suivant (vérifiez la référence de brochage ESP32).

ESP32 avec schéma de câblage BME280 I2C

Dans le cas des cartes ESP32-S3, les broches I2C sont SDA connectées au GPIO 8 et SCL connectées au GPIO 9, comme indiqué dans le schéma suivant (consultez le guide de référence GPIO ESP32-S3).

Schéma de câblage du capteur ESP-IDF ESP32 BME280 I2C SDA SCL

Installation de la bibliothèque BME280

Pour ce tutoriel, nous utiliserons un capteur BME280 et la bibliothèque Adafruit_BME280. Installez-le avant de continuer.

Dans l’IDE Arduino, accédez à Sketch > Inclure la bibliothèque > Gérer les bibliothèques… et recherchez le nom de la bibliothèque : Adafruit BME280. Vous devez également installer la bibliothèque de capteurs unifiés Adafruit (une fenêtre contextuelle s’affiche pour l’installer si vous ne l’avez pas déjà fait)

Installation de la bibliothèque de capteurs Adafruit BME280 Arduino IDE

Arduino Sketch – Dispositif ESP32 Matter : envoyer la température, l’humidité et la pression

L’exemple suivant est basé sur la bibliothèque officielle Espressif Arduino ESP32 Matter. Il transforme votre ESP32 en un appareil Matter (nœud) entièrement fonctionnel qui envoie des lectures à partir d’un capteur BME280. L’appareil peut être mis en service dans n’importe quel écosystème Matter majeur.

/*
  Rui Santos & Sara Santos - Raspberryme.com
  Complete project details at https://Raspberryme.com/esp32-matter-temperature-humidity-bme280-arduino/
  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files.
  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
*/
#include 
#include 
#include 
#include 

// Wi-Fi credentials for this sketch. Fill these in when the board cannot commission over BLE (Arduino prebuild on ESP32 / ESP32-S2): the sketch
// joins the AP itself. When Matter commissions over BLE (CHIPoBLE), the hub sends SSID and password — leave the placeholders; they are unused.
#define WIFI_SSID     "your-ssid"
#define WIFI_PASSWORD "your-password"

// Matter endpoints
MatterTemperatureSensor TemperatureSensor;
MatterHumiditySensor HumiditySensor;
MatterPressureSensor PressureSensor;

// I2C pins for the BME280
#define I2C_SDA 8
#define I2C_SCL 9

// BME280 
Adafruit_BME280 bme;

// Latest BME280 readings
float temperature, humidity, pressure;

// Update interval for the BME280 sensor readings (in milliseconds)
const uint32_t SENSOR_INTERVAL_MS = 30000;

// Button pin for decommissioning the Matter accessory
const uint8_t buttonPin = BOOT_PIN;
MatterButton button;

// Read BME280 sensor values
bool readBME280() {
  temperature = bme.readTemperature();
  humidity = bme.readHumidity();
  pressure = bme.readPressure() / 100.0F;
  return !(isnan(temperature) || isnan(humidity) || isnan(pressure));
}

void setup() {
  button.begin(buttonPin);

  Serial.begin(115200);

  // Initialize BME280 Sensor
  Wire.begin(I2C_SDA, I2C_SCL);
  if (!bme.begin(0x76, &Wire) && !bme.begin(0x77, &Wire)) {
    Serial.println("BME280 not found!");
    while(1); 
  }

// Connect to Wi-Fi if CHIPoBLE is not enabled
#if !CONFIG_ENABLE_CHIPOBLE
  matterConnectWiFi(WIFI_SSID, WIFI_PASSWORD);
#endif

  // Read initial sensor values and initialize Matter endpoints
  readBME280();
  TemperatureSensor.begin(temperature);
  HumiditySensor.begin(humidity);
  PressureSensor.begin(pressure);

  // Start Matter stack and wait until ready
  Matter.begin();
  matterWaitUntilReady();
}

void loop() {
  matterRestartIfNoFabric();

  static uint32_t lastUpdate = 0;
  // Read BME280 sensor values at defined intervals
  if (millis() - lastUpdate >= SENSOR_INTERVAL_MS) {
    lastUpdate = millis();

    if (readBME280()) {
      Serial.printf("Temperature: %.2f C | Humidity: %.2f %% | Pressure: %.2f hPa\r\n",
                    temperature, humidity, pressure);

      TemperatureSensor.setTemperature(temperature);
      HumiditySensor.setHumidity(humidity);
      PressureSensor.setPressure(pressure);
    }
  }

  matterButtonEvent_t ev;
  // Poll the button for events and handle long hold for decommissioning
  while ((ev = button.poll()) != MATTER_BUTTON_NONE) {
    if (ev == MATTER_BUTTON_LONG_HOLD) {
      Serial.println("Decommissioning Matter Accessory. It shall be commissioned again.");
      Matter.decommission();
    }
  }

  delay(100);
}

Afficher le code brut

Vous devez sélectionner dans les Outils – Schéma de partition : « Huge APP (3MB No OT /1MB SPIFFS) » et le code fonctionnera immédiatement. En fonction de votre carte, vous devrez peut-être insérer vos informations d’identification réseau dans les lignes suivantes du code.

#define WIFI_SSID "REPLACE_WITH_YOUR_SSID";
#define WIFI_PASSWORD "REPLACE_WITH_YOUR_PASSWORD";

Comment fonctionne le code

Continuez à lire pour découvrir comment fonctionne le code ou passez à la section Démonstration.

Y compris les bibliothèques

Commencez par inclure les bibliothèques suivantes :

#include 
#include 
#include 
#include 
  • Matter.h – Bibliothèque Main Matter (gère la pile de protocoles)
  • Wire.h – bibliothèque pour la communication I2C (Two-Wire Interface)
  • Adafruit_BME280.h – bibliothèque pour capteur environnemental BME280. Il lit la température, l’humidité et la pression barométrique

Informations d’identification réseau

Ces informations d’identification Wi-Fi ne sont nécessaires que si la carte ne peut pas être mise en service via BLE (préconstruction Arduino sur ESP32 ou ESP32-S2), auquel cas le croquis rejoint le réseau lui-même. Lorsque Matter utilise la mise en service BLE (CHIPoBLE), le hub fournit le SSID et le mot de passe, vous pouvez donc laisser les espaces réservés SSID/Mot de passe par défaut.

#define WIFI_SSID "REPLACE_WITH_YOUR_SSID";
#define WIFI_PASSWORD "REPLACE_WITH_YOUR_PASSWORD";

Points de terminaison du sujet

Ces lignes suivantes créent trois objets capteurs Matter sur l’ESP32. Chaque objet représente un appareil Matter virtuel qui peut rapporter la mesure de son capteur à un contrôleur Matter.

MatterTemperatureSensor TemperatureSensor;
MatterHumiditySensor HumiditySensor;
MatterPressureSensor PressureSensor;

BME280

Définissez les broches auxquelles le capteur BME280 est connecté. Nous utilisons les GPIO 8 et 9 (ESP32-S3).

// I2C pins for the BME280
#define SDA_PIN 8
#define SCL_PIN 9

Créez une instance d’Adafruit_BME280 appelée bme.

Adafruit_BME280 bme;

Variables qui stockeront les lectures du capteur :

float temperature, humidity, pressure;

L’intervalle de mise à jour des lectures du capteur BME280 (en millisecondes) par défaut est défini sur 30 000 ms (30 secondes).

const uint32_t SENSOR_INTERVAL_MS = 30000;

Bouton DE DÉMARRAGE

Nous utiliserons le bouton BOOT intégré de l’ESP32 (généralement GPIO 0) pour le contrôle GPIO local et la réinitialisation d’usine (mise hors service).

const uint8_t buttonPin = BOOT_PIN;
MatterButton button;

Prendre de nouvelles lectures

Cette fonction prend une nouvelle mesure BME280 : lit la température, l’humidité et la pression. Ensuite, il renvoie vrai si les trois lectures sont valides.

bool readBME280() {
  temperature = bme.readTemperature();
  humidity = bme.readHumidity();
  pressure = bme.readPressure() / 100.0F;
  return !(isnan(temperature) || isnan(humidity) || isnan(pressure));
}

installation()

La fonction setup() commence par initialiser le boutonPin. Il démarre également la communication série.

void setup() {
  button.begin(buttonPin);

  Serial.begin(115200);

Cette section de code initialise le bus I2C sur les broches spécifiées, tente de se connecter à un capteur BME280 en utilisant l’adresse 0x76 ou 0x77. Ensuite, il configure le capteur pour des mesures en mode forcé avec un suréchantillonnage minimal et aucun filtrage.

// Initialize BME280 Sensor
Wire.begin(I2C_SDA, I2C_SCL);
if (!bme.begin(0x76, &Wire) && !bme.begin(0x77, &Wire)) {
  Serial.println("BME280 not found!");
  while(1); 
}

En fonction de votre carte, il se connecte au Wi-Fi à l’aide des informations d’identification du réseau si CHIPoBLE est désactivé.

// CONFIG_ENABLE_CHIPOBLE=n: sketch starts Wi-Fi here; with CHIPoBLE the hub delivers credentials.
#if !CONFIG_ENABLE_CHIPOBLE
  matterConnectWiFi(WIFI_SSID, WIFI_PASSWORD);
#endif

Lisez les valeurs initiales du capteur et initialisez les points de terminaison de Matter :

readBME280();
TemperatureSensor.begin(temperature);
HumiditySensor.begin(humidity);
PressureSensor.begin(pressure);

La première ligne commence la pile Matter et attend qu’elle soit complètement prête.

Matter.begin();
matterWaitUntilReady();

boucle()

La boucle() commence par appeler la fonction MatterRestartIfNoFabric(). Il s’agit d’une fonction d’assistance qui vérifie si l’appareil fait toujours partie d’une structure Matter (il est toujours commandé à un contrôleur). Si l’appareil n’a pas de structure (il est actuellement mis hors service), il redémarre la pile Matter afin qu’elle puisse être découverte et mise en service.

matterRestartIfNoFabric();

L’extrait suivant lit le capteur BME280 toutes les 30 secondes, imprime les valeurs en série et met à jour les trois points de terminaison du capteur Matter avec les nouvelles lectures (en conservant les valeurs précédentes si la lecture échoue).

static uint32_t lastUpdate = 0;
// Read BME280 sensor values at defined intervals
if (millis() - lastUpdate >= SENSOR_INTERVAL_MS) {
  lastUpdate = millis();

  if (readBME280()) {
    Serial.printf("Temperature: %.2f C | Humidity: %.2f %% | Pressure: %.2f hPa\r\n",
                  temperature, humidity, pressure);

    TemperatureSensor.setTemperature(temperature);
    HumiditySensor.setHumidity(humidity);
    PressureSensor.setPressure(pressure);
  }
}

Déclare une variable ev de type MatterButtonEvent_t qui vérifie les événements de bouton (appui long).

matterButtonEvent_t ev;

Enfin, si le bouton BOOT intégré est enfoncé pendant plus de 5 secondes, il supprime l’appareil de tous les tissus Matter (réinitialisation d’usine). L’appareil devra être à nouveau mis en service.

while ((ev = button.poll()) != MATTER_BUTTON_NONE) {
  if (ev == MATTER_BUTTON_LONG_HOLD) {
    Serial.println("Decommissioning Matter Accessory. It shall be commissioned again.");
    Matter.decommission();
  }
}

Téléchargez le code sur votre tableau

Après avoir inséré vos informations d’identification réseau, suivez ces étapes suivantes pour télécharger le code sur la carte ESP32.

Tout d’abord, sélectionnez votre carte : Outils – Carte – ESP32 Arduino – sélectionnez votre carte (par exemple, ESP32S3 Dev Module).

Ensuite, allez dans Outils et sélectionnez le schéma de partition : « Huge APP (3MB No OT /1MB SPIFFS) »

ESP32 Matter Device Sélectionnez un énorme schéma de partition d'application Arduino IDE

Important : avant le premier téléchargement, nous vous recommandons d’effacer toute la mémoire flash. Accédez à Outils et activez l’option Effacer tout le flash avant le téléchargement de l’esquisse : activé. Cela efface les informations d’identification Wi-Fi précédentes et les données de structure Matter. Faites-le au moins lors du premier téléchargement ou en cas d’échec de la mise en service.

ESP32 Matter Device Effacement de la mémoire Flash activé Arduino IDE

Enfin, après avoir branché votre carte sur votre ordinateur et sélectionné le bon port série, cliquez sur le bouton Arduino IDE Upload.

Bouton de téléchargement Arduino IDE 2

Mise en service de votre appareil ESP32 Matter

Au premier démarrage de l’ESP32 (ou après avoir effacé toute la mémoire flash), ouvrez votre moniteur série Arduino IDE, appuyez sur le bouton RST/EN intégré de l’ESP32.

Ouvrir le moniteur série Arduino 2

Il devrait imprimer quelque chose comme ceci :

ESP32 Matter Device Scannez le code QR ou copiez le code de couplage manuel Moniteur série Arduino IDE

Vous pouvez soit utiliser le code de couplage manuel à 11 chiffres, soit ouvrir l’URL dans votre navigateur pour obtenir un code QR à scanner dans votre application pour maison intelligente.

ESP32 Matter Device Scanner le code QR

Ajouter un appareil Matter à Amazon Alexa

Pour cet exemple, nous utiliserons l’application Amazon Alexa, mais dans la section suivante, nous montrerons les étapes à ajouter à d’autres applications de contrôleur.

Tout d’abord, ouvrez l’application Amazon Alexa et appuyez sur l’icône + :

Nœud de périphérique ESP32 Matter Ajouter à Alexa

Choisissez l’option Ajouter un appareil :

Nœud de périphérique ESP32 Matter Ajout d'un périphérique à Alexa

Sélectionnez Logo Matter ou Autre.

ESP32 Matter Ajouter un nœud de périphérique Sélectionnez l'option Matter

Lorsqu’on vous demande si l’appareil a un logo, sélectionnez l’option « OUI ». Ensuite, scannez le code QR ou saisissez le code d’appairage manuel :

ESP32 Matter Oui Ajouter un appareil Matter

Ayant votre appareil assez proche de l’appareil concerné, cliquez sur « Connecter ».

Carte de connexion de nœud de périphérique ESP32 Matter

L’ESP32 n’est pas certifié Matter, mais ajoutez l’appareil en appuyant sur Oui.

Nœud de périphérique ESP32 Matter Oui, ajoutez-le

Votre appareil ESP32 Matter sera trouvé et connecté ; cliquez sur Suivant.

Configuration complète du nœud de périphérique de capteur de matière ESP32

Après une mise en service réussie, le moniteur série Arduino IDE imprime « Matter Node is commissioned… » et la LED reflète l’état actuel.

Moniteur série Arduino IDE connecté au nœud Alexa connecté au dispositif ESP32 Matter

Vos relevés de température et d’humidité seront ajoutés à votre liste d’appareils. Vous pouvez l’ouvrir comme indiqué dans l’image suivante.

Dispositif de capteur de matière ESP32 signalant les lectures de température

Remarque : l’attribut Température de la matière est défini en Celsius. Le contrôleur le convertit pour l’affichage, de sorte qu’Alexa affiche Fahrenheit si les paramètres de votre téléphone ou de votre application sont définis sur Fahrenheit.

Ajouter un appareil Matter à Apple Home, Google Home, Home Assistant ou SmartThings

Voici les instructions rapides sur la façon d’ajouter un appareil Matter à différentes applications de contrôleur. Le contrôleur doit fonctionner dans votre maison comme Apple Home, Google Home, Home Assistant ou SmartThings.

  • Accueil Apple :
    • Ouvrez l’application iPhone Accueil
    • Appuyez sur l’icône + dans le coin supérieur droit
    • Ajouter un accessoire
    • Scannez le code QR ou appuyez sur le lien « Plus d’options » pour saisir le code d’appairage manuel
  • Accueil Google :
    • Ouvrez l’application Google Home
    • Appuyez sur l’icône +
    • Configurer l’appareil
    • Nouvel appareil
    • Appareil matière
    • Scannez le code QR ou entrez le code d’appairage manuel
  • Assistante à domicile :
    • Assistant à domicile ouvert
    • Allez dans Paramètres
    • Appareils et services
    • Ajouter une intégration
    • Matière
    • Entrez le code d’appairage manuel ou scannez le code QR
  • Objets intelligents Samsung :
    • Ouvrez l’application SmartThings
    • Appuyez sur l’icône +
    • Sélectionnez les appareils partenaires : Matter
    • Scannez le code QR ou entrez le code d’appairage manuel

Important : après avoir mis en service un appareil Matter sur un contrôleur, vous ne pouvez pas réutiliser le code QR d’origine ou le code d’appairage manuel pour l’ajouter à un autre contrôleur. Au lieu de cela, vous devez ouvrir une nouvelle fenêtre de mise en service à partir de l’application du premier contrôleur (Partager / Activer le mode d’appairage / Lien vers une autre plate-forme) pour générer un nouveau code temporaire, puis utiliser ce code pour partager l’appareil sur la nouvelle plate-forme.

Remarque : certaines applications peuvent avertir qu’il ne s’agit pas d’un appareil officiel ou certifié, mais vous devez sélectionner l’option pour l’ajouter.

Démonstration

Depuis une application Matter (comme Alexa) ou un hub vocal, vous pouvez afficher ou demander les valeurs de température et d’humidité.

Démonstration des lectures de la température et de l'humidité du dispositif ESP32 Matter

Vous pouvez également surveiller les lectures envoyées toutes les 30 secondes dans le moniteur série Arduino IDE.

Démonstration des lectures du capteur d'envoi du dispositif ESP32 Matter

IMPORTANT : vous pouvez maintenir le bouton ESP32 BOOT enfoncé pendant plus de 5 secondes pour mettre hors service l’appareil Matter (réinitialisation d’usine). L’appareil doit ensuite être remis en service avec un nouveau code QR ou en saisissant le code d’appairage manuel.

Intégration de l’assistant à domicile

Certains contrôleurs Matter (Alexa, Apple Home) ne prennent pas en charge la pression, mais Home Assistant le fait. Vous pouvez mettre en service cet appareil Matter dans votre installation Home Assistant pour afficher les trois lectures BME280.

Appareil ESP32 Matter connecté à Home Assistant

Arduino Sketch – Dispositif ESP32 Matter en mode veille profonde : température, humidité et pression

L’exemple suivant transforme votre ESP32 en un appareil Matter fonctionnel (nœud) qui est constamment en veille profonde pour économiser de l’énergie, afin qu’il puisse être alimenté par batterie. Ensuite, il se réveille à intervalles réguliers pour envoyer les lectures d’un capteur BME280.

/*
  Rui Santos & Sara Santos - Raspberryme.com
  Complete project details at https://Raspberryme.com/esp32-matter-temperature-humidity-bme280-arduino/
  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files.
  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
*/
#include 
#include 
#include 
#include 
#include "esp_sleep.h"

// Matter endpoints
MatterTemperatureSensor TemperatureSensor;
MatterHumiditySensor HumiditySensor;
MatterPressureSensor PressureSensor;

// Wi-Fi credentials for this sketch. Fill these in when the board cannot commission over BLE (Arduino prebuild on ESP32 / ESP32-S2): the sketch
// joins the AP itself. When Matter commissions over BLE (CHIPoBLE), the hub sends SSID and password — leave the placeholders; they are unused.
#define WIFI_SSID     "your-ssid"
#define WIFI_PASSWORD "your-password"

// I2C pins for the BME280
#define I2C_SDA 8
#define I2C_SCL 9

// These 4 strings are used for Matter device identity and commissioning (They have a limit of 32 characters)
const char* MATTER_VENDOR_NAME = "MyESP32";         
const char* MATTER_PRODUCT_NAME = "BME280 Sensor";     
const char* MATTER_DEVICE_NAME = "Living Room BME280";
const char* MATTER_SERIAL_NUMBER = "BME-001";           

// Hardware version
const uint16_t MATTER_HW_VERSION = 1;
// Hardware version string
const char* MATTER_HW_VERSION_STR = "RevA";               

// Commissioning codes: custom manual pairing code / QR code 
const uint32_t MATTER_SETUP_PASSCODE = 20202021;   // 8-digit setup PIN
const uint16_t MATTER_SETUP_DISCRIMINATOR = 0xF00; // 0–4095

const uint32_t FIRST_AWAKE_MS = 5UL * 60UL * 1000UL;  // 5 minutes after first boot or board reset
const uint32_t SENSOR_INTERVAL_MS = 30000;            // 30s while fully awake
const uint32_t SLEEP_TIME_SECONDS = 60;               // Deep sleep interval
const uint32_t ONLINE_TIMEOUT_MS = 20000;             // Wait for CASE on timer wake
const uint32_t POST_UPDATE_AWAKE_MS = 10000;          // Stay awake after publish

// Button pin for decommissioning the Matter accessory
const uint8_t buttonPin = BOOT_PIN;
MatterButton button;

Adafruit_BME280 bme;

bool isTimerWake = false;
uint32_t awakeStartMs = 0;

// Read BME280 sensor values
bool readBME280(float &temperature, float &humidity, float &pressure) {
  if (!bme.takeForcedMeasurement()) {
    return false;
  }
  temperature = bme.readTemperature();
  humidity = bme.readHumidity();
  pressure = bme.readPressure() / 100.0F;
  return !(isnan(temperature) || isnan(humidity) || isnan(pressure));
}

// Go to deep sleep for SLEEP_TIME_SECONDS
void goToDeepSleep() {
  uint64_t sleep_us = (uint64_t)SLEEP_TIME_SECONDS * 1000000ULL;
  esp_sleep_enable_timer_wakeup(sleep_us);

  Serial.printf("Going to deep sleep for %u seconds...\r\n", SLEEP_TIME_SECONDS);
  Serial.flush();
  delay(50);
  esp_deep_sleep_start();
}

// Update sensor readings and publish to Matter endpoints
void updateSensorsAndMatter() {
  float t, h, p;
  if (readBME280(t, h, p)) {
    Serial.printf("Temperature: %.2f C | Humidity: %.2f %% | Pressure: %.2f hPa\r\n", t, h, p);

    TemperatureSensor.setTemperature
    HumiditySensor.setHumidity(h);
    PressureSensor.setPressure(p);
  } else {
    Serial.println("BME280 read failed.");
  }
}

// Handle button events for decommissioning
void handleButton() {
  matterButtonEvent_t ev;
  while ((ev = button.poll()) != MATTER_BUTTON_NONE) {
    if (ev == MATTER_BUTTON_LONG_HOLD) {
      Serial.println("Decommissioning Matter Accessory. It shall be commissioned again.");
      Matter.decommission();
    }
  }
}

// Apply Matter device identity and commissioning codes
void applyMatterIdentity() {
  // These configurations must be called BEFORE Matter.begin()
  Matter.setVendorName(MATTER_VENDOR_NAME);
  Matter.setProductName(MATTER_PRODUCT_NAME);
  Matter.setDeviceName(MATTER_DEVICE_NAME);
  Matter.setSerialNumber(MATTER_SERIAL_NUMBER);
  Matter.setHardwareVersion(MATTER_HW_VERSION);
  Matter.setHardwareVersionString(MATTER_HW_VERSION_STR);

  Matter.setSetupPasscode(MATTER_SETUP_PASSCODE);
  Matter.setSetupDiscriminator(MATTER_SETUP_DISCRIMINATOR);

  Serial.println("Matter identity configured:");
  Serial.printf(" Vendor: %s\r\n", MATTER_VENDOR_NAME);
  Serial.printf(" Product: %s\r\n", MATTER_PRODUCT_NAME);
  Serial.printf(" Device: %s\r\n", MATTER_DEVICE_NAME);
  Serial.printf(" Passcode: %lu\r\n", (unsigned long)MATTER_SETUP_PASSCODE);
  Serial.printf(" Discriminator: 0x%03X (%u)\r\n", MATTER_SETUP_DISCRIMINATOR, MATTER_SETUP_DISCRIMINATOR);
}

void setup() {
  button.begin(buttonPin);
  Serial.begin(115200);
  delay(100);

  // Check wakeup reason
  esp_sleep_wakeup_cause_t cause = esp_sleep_get_wakeup_cause();
  isTimerWake = (cause == ESP_SLEEP_WAKEUP_TIMER);
  if (isTimerWake) {
    Serial.println("Wakeup caused by timer. It will go back to deep sleep after publishing readings.");
  } else {
    Serial.println("ESP32 first boot / reset. It will stay awake for 5 minutes to allow commissioning.");
  }

  // Initialize BME280 sensor
  Wire.begin(I2C_SDA, I2C_SCL);
  if (!bme.begin(0x76, &Wire) && !bme.begin(0x77, &Wire)) {
    Serial.println("BME280 not found - check wiring and I2C pins.");
    while (true) delay(1000);
  }
  bme.setSampling(
    Adafruit_BME280::MODE_FORCED,
    Adafruit_BME280::SAMPLING_X1,
    Adafruit_BME280::SAMPLING_X1,
    Adafruit_BME280::SAMPLING_X1,
    Adafruit_BME280::FILTER_OFF
  );

// Connect to Wi-Fi if CHIPoBLE is not enabled
#if !CONFIG_ENABLE_CHIPOBLE
  matterConnectWiFi(WIFI_SSID, WIFI_PASSWORD);
#endif

  // Read initial sensor values and initialize Matter endpoints
  float t = 0, h = 0, p = 0;
  if (!readBME280(t, h, p)) {
    t = h = p = 0;
  }
  TemperatureSensor.begin
  HumiditySensor.begin(h);
  PressureSensor.begin(p);

  // Apply Matter identity and commissioning codes
  applyMatterIdentity();

  // Start Matter stack and wait until ready
  Matter.begin();
  matterWaitUntilReady();

  // If not commissioned, print manual pairing code and QR code URL
  if (!Matter.isDeviceCommissioned()) {
    Serial.println("----------------------------------------");
    Serial.println("Device not commissioned yet.");
    Serial.printf("Manual pairing code: %s\r\n", Matter.getManualPairingCode().c_str());
    Serial.printf("QR code URL: %s\r\n", Matter.getOnboardingQRCodeUrl().c_str());
    Serial.println("----------------------------------------");
  }

  matterRestartIfNoFabric();

  // If this is a timer wakeup, wait for CASE session and publish readings
  if (isTimerWake) {
    uint32_t t0 = millis();
    while (!Matter.isOnline() && (millis() - t0) < ONLINE_TIMEOUT_MS) {
      matterRestartIfNoFabric();
      handleButton();
      delay(100);
    }

    if (Matter.isOnline()) {
      Serial.println("Controller online (CASE up) – publishing readings");
    } else {
      Serial.println("WARNING: Controller not online – publishing anyway");
    }

    // Publish sensor values
    updateSensorsAndMatter();

    // Stay awake so reports can reach Alexa; re-publish halfway
    Serial.printf("Staying awake %u ms...\r\n", POST_UPDATE_AWAKE_MS);

    t0 = millis();
    bool resent = false;
    while (millis() - t0 < POST_UPDATE_AWAKE_MS) {
      matterRestartIfNoFabric();
      handleButton();

      if (!resent && (millis() - t0) > (POST_UPDATE_AWAKE_MS / 2)) {
        Serial.println("Re-publishing readings...");
        updateSensorsAndMatter();
        resent = true;
      }

      delay(50);
    }

    goToDeepSleep();
  }

  // First boot / reset: one update, then 5 minute fully awake to allow commissioning to other controllers
  updateSensorsAndMatter();
  awakeStartMs = millis();
  Serial.println("Entering 5 minutes awake period...");
}

void loop() {
  // Check if the device is still commissioned. If not, restart to allow re-commissioning
  matterRestartIfNoFabric();
  handleButton();

  // Update sensor readings every SENSOR_INTERVAL_MS
  static uint32_t lastUpdate = 0;
  if (millis() - lastUpdate >= SENSOR_INTERVAL_MS) {
    lastUpdate = millis();
    updateSensorsAndMatter();
  }

  // After 5 minutes, go to deep sleep
  if (millis() - awakeStartMs >= FIRST_AWAKE_MS) {
    Serial.println("5 minutes finished: entering deep sleep cycle.");
    goToDeepSleep();
  }

  delay(50);
}

Afficher le code brut

Vous devez sélectionner dans les Outils – Schéma de partition : « Huge APP (3MB No OT /1MB SPIFFS) » et le code fonctionnera immédiatement. En fonction de votre carte, vous devrez peut-être insérer vos informations d’identification réseau dans les lignes suivantes du code.

#define WIFI_SSID "REPLACE_WITH_YOUR_SSID";
#define WIFI_PASSWORD "REPLACE_WITH_YOUR_PASSWORD";

Lorsque vous allumez ou réinitialisez la carte pour la première fois, elle reste complètement éveillée pendant 5 minutes, lisant le BME280 et envoyant la température, l’humidité et la pression au contrôleur Matter toutes les 30 secondes tout en surveillant le bouton BOOT pour une mise hors service longue ou une remise en service sur un autre contrôleur.

L'appareil ESP32 Matter envoie les lectures du capteur Démonstration DeepSleep

Après cette fenêtre de 5 minutes, votre carte entre dans le cycle de sommeil profond suivant :

  1. Il dort profondément pendant 60 secondes (se réveille avec une minuterie).
  2. Reconnecte le Wi‑Fi/Matter.
  3. Publie les dernières valeurs du capteur.
  4. Reste éveillé encore 20 secondes (re-publiant une fois à mi-parcours pour que votre contrôleur ait une meilleure chance de recevoir les rapports).
  5. Enfin, retourne au sommeil profond.

Comme décrit précédemment, alimenter la carte ou appuyer sur le bouton de réinitialisation intégré réveille votre ESP32 pendant 5 minutes, afin que vous puissiez le mettre hors service ou le partager avec un autre contrôleur.

Le dispositif ESP32 Matter envoie des lectures de température et d'humidité BME280 Démonstration DeepSleep

Dépannage

Le tableau suivant présente les erreurs les plus courantes lorsque vous suivez ce didacticiel et les solutions possibles.

Erreur Solution
Esquisse trop grande / pas assez d’espace / échec de la compilation Dans le menu Outils, vous devez sélectionner l’option : Schéma de partition : « Huge APP (3MB No OT /1MB SPIFFS) »
L’appareil n’affiche jamais le code d’appairage Vérifiez que vous avez saisi le bon SSID/mot de passe dans votre code
La mise en service échoue après une tentative précédente / Vous souhaitez remettre en service sur un autre contrôleur – Appuyez sur le bouton BOOT pendant 5 secondes

– Ou vous pouvez également aller dans Outils et activer l’option Effacer tout le flash avant le téléchargement de l’esquisse : activé, puis télécharger à nouveau le code sur votre tableau.

Aucune sortie série imprimée Appuyez sur le bouton RST/EN pour redémarrer l’ESP32 pendant que le moniteur série Arduino IDE est ouvert avec un débit en bauds de 115 200 avec le port série correct sélectionné.

Remarque : sur le moniteur Arduino IDE Serial, vous pouvez voir de nombreux messages de journal imprimés au fil du temps et juste après la configuration. Vous pouvez voir des messages tels que « échec de l’envoi », « erreur d’envoi transitoire », « demande sur un cluster inconnu » ou similaire. Ils sont généralement inoffensifs et vous pouvez les ignorer à moins que l’appareil ne reste inaccessible.

Conclusion

Dans ce guide, vous avez appris à transformer votre ESP32 en un appareil Matter qui rapporte les relevés de température, d’humidité et de pression à partir d’un capteur BME280. Vous avez également appris les bases du protocole Matter et comment mettre l’appareil en service sur différents contrôleurs, tels qu’Alexa, Apple Home, Google Home, Home Assistant et SmartThings.

Nous avons un tutoriel similaire pour un appareil On/Off Matter, consultez-le ci-dessous :

Si vous avez aimé ce projet, vous aimerez peut-être également ces autres tutoriels :

Merci d’avoir lu.

Cette vidéo vous emmène dans l’histoire de Raspberry Pi :

  • Hailege BME280 Capteur de pression atmosphérique Capteur de température d’humidité Breakout Haute précision pour Arduino
  • 2 Pièces Capteur BMP280, Module Capteur BMP280 I2C/SPI 5V, Capteur Température Humidité Pression, Précis et Faible Conso, Compatible avec Arduino, Raspberry Pi et ESP32, pour Station Météo, Altimètre