Chisme 181 del Lince: BMP280 EducaCont, el Lince mide presión y polvo

Era una de esas tardes de Sierra Bermeja en las que el aire parece de cristal. El Lince de la Noche había montado sobre la mesa de la cueva su nueva estación: una placa ESP32, un sensor azul de cuatro patillas y una cajita negra con un pequeño ojo infrarrojo. BMP280 EducaCont.

—Esto es un BME280 —dijo orgulloso—. Temperatura, presión y humedad. ¡Tres sensores en uno!

La Gata Montesa se acercó, miró la placa y levantó una ceja.

—¿Y cómo lo sabes?

—Porque… me lo han dicho.

—Eso es leer una etiqueta, no medir nada —sonrió ella—. Los chips I2C tienen un «DNI» interno. Se le puede preguntar al propio sensor quién es.

El Lince se quedó pensando.

—¿Y el otro? —señaló la cajita negra—. Para saber si responde al polvo, voy a soplar polvo de tiza encima.

—Eso, con ventana abierta y el profesor al mando, ya lo haremos con calma —dijo la Gata—. Y recuerda: antes de fiarte de un número, tienes que dudar de él.

Introducción

En este chisme ponemos en marcha la primera parte de la estación EducaCont 984, la modular, con una placa ESP32 Plus en lugar de la UNO. Conectamos dos sensores y leemos sus datos por el monitor serie de Arduino IDE: el BMP280 (temperatura y presión) y un sensor de polvo.

No hay Wi-Fi ni nube todavía. Partimos de que ya sabes usar Arduino IDE y el monitor serie.

Antes de tocar un solo cable puedes practicar en el simulador del chisme 181: solo hay que conectar los pines bien; el código ya está escrito y explicado, y las lecturas son inventadas.

Al terminar este BMP280 EducaCont sabrás conectar un sensor I2C y uno analógico a la ESP32, saber qué chip tienes en la mano (BME280 o BMP280) y ver en el monitor serie temperatura, presión y una estimación de polvo.

Por qué este chisme

Con el BMP280 EducaCont, antes de montar la estación completa, hay que saber qué sensor tenemos y si cada uno responde. Lo haremos en tres pasos: primero identificamos el chip, luego leemos presión y temperatura y, por último, comprobamos con un poco de humo que el sensor de polvo reacciona.

También sirve para algo más importante: aprender que medir no significa medir bien. Cada sensor de esta estación es un prototipo educativo, no un instrumento de medida.

Cómo funciona

Qué mide el BMP280 (y qué no)

El BMP280 mide temperatura (°C) y presión (hPa). No mide humedad. Su hermano mayor, el BME280, sí la mide. Los dos se parecen tanto que se confunden con facilidad.

Hay un tercer caso: el módulo GY-91 lleva un BMP280 más un giroscopio MPU. Hoy usamos solo el BMP280; el giroscopio queda sin usar. Si quieres ver otro sensor de la familia, mira el chisme 36 con el BME280.

I2C y el «DNI» del chip

Los dos chips hablan por un bus llamado I2C: dos cables, SDA (datos) y SCL (reloj), compartidos por varios dispositivos. Cada dispositivo tiene una dirección. Para el BMP280 y el BME280 son 0x76 o 0x77.

Dentro del chip hay un registro, el 0xD0, que guarda su identificador (*chip id*). Si el chip responde 0x60, es un BME280. Si responde 0x58, es un BMP280. Eso es lo que lee nuestro programa detector.

Cómo ve el polvo el sensor de polvo

El módulo Keyestudio PM2.5 lleva un chip GP2Y1014AU0F. Dentro hay un LED infrarrojo y un detector de luz. Cuando hay partículas en el aire, reflejan parte de esa luz y la tensión de la salida (OUT) sube.

