¿Quieres preguntarle a Alexa qué temperatura hay en el dormitorio, verla en la app Casa del iPhone y además graficar la presión atmosférica en Home Assistant, todo con el mismo sensor y sin pagar una nube? Eso es lo que permite Matter, el estándar de domótica que firmaron Apple, Google, Amazon y Samsung. Y un ESP32 con un BME280 alcanza para fabricar tu propio dispositivo compatible.

En esta guía vas a armar un nodo Matter que publica temperatura, humedad y presión. Vas a entender qué pasa durante el emparejamiento (por qué a veces pide Bluetooth y a veces no), qué placas sirven, cómo cargar el programa con Arduino IDE, cómo sumarlo a Alexa, Apple Casa, Google Home o Home Assistant y, como extra que no trae la guía original, cómo usar la presión para que Home Assistant te avise cuando se viene lluvia.

Matter en cinco minutos: lo que necesitas entender antes de cablear

Hasta hace poco, cada marca tenía su propio protocolo: un enchufe de una marca no hablaba con el parlante de otra. Matter, que nació con el nombre Project CHIP (Connected Home over IP) y hoy mantiene la Connectivity Standards Alliance, resuelve eso con una idea simple: todos los dispositivos hablan IP en la red de tu casa, con un modelo de datos común.

Diagrama general de la topología de Matter con un ESP32 conectado a varios controladores

Lo que más te va a importar en la práctica:

  • Control local. Las lecturas viajan por tu WiFi, cifradas. Internet es opcional: si se cae la conexión, el sensor sigue reportando al controlador de tu casa.
  • Varios controladores a la vez (multi admin). El mismo ESP32 puede estar en Alexa y en Home Assistant al mismo tiempo, sin reflashear nada.
  • Emparejamiento con código. Un código QR o un código manual de 11 dígitos, igual que un producto comercial.

Y el vocabulario mínimo, porque aparece en los mensajes del monitor serial:

Término Qué significa en este proyecto
Nodo El ESP32 completo, visto como un dispositivo Matter
Endpoint Cada función que expone el nodo: acá son tres (temperatura, humedad y presión)
Cluster El grupo de atributos de una función; por ejemplo, el cluster de medición de temperatura tiene el atributo MeasuredValue
Fabric La red lógica que crea cada controlador al aceptar el dispositivo. Un nodo puede pertenecer a varias
Commissioning El emparejamiento: meter el nodo en un fabric usando el QR o el código manual

El ciclo de vida de un dispositivo Matter

Secuencia típica de un dispositivo Matter, desde sin emparejar hasta operación normal y multi admin

  1. Sin emparejar. En el primer arranque (o tras un reset de fábrica) el ESP32 imprime el código QR y el código manual.
  2. Emparejamiento. El controlador abre una sesión segura (PASE), confirma que es un dispositivo Matter y le entrega las credenciales WiFi, normalmente por Bluetooth Low Energy.
  3. Entrada a la red. El ESP32 se conecta al WiFi y se vuelve visible por IPv6 y mDNS.
  4. Operación normal. Los controladores lo descubren y leen sus valores; todo va cifrado y funciona sin internet.
  5. Multi admin (opcional). El QR original ya no sirve: desde la primera app se genera un código temporal nuevo para sumarlo a otro ecosistema.

Un detalle técnico que la mayoría de las guías no explica: en el paso 2 hay dos sesiones distintas. PASE usa el código de 8 dígitos (el passcode) para derivar una clave sin enviarla nunca por el aire; después, el controlador le instala al ESP32 un certificado de operación, y desde ahí todas las conversaciones usan sesiones CASE, que se autentican con ese certificado. Por eso, una vez emparejado, el código QR deja de ser un secreto útil y no sirve para sumarlo a otra app.

Qué ESP32 elegir (y por qué cambia el emparejamiento)

No todos los chips de Espressif emparejan igual. La diferencia está en si el núcleo Arduino trae activado CHIPoBLE, es decir, el emparejamiento por Bluetooth Low Energy:

Chip Cómo recibe el WiFi CHIPoBLE
ESP32 (clásico) Escribes SSID y clave en el sketch No
ESP32-S2 Escribes SSID y clave en el sketch No (no tiene Bluetooth)
ESP32-S3 Se las entrega el controlador Sí
ESP32-C3 Se las entrega el controlador Sí
ESP32-C5 Se las entrega el controlador Sí
ESP32-C6 Se las entrega el controlador Sí
ESP32-H2 Usa Thread, no WiFi Sí

En la práctica, un ESP32-S3, C3, C5 o C6 se comporta como un producto comercial: escaneas el QR y la app le pasa tu WiFi. Con un ESP32 clásico funciona igual, pero tienes que dejar la red escrita en el código. Si vas a comprar placa para este proyecto, conviene una de la primera familia.

La librería Matter viene incluida en el núcleo ESP32 para Arduino desde la versión 3.1.0, así que no hay que instalar nada extra para el protocolo. Si tu núcleo es más antiguo, actualízalo desde el Gestor de placas antes de seguir.

Hardware: un sensor, cuatro cables

El montaje es mínimo:

  • Módulo BME280 (temperatura, humedad y presión, por I2C).
  • Una placa ESP32-S3 u otro ESP32 de la tabla.
  • Protoboard y cables jumper.
  • Un controlador Matter: un parlante Echo con Alexa, un iPhone con un hub de Apple Casa, un Google Nest compatible o una instalación de Home Assistant con la integración Matter.

Módulo BME280 de comunicación I2C que mide presión, temperatura y humedad

Ojo con el BMP280. Por fuera es casi idéntico al BME280 y se vende muchas veces con el nombre cambiado, pero no mide humedad. La forma segura de distinguirlos es por software: el registro de identificación (0xD0) devuelve 0x60 en un BME280 y 0x58 en un BMP280. Si bme.begin() falla con las dos direcciones aunque el cableado esté bien, lo más probable es que tengas un BMP280 entre manos.

Conexiones

El BME280 se alimenta con 3,3 V y comparte el bus I2C del ESP32. Son cuatro cables:

BME280 ESP32 clásico ESP32-S3 DevKit
VIN 3.3V 3.3V
GND GND GND
SCL GPIO 22 GPIO 9
SDA GPIO 21 GPIO 8

Esquema de conexión del ESP32 con el BME280 por I2C

Para un ESP32-S3 el esquema es el mismo, solo cambian los pines: SDA va al GPIO 8 y SCL al GPIO 9.

Esquema de conexión del sensor BME280 a los pines SDA y SCL de una placa ESP32-S3

Si usas otra placa, revisa su diagrama de pines. En la XIAO ESP32 S3, por ejemplo, SDA es el pin D4 (GPIO 5) y SCL el D5 (GPIO 6), así que en el código cambias I2C_SDA a 5 e I2C_SCL a 6.

Un error de ubicación que arruina las lecturas: el BME280 se calienta con el propio ESP32. Si lo dejas pegado a la placa en la misma protoboard, la temperatura sale uno o dos grados más alta y la humedad relativa, más baja. Para un sensor definitivo, sepáralo con cables de 10 a 15 cm y ponlo fuera de la caja o en la parte de abajo, donde no le llegue el aire caliente del regulador.

Software: librerías y el sketch

Instala dos librerías desde Programa > Incluir librería > Administrar bibliotecas: busca Adafruit BME280 y acepta cuando te ofrezca instalar también Adafruit Unified Sensor.

El programa convierte al ESP32 en un nodo Matter con tres endpoints. Está basado en los ejemplos oficiales de la librería Matter de Espressif:

C++
/*
  Rui Santos & Sara Santos - Random Nerd Tutorials
  Complete project details at https://RandomNerdTutorials.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 <Arduino.h>
#include <Matter.h>
#include <Wire.h>
#include <Adafruit_BME280.h>

// 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);
}

Cómo funciona, por bloques

Credenciales WiFi. WIFI_SSID y WIFI_PASSWORD solo se usan en placas sin CHIPoBLE (ESP32 clásico y S2). Ahí el sketch se conecta solo a tu red con matterConnectWiFi(). En un S3, C3, C5 o C6 puedes dejar los valores de ejemplo: el controlador le entrega la red durante el emparejamiento. La directiva #if !CONFIG_ENABLE_CHIPOBLE es la que decide en tiempo de compilación cuál de los dos caminos se usa.

Los tres endpoints. MatterTemperatureSensor, MatterHumiditySensor y MatterPressureSensor son objetos que la librería publica como sensores independientes. Para el controlador, tu ESP32 es un aparato con tres funciones.

Unidades. La librería recibe la temperatura en grados Celsius, la humedad en porcentaje y la presión en hectopascales, por eso el código divide readPressure() (que entrega pascales) por 100. Internamente, Matter guarda la temperatura en centésimas de grado. Si tu teléfono está configurado en Fahrenheit, Alexa hace la conversión al mostrarla: el dispositivo siempre informa en Celsius.

Detección del sensor. bme.begin(0x76, &Wire) && bme.begin(0x77, &Wire) prueba las dos direcciones I2C posibles del módulo, según cómo venga soldado el pin SDO. Si ninguna responde, el programa se queda detenido en while(1) y lo avisa por el monitor serial.

El ciclo principal. Cada 30 segundos (SENSOR_INTERVAL_MS) lee el sensor, imprime los valores y actualiza los tres endpoints. Si una lectura sale inválida (isnan), conserva los valores anteriores en vez de mandar basura al controlador.

matterRestartIfNoFabric(). Revisa en cada vuelta si el nodo sigue perteneciendo a algún fabric. Si lo eliminaste desde la app, reinicia la pila Matter para que vuelva a quedar disponible para emparejar.

Reset de fábrica con el botón BOOT. Si mantienes presionado BOOT por más de 5 segundos, Matter.decommission() borra todos los fabrics y el nodo vuelve al estado de fábrica. Si al compilar con otra placa te marca que BOOT_PIN no existe, reemplázalo por el número de GPIO del botón BOOT de tu placa (en casi todas es el GPIO 0).

Cargar el programa

  1. Selecciona tu placa en Herramientas > Placa > ESP32 Arduino (por ejemplo, ESP32S3 Dev Module o XIAO_ESP32S3).
  2. En Herramientas > Partition Scheme elige "Huge APP (3MB No OTA/1MB SPIFFS)". La pila Matter no cabe en la partición por defecto y el error de compilación ("sketch too big") no deja claro que el problema es ese.

Menú de Arduino IDE con el esquema de particiones Huge APP seleccionado

  1. En la primera carga, activa Herramientas > Erase All Flash Before Sketch Upload: Enabled. Borra credenciales WiFi y fabrics que hayan quedado de pruebas anteriores. Vuelve a usarlo cada vez que el emparejamiento falle sin razón aparente.

Opción Erase All Flash Before Sketch Upload habilitada en Arduino IDE

  1. Conecta la placa, elige el puerto correcto y presiona Subir.

Emparejar el sensor

Abre el monitor serial a 115200 baudios y presiona el botón RST/EN de la placa. Vas a ver el código manual de 11 dígitos y una URL:

Monitor serial de Arduino IDE mostrando el código manual de emparejamiento y la URL del código QR

Si abres esa URL en el navegador, aparece el código QR para escanear con la app.

Código QR del dispositivo Matter generado a partir de la URL del monitor serial

Con Alexa

  1. En la app Amazon Alexa toca el ícono + y elige Agregar dispositivo.

Pantalla de la app Alexa con la opción para agregar un dispositivo Matter

  1. Selecciona el logo de Matter (o Otro).

Pantalla de la app Alexa donde se elige la opción Matter

  1. Cuando pregunte si el dispositivo tiene el logo de Matter, responde Sí y escanea el QR o escribe el código manual.
  2. Con el teléfono cerca del ESP32, toca Conectar. La app avisa que el dispositivo no está certificado; acéptalo con Sí. Es normal: un prototipo casero no pasa por la certificación de la CSA.
  3. Cuando lo encuentre, toca Siguiente. En el monitor serial aparece "Matter Node is commissioned".

Pantalla final de la app Alexa con el sensor Matter del ESP32 configurado

Desde ahí, la temperatura y la humedad quedan en tu lista de dispositivos y le puedes preguntar a Alexa por ellas.

Con Apple Casa, Google Home, Home Assistant o SmartThings

  • Apple Casa: app Casa, + arriba a la derecha, Agregar accesorio, escanear el QR o tocar "Más opciones" para escribir el código.
  • Google Home: +, Configurar dispositivo, Dispositivo nuevo, Dispositivo Matter y escanear o escribir el código.
  • Home Assistant: Ajustes > Dispositivos y servicios > Agregar integración > Matter, y después el código.
  • Samsung SmartThings: +, Dispositivos de socios > Matter y escanear o escribir el código.

Para sumarlo a un segundo controlador no sirve el QR original. Desde la primera app activa el modo de emparejamiento (según la marca se llama "Compartir", "Activar modo de vinculación" o "Vincular a otra plataforma"): genera un código temporal nuevo, que es el que escaneas en la otra app.

Qué ve cada controlador. Alexa y Apple Casa muestran temperatura y humedad, pero no presión. Home Assistant muestra las tres. Si te interesa la presión (y en la próxima sección vas a ver por qué sí), empareja también con Home Assistant usando el multi admin.

Pruebas y problemas típicos

En el monitor serial deberías ver una línea cada 30 segundos con temperatura, humedad y presión. Si algo no anda:

  • "BME280 not found!": revisa SDA y SCL (es el error más común: van cruzados), que el módulo esté a 3,3 V y que sea un BME280 y no un BMP280.
  • La app no encuentra el dispositivo: acerca el teléfono, confirma que el teléfono está en la misma red y que es de 2,4 GHz (el ESP32-S3 no usa 5 GHz). Si venías de otros intentos, borra la flash completa y vuelve a cargar.
  • Se emparejó pero quedó "sin respuesta": el router puede estar filtrando IPv6 o mDNS. Matter depende de los dos; revisa que no estén desactivados en la configuración del router.
  • Quieres empezar de cero: mantén presionado BOOT más de 5 segundos. El nodo sale de todos los fabrics y vuelve a imprimir el código.

Versión a batería con deep sleep

La guía original incluye un segundo sketch pensado para alimentar el sensor con batería. Funciona así:

  • Al primer arranque (o tras un reset) se queda despierto 5 minutos para que alcances a emparejarlo con calma.
  • Después entra en deep sleep y despierta cada 60 segundos con el temporizador.
  • Al despertar espera hasta 20 segundos a que el controlador restablezca la sesión cifrada (CASE), publica las lecturas, se queda 10 segundos más despierto para que lleguen y vuelve a dormir.

Los tiempos están en estas constantes, al principio del sketch:

C++
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

Y la función que lo manda a dormir es la estándar de ESP IDF:

C++
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();
}

Este sketch también pone el BME280 en modo forzado (MODE_FORCED): el sensor queda en reposo y solo mide cuando se lo piden, con un consumo de pocos microamperes entre lecturas. Además fija un nombre, número de serie y código de emparejamiento propios con Matter.setVendorName(), Matter.setSetupPasscode() y compañía, que deben llamarse antes de Matter.begin(). El código completo está en el enlace del tutorial original, al final.

Una advertencia honesta sobre la batería: con WiFi, cada despertar cuesta caro. Reconectar al WiFi y restablecer la sesión CASE toma varios segundos con la radio encendida, a más de 100 mA en los picos. Despertar cada 60 segundos es útil para probar, pero para que una batería dure semanas conviene subir SLEEP_TIME_SECONDS a 5 o 10 minutos; para la temperatura de una pieza no necesitas más. Y si de verdad quieres un sensor que dure meses con una pila, el camino es un ESP32-C6 o un ESP32-H2 con Thread, que fue diseñado para dispositivos dormidos.

Variantes y mejoras

1. Alerta de lluvia en Home Assistant usando la presión

La presión absoluta no dice mucho por sí sola: en Santiago, a unos 570 metros de altura, un BME280 marca alrededor de 950 hPa en un día normal, muy lejos de los 1013 hPa del nivel del mar que muestran las apps del clima (ellas corrigen por altura). Lo que sí sirve para pronosticar es la tendencia: una caída de más de 3 hPa en tres horas suele anunciar un frente, que en la zona central es justamente cómo llegan las lluvias de invierno.

Con el sensor ya emparejado en Home Assistant, agrega a tu configuration.yaml un sensor de estadística que calcule el cambio en las últimas 3 horas, y una automatización que avise. Cambia sensor.presion_bme280 por el nombre real de la entidad de presión que creó la integración Matter:

YAML
sensor:
  - platform: statistics
    name: "Cambio de presión 3h"
    entity_id: sensor.presion_bme280
    state_characteristic: change
    max_age:
      hours: 3
    sampling_size: 400

automation:
  - alias: "Aviso de posible lluvia"
    trigger:
      - platform: numeric_state
        entity_id: sensor.cambio_de_presion_3h
        below: -3
    action:
      - service: notify.notify
        data:
          message: "La presión bajó más de 3 hPa en 3 horas: es probable que llueva."

Con lecturas cada 30 segundos, tres horas son unas 360 muestras; por eso sampling_size va en 400. Si usas la versión a batería con lecturas más espaciadas, puedes bajarlo.

2. Detectar humedad alta en el baño o en la bodega

El mismo nodo sirve como detector de condensación: una automatización que te avise cuando la humedad pase de 70 % por más de una hora es una buena alarma contra hongos en invierno, cuando las casas se ventilan poco. Si lo combinas con un enchufe inteligente Matter, Home Assistant puede encender un extractor o un deshumidificador por su cuenta.

3. Agregar un sensor de luz como cuarto endpoint

La librería Matter de Espressif también trae endpoints para otros sensores, entre ellos ocupación y luz. Un sensor de luz ambiental I2C comparte los mismos dos cables del bus con el BME280, y con un endpoint más tu nodo puede decidir, por ejemplo, encender una lámpara solo si la pieza está oscura.

Personalización para Chile

En Chile consigues todo lo necesario en MechatronicStore:

  • Sensor BME280 temperatura humedad y presión barométrica 3.3V I2C (SKU GR1-10): el corazón del proyecto. Es la versión que mide las tres variables, no el BMP280, así que los tres endpoints del sketch funcionan.
  • Seeed Studio XIAO ESP32 S3 (SKU GS1-3): un ESP32-S3 con CHIPoBLE, así que el emparejamiento es por Bluetooth y no escribes tu WiFi en el código. Es más pequeña que la DevKit del tutorial original y sus pines I2C son otros: SDA en D4 (GPIO 5) y SCL en D5 (GPIO 6). Cambia I2C_SDA y I2C_SCL en el sketch y listo.
  • Breadboard / Protoboard 830 puntos MB102 (SKU C-302): para montar todo sin soldar mientras pruebas.
  • Cables macho macho 40 piezas 20cm (SKU C-411): los cuatro cables del bus I2C y la alimentación del sensor, con largo suficiente para alejar el BME280 del calor de la placa.
  • Cable USB Tipo C a USB Tipo A 1mt (SKU B-101): para cargar el programa y alimentar la XIAO. Tiene que ser un cable de datos, no solo de carga.

Si en el tutorial original usan una "ESP32-S3 DevKitC", la XIAO ESP32 S3 cumple la misma función con el mismo chip. El controlador Matter (un parlante con Alexa, un hub de Apple Casa o Google, o un computador con Home Assistant) lo pones tú: si ya tienes Home Assistant en una Raspberry Pi, no necesitas nada más.

Recursos

Versión chilena con componentes en stock local.