Según el fabricante, la sensibilidad es de 0,5 V por cada 100 µg/m³: es decir, 200 µg/m³ por voltio. El programa enciende el LED con LOW, lee la salida 0,28 ms después, lo apaga y completa un ciclo de 10 ms. Después promedia 50 lecturas.

Dos tensiones: 3,3 V y 5 V

El BMP280 y la ESP32 trabajan a 3,3 V. El sensor de polvo necesita 5 V. Por eso el interruptor de la placa se deja en 3,3 V y el 5 V del sensor se saca de la fila POWER.

La fila de pines analógicos da solo 3,3 V. Y si pusiéramos el interruptor en 5 V, el conector I2C pasaría también a 5 V, que es demasiado para el BMP280.

Por qué A2 (IO35) y no A0 ni A1

La ESP32 tiene dos convertidores analógico-digitales: ADC1 y ADC2. A0 (IO2) y A1 (IO4) pertenecen al ADC2, que no funciona con el Wi-Fi activo, tal como explica la documentación de Espressif.

Hoy no usamos Wi-Fi, pero cuando subamos los datos a la nube la lectura dejaría de funcionar. Con A2 (IO35), del ADC1, nos ahorramos ese problema desde el principio.

Qué necesitamos

Para montar el BMP280 EducaCont necesitamos:

• Placa ESP32 Plus y cable USB de datos.
• Sensor BMP280 en placa de 4 pines (VCC, GND, SDA, SCL).
• Sensor de polvo Keyestudio PM2.5 (conector J2: GND, VCC, LED, OUT).
• Cables Dupont.
• Ordenador con Windows y Arduino IDE 2.x con el paquete «esp32» de Espressif.
• Librería Adafruit BMP280 Library (con Adafruit Unified Sensor y Adafruit BusIO), solo para el segundo programa.

Conexión del BMP280 EducaCont

Interruptor de la placa en 3,3 V. En el simulador puedes ensayarlo antes sin riesgo.

BMP280	Placa ESP32
VCC	3,3 V
GND	GND
SDA	SDA (GPIO 21)
SCL	SCL (GPIO 22)

Sensor de polvo	Placa ESP32
VCC	5 V (fila POWER, abajo)
GND	GND
LED	D3 (IO25)
OUT	A2 (IO35)

Los pines D3 = IO25 y A2 = IO35 son los de la imagen de pines de la placa. Si tu placa es de otra marca o modelo, confirma con la serigrafía antes de conectar.

Programa 1: el detector I2C

Este programa no usa librerías. Cada 2 segundos dice si hay un sensor conectado y cuál es. Puedes enchufar y desenchufar el sensor con la placa encendida.

Ajustes: placa ESP32 Dev Module y monitor serie a 115200 baudios.

// EducaCont 984 (modular) - Prueba 05: detector I2C continuo (BME280 / BMP280 / MPU del GY-91)
// Placa: ESP32 Dev Module (Keyestudio / Acebott ESP32 Plus)
// IDE: Arduino IDE 2.x con el paquete "esp32" de Espressif
// Librerias: ninguna
// Monitor serie: 115200 baudios
// Cada 2 segundos dice que hay conectado. Puedes enchufar y desenchufar el sensor con la placa encendida.

#include <Wire.h>

int leerRegistro(byte direccion, byte registro) {
  Wire.beginTransmission(direccion);
  Wire.write(registro);
  if (Wire.endTransmission(false) != 0) return -1;
  Wire.requestFrom((int)direccion, 1);
  if (Wire.available()) return Wire.read();
  return -1;
}

bool hayDispositivo(byte direccion) {
  Wire.beginTransmission(direccion);
  return Wire.endTransmission() == 0;
}

int numeroLectura = 0;

void setup() {
  Serial.begin(115200);
  delay(1500);
  Wire.begin();  // SDA = GPIO 21, SCL = GPIO 22 por defecto
  Serial.println("Detector I2C: comprobando cada 2 segundos...");
}

void loop() {
  numeroLectura++;
  Serial.print("[");
  Serial.print(numeroLectura);
  Serial.print("] ");

  bool algo = false;
  byte direcciones[4] = {0x76, 0x77, 0x68, 0x69};

  for (int i = 0; i < 4; i++) {
    byte d = direcciones[i];
    if (!hayDispositivo(d)) continue;
    algo = true;

    if (d == 0x76 || d == 0x77) {
      int id = leerRegistro(d, 0xD0);
      Serial.print("0x");
      Serial.print(d, HEX);
      if (id == 0x60)                                  Serial.print(" BME280 (temp+humedad+presion)  ");
      else if (id == 0x58 || id == 0x57 || id == 0x56) Serial.print(" BMP280 (temp+presion, sin humedad)  ");
      else                                             Serial.print(" chip desconocido  ");
    } else {
      Serial.print("0x");
      Serial.print(d, HEX);
      Serial.print(" MPU giroscopio (GY-91)  ");
    }
  }

  if (!algo) Serial.print("NO hay sensor conectado: revisa VCC (3,3 V), GND, SDA y SCL");
  Serial.println();
  delay(2000);
}

Cuando está bien conectado, el monitor serie muestra algo así:

[1] 0x76 BMP280 (temp+presion, sin humedad)

Si ves BME280, tu sensor mide además humedad. Si ves NO hay sensor conectado, revisa VCC (3,3 V), GND, SDA y SCL.

Programa 2: BMP280 EducaCont y sensor de polvo

Antes de cargarlo, instala la librería: en Arduino IDE abre el Gestor de librerías, busca Adafruit BMP280 Library e instálala con sus dependencias.

Mira la constante V_AIRE_LIMPIO: la tensión en aire limpio es distinta en cada sensor (el fabricante da 0,9 V como valor típico). Hay que medirla con el sensor caliente y en aire limpio y escribirla ahí. Con el sensor del profesor salió 0,53 V.

// EducaCont 984 (modular) - Prueba 06: BMP280 (I2C) + sensor de polvo GP2Y1014AU0F
// Placa: ESP32 Dev Module (Keyestudio / Acebott ESP32 Plus)
// IDE: Arduino IDE 2.x con el paquete "esp32" de Espressif (nucleo 2.x o superior)
// Librerias: Adafruit BMP280 Library (con sus dependencias Adafruit Unified Sensor y Adafruit BusIO)
// Monitor serie: 115200 baudios
//
// Conexiones:
//   BMP280 : VCC -> 3,3 V | GND -> GND | SDA -> SDA (GPIO 21) | SCL -> SCL (GPIO 22)
//   Polvo  : VCC -> 5 V (fila POWER) | GND -> GND | LED -> D3 (IO25) | OUT -> A2 (IO35)
//   Interruptor de la placa en 3,3 V.

#include <Wire.h>
#include <Adafruit_BMP280.h>

// ---- Sensor de polvo ----
const int PIN_LED = 25;
const int PIN_OUT = 35;
const float V_AIRE_LIMPIO = 0.53;     // medida en aire limpio con ESTE sensor (el tipico del fabricante es 0,9 V)
const float UG_POR_VOLTIO = 200.0;    // 0,5 V por cada 100 ug/m3
const int MUESTRAS = 50;              // 50 lecturas de 10 ms = 0,5 s
const unsigned long PRECALENTAMIENTO_MS = 60000;

// ---- BMP280 ----
Adafruit_BMP280 bmp;
bool bmpListo = false;
byte dirBmp = 0x76;   // direccion en la que se ha encontrado

bool hayDispositivo(byte direccion) {
  Wire.beginTransmission(direccion);
  return Wire.endTransmission() == 0;
}

int leerId(byte direccion) {
  Wire.beginTransmission(direccion);
  Wire.write(0xD0);
  if (Wire.endTransmission(false) != 0) return -1;
  Wire.requestFrom((int)direccion, 1);
  if (Wire.available()) return Wire.read();
  return -1;
}

// Intenta iniciar el BMP280 en 0x76 o 0x77. Devuelve true si lo consigue.
bool iniciarBmp() {
  byte direcciones[2] = {0x76, 0x77};
  for (int i = 0; i < 2; i++) {
    int id = leerId(direcciones[i]);
    if (id == 0x58 || id == 0x57 || id == 0x56) {
      if (bmp.begin(direcciones[i], id)) { dirBmp = direcciones[i]; return true; }
    }
  }
  return false;
}

float leerVoltiosPolvo() {
  digitalWrite(PIN_LED, LOW);           // LED infrarrojo encendido
  delayMicroseconds(280);
  int mv = analogReadMilliVolts(PIN_OUT);
  digitalWrite(PIN_LED, HIGH);          // LED apagado
  delayMicroseconds(9680);
  return mv / 1000.0;
}

void setup() {
  Serial.begin(115200);
  pinMode(PIN_LED, OUTPUT);
  digitalWrite(PIN_LED, HIGH);
  analogSetPinAttenuation(PIN_OUT, ADC_11db);
  Wire.begin();
  delay(1000);
  Serial.println();
  Serial.println("EducaCont 984: BMP280 + sensor de polvo (precalentando polvo 60 s)");
}

void loop() {
  // ----- BMP280 -----
  Serial.print("BMP280: ");
  if (bmpListo && !hayDispositivo(dirBmp)) bmpListo = false;  // se ha desenchufado
  if (!bmpListo) bmpListo = iniciarBmp();

  if (bmpListo) {
    Serial.print(bmp.readTemperature(), 1);
    Serial.print(" C  ");
    Serial.print(bmp.readPressure() / 100.0, 1);
    Serial.print(" hPa");
  } else {
    Serial.print("NO conectado (revisa 3,3 V, GND, SDA, SCL)");
  }

  // ----- Polvo -----
  Serial.print("   |   Polvo: ");
  float suma = 0;
  for (int i = 0; i < MUESTRAS; i++) suma += leerVoltiosPolvo();
  float v = suma / MUESTRAS;
  float polvo = (v - V_AIRE_LIMPIO) * UG_POR_VOLTIO;
  if (polvo < 0) polvo = 0;

  Serial.print(v, 2);
  Serial.print(" V  ~");
  Serial.print(polvo, 0);
  Serial.print(" ug/m3");
  if (v < 0.2) Serial.print("  (tension muy baja: revisa VCC a 5 V y GND)");
  else if (millis() < PRECALENTAMIENTO_MS) Serial.print("  (precalentando)");
  Serial.println();

  delay(1500);
}

Cada 2 segundos se imprime algo parecido a esto (datos de ejemplo, solo ilustrativos):

BMP280: 27.4 C  1020.2 hPa   |   Polvo: 0.53 V  ~0 ug/m3

Cómo probarlo

Estos son los pasos para probar el BMP280 EducaCont:

1. Detector. Carga el programa 1 y comprueba qué chip eres: BMP280 o BME280.
2. Presión y temperatura. Carga el programa 2. Mientras el sensor de polvo se precalienta, el monitor añade «(precalentando)». El fabricante pide entre 30 s y 2 min; el programa espera 60 s.
3. Calibra. Con el sensor caliente y en aire limpio, apunta la tensión que sale y escríbela en V_AIRE_LIMPIO.
4. Prueba con humo, solo el profesor. Con la ventana abierta, a 20-30 cm del sensor, el profesor acerca una cerilla recién apagada o un poco de incienso. La tensión debe subir.

Seguridad: el humo lo maneja solo el profesor. No se acerca llama a la placa y no se moja el sensor. El alumnado no hace esta prueba.

Precaución: la ESP32 solo admite 3,3 V en sus entradas analógicas, y con humo denso el sensor de polvo puede acercarse a ese límite. En nuestra prueba, con humo directo y concentrado, la tensión llegó a 3,16 V. Entonces salieron 527 µg/m³: es el tope de la fórmula, no una medida real.

Qué estamos midiendo realmente

En el BMP280 EducaCont el sensor da temperatura y presión, pero cada número trae su ruido: aunque no toques nada, el último decimal cambia. Un decimal suelto no es una medida fiable.

La presión baja al subir de altura. Cerca del nivel del mar, cada ocho metros de altura son aproximadamente un hectopascal menos. El BMP280 de esta estación no está calibrado como un barómetro profesional.

El sensor de polvo es todavía más delicado. Detecta partículas de más de 0,8 µm, así que no mide estrictamente PM2.5. Su resultado depende de V_AIRE_LIMPIO, y cada sensor tiene la suya.

Por eso el número en µg/m³ es solo orientativo. Sirve para comprobar que el sensor reacciona al humo, no para medir con precisión. Esta estación es un prototipo educativo.

Para el aula

• ¿Qué variable mide cada sensor y en qué unidad?
• ¿Por qué cambia el último decimal de la temperatura si la dejamos quieta?
• ¿Cómo sabemos si nuestro sensor es un BMP280 o un BME280, sin fiarnos de la etiqueta?
• ¿Qué ocurre si ponemos en V_AIRE_LIMPIO el valor del fabricante (0,9) en lugar del nuestro?
• ¿Cómo diseñarías una prueba justa para comprobar que el sensor de polvo responde?
• ¿Qué pasa si dos sensores dan resultados diferentes en el mismo sitio?

Preguntas de comprobación:

1. ¿Cómo sabes si tu sensor es BME280 o BMP280?
2. ¿Por qué el sensor de polvo va a 5 V y el BMP280 a 3,3 V?
3. ¿Por qué hay que esperar un minuto antes de fiarse del polvo?
4. ¿Qué le pasa a la lectura cuando se acerca humo y por qué no hay que fiarse del número exacto?

Retos

• Reto 1. Haz que funcione el detector y el programa 2.
• Reto 2. Cambia V_AIRE_LIMPIO a 0,9 y mira qué pasa con la estimación de polvo.
• Reto 3. Cambia el tiempo de precalentamiento y observa si los valores iniciales son estables.
• Reto 4. Copia 30 líneas del monitor serie a una hoja de cálculo.
• Reto 5. Dibuja con esos datos una gráfica de temperatura y otra de presión.
• Reto 6. Deja el sensor en dos sitios distintos (aula y patio) y compara.
• Reto 7. Con tu profesor, diseña una pequeña investigación: ¿cómo cambia la lectura de polvo con la ventilación del aula?

Qué hemos aprendido

Con el BMP280 EducaCont hemos aprendido esto:

• El BMP280 mide temperatura y presión; el BME280 también humedad.
• Se distinguen leyendo el registro 0xD0 por I2C: 0x58 es BMP280 y 0x60 es BME280.
• El BMP280 va a 3,3 V (SDA = GPIO 21, SCL = GPIO 22) y el sensor de polvo a 5 V.
• A2 (IO35) es una buena entrada analógica porque no depende del Wi-Fi.
• El sensor de polvo se precalienta y necesita calibrar su V_AIRE_LIMPIO.
• Un número en pantalla no es una medida fiable por sí solo: hay que dudar de él.

El Lince guardó los sensores en su caja y miró a la Gata.

—Ahora sé que mi sensor no es un BME280.

—Y lo has sabido preguntándole al chip —dijo ella—. Mucho mejor que fiarte de una etiqueta.

Para seguir investigando

• Practica en el simulador del chisme 181.
• Otro sensor de la familia: el chisme 36 con el BME280.
• Otra entrada analógica en la ESP32: el sensor UV con ESP32.
• Cómo se enciende un pin de salida: LED con la ESP32.
• Ficha oficial del BMP280 de Bosch.