Interfaz sensor ambiental BME680 con Arduino

Descubre cómo crear un sistema de monitorización del entorno utilizando el sensor ambiental BME680 y Arduino. En este artículo te enseñaremos paso a paso cómo conectar y programar este dispositivo para obtener mediciones precisas de la calidad del aire, temperatura, humedad y presión atmosférica. ¡No te lo pierdas!

¿Quiere crear un rastreador personal de la calidad del aire que muestre si su dormitorio, taller o lugar de trabajo tiene la ventilación adecuada? Instale el módulo de sensor ambiental BME680 en un Arduino y monitoree cada aspecto de su ambiente interior.

El adaptador BME680 de última generación le permite medir la temperatura, la presión, la humedad y la calidad del aire interior y, lo mejor de todo, ¡es compatible con Arduino!

El sensor ambiental BME680

El corazón del módulo es el sensor ambiental de próxima generación de Bosch: BME680.

Este pequeño sensor tiene funciones para detectar temperatura, humedad, presión del aire y gases VOC (compuestos orgánicos volátiles). Contiene un pequeño sensor de MOx (óxido metálico). El óxido metálico calentado cambia la resistencia en función de los COV en el aire, por lo que puede usarse para detectar gases y alcoholes como etanol, alcohol y monóxido de carbono y para tomar medidas de la calidad del aire. Por lo tanto, el BME680 puede funcionar como un sensor ambiental completamente independiente.

Como la mayoría de los sensores de gas, este sensor responde a múltiples gases y alcoholes, pero no puede distinguir cuál es cuál. Recibirás un valor de resistencia con contenido total de COV. Por lo tanto, es más adecuado para medir cambios en una densidad de gas conocida en lugar de detectar qué está cambiando.

Al igual que el BME280, este sensor de precisión puede medir la humedad con una precisión de ±3 %, la presión del aire con una precisión absoluta de ±1 hPa y la temperatura con una precisión de ±1,0 °C. Las mediciones de presión son muy precisas; Incluso puedes utilizarlo como altímetro con una precisión de ±1 metro.

Aquí están las especificaciones completas:

Consulte la siguiente hoja de datos para obtener más detalles.

Requisitos de energía

El módulo está equipado con un regulador de voltaje de precisión de 3,3 V y un traductor de nivel de voltaje XC6206, por lo que puede usarlo fácilmente con su microcontrolador favorito de 3,3 V o 5 V.

El BME680 consume menos de 1 mA durante las mediciones y sólo 0,15 µA en modo de suspensión. Este bajo consumo energético permite su implementación en dispositivos que funcionan con baterías como teléfonos móviles, wearables o relojes inteligentes.

Interfaces digitales

El sensor se comunica a través de I2C o SPI.

interfaz I2C

El sensor utiliza la interfaz I2C para comunicarse con Arduino. Admite dos direcciones I2C separadas: 0x77_Maleficio y 0x76_Maleficio. Esto permite utilizar dos BME680 en el mismo bus o evitar conflictos de direcciones con otro dispositivo en el bus.

El pin SDO determina la dirección I2C del módulo. Este pin tiene una resistencia pull-up incorporada. Por lo tanto, si deja el pin SDO desconectado, la dirección I2C predeterminada es 0x77_Maleficio y cuando lo conectas a GND, la línea pasa a BAJA y la dirección I2C se convierte en 0x76_Maleficio.

interfaz SPI

El sensor también puede comunicarse a través de la interfaz SPI.

¿Cómo funciona el sensor de gas MEMS BME680?

A diferencia de MQ2 o MQ3, el sensor de gas BME680 se fabrica utilizando tecnología de sistema microelectromecánico (MEMS). La detección de gases basada en MEMS permite una reducción drástica del tamaño, una reducción del consumo de energía y la capacidad de aumentar la funcionalidad y la selectividad.

Un sensor de gas MEMS típico consta de una capa semiconductora de óxido metálico (material del sensor) que reacciona con el gas objetivo, al menos dos electrodos para monitorear la resistencia eléctrica/fluctuaciones de corriente y una placa microcalentadora para aumentar la temperatura de funcionamiento.

Cuando una capa semiconductora de óxido metálico se calienta a altas temperaturas, se produce oxígeno. adsorbido en la superficie. En el aire limpio, los electrones de la banda de conducción del óxido metálico son atraídos por las moléculas de oxígeno. Esto crea una capa de agotamiento de electrones directamente debajo de la superficie de las partículas de óxido metálico, lo que representa una barrera potencial. Esto confiere a la capa de óxido metálico una alta resistencia e impide el flujo de corriente.

Sin embargo, en presencia de gases, la densidad superficial del oxígeno adsorbido disminuye a medida que reacciona con los gases; lo que reduce la barrera potencial. Luego se liberan electrones en la capa de óxido metálico, lo que permite que la corriente fluya sin obstáculos a través del sensor.

Distribución de pines del módulo BME680

Ahora veamos el pinout.

Pines de alimentación:

VCC es el pin de alimentación. Puedes conectarlo a la salida de 5V de tu Arduino.

Tierra es la base común del poder y la lógica.

Pines lógicos SPI:

SCL es el pin del reloj SPI, una entrada al chip

ASD es el pin de entrada de datos serie (SDI/MOSI) para los datos enviados desde su microcontrolador al BME680.

SDO es el pin de salida de datos en serie (SDO/MISO) para los datos enviados desde el BME680 a su microcontrolador.

C.S. Si el chip selecciona el pin, tírelo a BAJO para habilitar la comunicación SPI. Si desea conectar varios BME680 a un microcontrolador, permítales compartir los pines SDI, SDO y SCK y asigne un pin CS único a cada uno.

Pines lógicos I2C:

SCL También es el pin del reloj I2C, conéctelo a la línea de reloj I2C de su microcontrolador.

ASD También es el pin de datos I2C, conéctelo a la línea de datos I2C de su microcontrolador.

Preparación del módulo BME680 para su uso

Antes de utilizar el sensor por primera vez, se recomienda dejarlo funcionando durante 48 horas. marcar a fuegoy luego 30 minutos en el modo deseado cada vez que utilice el sensor. La razón de esto es que la sensibilidad del sensor cambia durante el uso inicial y la resistencia aumenta gradualmente a medida que el MOx se calienta hasta su valor base con el tiempo.

Cableado del módulo BME680 a Arduino

Ahora que sabemos todo sobre el módulo, ¡podemos empezar a conectarlo a nuestro Arduino!

cableado I2C

Utilice este cableado si desea conectarse a través de la interfaz I2C.

Comience conectando el pin VCC a la fuente de alimentación. 3V-5V está bien. Utilice el mismo voltaje en el que se basa la lógica de su microcontrolador. Para la mayoría de los Arduinos, esto es 5V. Para dispositivos lógicos de 3,3 V, utilice 3,3 V. Ahora conecte GND a tierra común.

Conecte el pin SCL al pin de reloj I2C y el pin SDA al pin de datos I2C de su Arduino. Tenga en cuenta que cada placa Arduino tiene diferentes pines I2C que deben conectarse en consecuencia. En las placas Arduino con diseño R3, SDA (línea de datos) y SCL (línea de reloj) se encuentran en los encabezados cerca del pin AREF. También se les conoce como A5 (SCL) y A4 (SDA).

La siguiente figura muestra el cableado.

cableado SPI

Dado que es un sensor habilitado para SPI, puede utilizar hardware o software SPI. Sin embargo, se recomienda utilizar pines SPI de hardware, ya que son mucho más rápidos que modificar el código de la interfaz con un conjunto diferente de pines.

Nuevamente, cada placa Arduino tiene diferentes pines SPI que deben conectarse en consecuencia. En placas Arduino como UNO/Nano V3.0, estos pines son digitales 13 (SCK), 12 (MISO), 11 (MOSI) y 10 (SS).

Si está utilizando otra placa Arduino, se recomienda leer la documentación oficial correspondiente. Posiciones de los pines SPI Antes de continuar.

La siguiente figura muestra el cableado.

Una vez que su módulo esté conectado al Arduino, ¡es hora de escribir código!

Instalación de biblioteca

Para comenzar a leer los datos del sensor, debe instalar lo siguiente Biblioteca Adafruit_BME680. Está disponible en el administrador de la biblioteca Arduino.

Para instalar la biblioteca, navegue hasta Bosquejo > Incluir biblioteca > Administrar bibliotecas… Espere a que el administrador de la biblioteca descargue el índice de la biblioteca y actualice la lista de bibliotecas instaladas.

Filtra tu búsqueda escribiendo “adafruit bme680'. Haga clic en esta entrada y luego seleccione Instalar.

La biblioteca de sensores BME280 utiliza el Backend de soporte del sensor de Adafruit. Así que consulte con el administrador de la biblioteca. Sensor unificado de Adafruit e instálalo también (es posible que tengas que desplazarte un poco)

Bocetos de ejemplo de BME680

La biblioteca Adafruit_BME680 tiene varios bocetos de ejemplo. Puede utilizar estos bocetos de ejemplo como base para desarrollar su propio código.

Para acceder a los bocetos de muestra, navegue hasta Archivo > Ejemplos > Biblioteca Adafruit BME680 Verá una selección de bocetos de muestra.

Código Arduino: lectura de gas, presión, humedad, temperatura y altitud

Descargar el prueba bme680 Dibuje a partir de los bocetos de ejemplo en su IDE de Arduino. Este es un boceto básico de Arduino. Continúe y cárguelo en su Arduino. Deberías ver temperatura, presión, humedad, gas y aprox. Altura en el monitor serie.

#include <Wire.h>
#include <SPI.h>
#include <Adafruit_Sensor.h>
#include "Adafruit_BME680.h"

// Uncomment if you want to use SPI
//#define BME_SCK 13
//#define BME_MISO 12
//#define BME_MOSI 11
//#define BME_CS 10

#define SEALEVELPRESSURE_HPA (1013.25)

Adafruit_BME680 bme;
//Adafruit_BME680 bme(BME_CS); // Uncomment if you want to use SPI
//Adafruit_BME680 bme(BME_CS, BME_MOSI, BME_MISO,  BME_SCK);

void setup() {
  Serial.begin(9600);
  while (!Serial);

  if (!bme.begin()) {
    Serial.println("Could not find a valid BME680 sensor, check wiring!");
    while (1);
  }

  // Set up oversampling and filter initialization
  bme.setTemperatureOversampling(BME680_OS_8X);
  bme.setHumidityOversampling(BME680_OS_2X);
  bme.setPressureOversampling(BME680_OS_4X);
  bme.setIIRFilterSize(BME680_FILTER_SIZE_3);
  bme.setGasHeater(320, 150); // 320*C for 150 ms
}

void loop() {
  if (! bme.performReading()) {
    Serial.println("Failed to perform reading :(");
    return;
  }
  Serial.print("Temperature = ");
  Serial.print(bme.temperature);
  Serial.println(" *C");

  Serial.print("Pressure = ");
  Serial.print(bme.pressure / 100.0);
  Serial.println(" hPa");

  Serial.print("Humidity = ");
  Serial.print(bme.humidity);
  Serial.println(" %");

  Serial.print("Gas = ");
  Serial.print(bme.gas_resistance / 1000.0);
  Serial.println(" KOhms");

  Serial.print("Approx. Altitude = ");
  Serial.print(bme.readAltitude(SEALEVELPRESSURE_HPA));
  Serial.println(" m");

  Serial.println();
  delay(2000);
}

Tenga en cuenta que deberá configurar su monitor serie a una velocidad de 115200 baudios para probar el boceto.

Verá innumerables datos sobre temperatura, presión, humedad, gas y valores de altitud aprox. Mueva su sensor y observe cómo cambian los datos.

Explicación del código:

El boceto comienza con la inclusión de cuatro bibliotecas necesarias, a saber. Wire.h (para I2C), SPI.h (para SPI), Adafruit_Sensor.h y Adafruit_BME680.h.

#include <Wire.h>
#include <SPI.h>
#include <Adafruit_Sensor.h>
#include "Adafruit_BME680.h"

En este ejemplo, se utiliza el protocolo de comunicación I2C para comunicarse con el sensor. Sin embargo, el código está preparado si desea utilizar SPI. Todo lo que necesitas hacer es comentar las siguientes líneas de código que definen los pines SPI.

//#define BME_SCK 13
//#define BME_MISO 12
//#define BME_MOSI 11
//#define BME_CS 10

A continuación se llama una variable SEALEVELPRESSURE_HPA se define. Esta variable almacena la presión a nivel del mar en milibares y se utiliza para estimar la altitud para una presión determinada comparándola con la presión a nivel del mar. El valor predeterminado se utiliza en este boceto. Sin embargo, para obtener resultados precisos, reemplace el valor con la presión actual al nivel del mar en su ubicación.

#define SEALEVELPRESSURE_HPA (1013.25)

Este boceto utiliza el protocolo de comunicación I2C de forma predeterminada. La siguiente línea crea un objeto llamado Adafruit_BME680 bme en los pines Arduino I2C.

Adafruit_BME680 bme;

Si desea utilizar SPI, debe comentar la línea anterior y descomentar las líneas siguientes.

//Adafruit_BME680 bme(BME_CS);
//Adafruit_BME680 bme(BME_CS, BME_MOSI, BME_MISO,  BME_SCK);

En la configuración inicializamos la comunicación serie con el PC y la llamamos. begin() Función. El begin() La función inicializa la interfaz I2C y verifica si la ID del chip es correcta. Luego, el chip se reinicia mediante un reinicio por software y, después de despertarse, espera a que se calibre el sensor.

Serial.begin(9600);
while (!Serial);

if (!bme.begin()) {
	Serial.println("Could not find a valid BME680 sensor, check wiring!");
	while (1);
}

A continuación configuramos algunos parámetros para el sensor.

bme.setTemperatureOversampling(BME680_OS_8X);
bme.setHumidityOversampling(BME680_OS_2X);
bme.setPressureOversampling(BME680_OS_4X);
bme.setIIRFilterSize(BME680_FILTER_SIZE_3);
bme.setGasHeater(320, 150); // 320*C for 150 ms

Veamos cada característica individualmente.

setTemperatureSobremuestreo(sistema operativo uint8_t)

establecerPresiónSobremuestreo(sistema operativo uint8_t)

setHumiditySobremuestreo(sistema operativo uint8_t)

Para aumentar la resolución efectiva de las mediciones y reducir el ruido, el BME680 admite sobremuestreo (adquirir múltiples muestras y promediarlas). Se llaman tres funciones. setTemperatureOversampling(), setHumidityOversampling() Y setPressureOversampling() para configurar el sobremuestreo para mediciones de temperatura, humedad o presión. Estas funciones aceptan uno de los siguientes parámetros:

• BME680_OS_NONE (desactiva la lectura)
• BME680_OS_1X
• BME680_OS_2X
• BME680_OS_4X
• BME680_OS_8X
• BME680_OS_16X

setIIRFiltroTamaño(fs)

El BME680 también cuenta con un filtro IIR interno para reducir los cambios a corto plazo en los valores de salida del sensor causados ​​por perturbaciones externas (por ejemplo, un portazo o entrada de aire al sensor). El setIIRFilterSize() La función configura el filtro IIR. El filtro IIR se puede configurar con diferentes coeficientes de filtrado seleccionando uno de los siguientes parámetros:

• BME680_FILTER_SIZE_0 (sin filtrado)
• BME680_FILTER_SIZE_1
• BME680_FILTER_SIZE_3
• BME680_FILTER_SIZE_7
• BME680_FILTER_SIZE_15
• BME680_FILTER_SIZE_31
• BME680_FILTER_SIZE_63
• BME680_FILTER_SIZE_127

setGasCalentador(Temperatura de calentamiento, Tiempo de calentamiento)

Además, la placa calefactora del sensor de gas se puede configurar para calentarse antes de la medición del gas. El setGasHeater() La función establece el perfil de calefacción y acepta dos argumentos.

• HeaterTemp: la temperatura de calentamiento (en °C)
• HeaterTime: el tiempo que el calentador debe estar encendido (en milisegundos)

Por ejemplo, bme.setGasHeater(320, 150) Calienta la placa calefactora del sensor de gas a 320 °C durante 150 milisegundos.

Lo llamamos en el bucle bme.performReading() Función para realizar una lectura en modo bloqueo. Una vez hecho esto, podremos acceder a las variables de instancia de bme a través del punto (.) Operador.

bme.temperatura devuelve el valor de temperatura.

bme.Presión devuelve el valor de la presión del aire.

bme.humedad Devuelve la lectura de humedad relativa.

bme.gas_resistance devuelve la resistencia del gas.

bme.readAltitud(SEALEVELPRESSURE_HPA) La función calcula la altitud (en metros) a partir de la presión atmosférica especificada (en hPa) y la presión al nivel del mar (en hPa).

if (! bme.performReading()) {
	Serial.println("Failed to perform reading :(");
	return;
}
Serial.print("Temperature = ");
Serial.print(bme.temperature);
Serial.println(" *C");

Serial.print("Pressure = ");
Serial.print(bme.pressure / 100.0);
Serial.println(" hPa");

Serial.print("Humidity = ");
Serial.print(bme.humidity);
Serial.println(" %");

Serial.print("Gas = ");
Serial.print(bme.gas_resistance / 1000.0);
Serial.println(" KOhms");

Serial.print("Approx. Altitude = ");
Serial.print(bme.readAltitude(SEALEVELPRESSURE_HPA));
Serial.println(" m");

Interfaz sensor ambiental BME680 con Arduino

¿Quieres construir un rastreador de calidad del aire personal que te indique si tu dormitorio, taller o lugar de trabajo tiene una ventilación adecuada? Instala el módulo del sensor ambiental BME680 en un Arduino y monitorea todos los aspectos de tu entorno interior.

El Sensor Ambiental BME680

En el corazón del módulo se encuentra el sensor ambiental de última generación fabricado por Bosch: BME680.

Este pequeño sensor tiene capacidades de medición de temperatura, humedad, presión barométrica y gases VOC (compuestos orgánicos volátiles). Contiene un pequeño sensor de MOx (óxido metálico). El óxido metálico calentado cambia de resistencia en función de los VOC en el aire, por lo que se puede utilizar para detectar gases y alcoholes como el etanol, alcohol y monóxido de carbono y realizar mediciones de calidad del aire. Por lo tanto, el BME680 puede funcionar como un sensor ambiental completamente independiente.

Al igual que la serie BME280, este sensor de precisión puede medir la humedad con una precisión de ±3%, la presión barométrica con una precisión absoluta de ±1 hPa, y la temperatura con una precisión de ±1,0°C. Las mediciones de presión son tan precisas que incluso se pueden utilizar como altímetro con una precisión de ±1 metro.

• Temp: -40°C a 85°C
• Humedad: 0% a 100% RH con una precisión del ±3%
• Presión: 300Pa a 1100 hPa con una precisión absoluta de ±1 hPa
• Altitud: 0 a 9.2 km con una precisión de ±1 metro

Para obtener más detalles, consulta la hoja técnica a continuación.

¿Qué son los compuestos orgánicos volátiles (VOC)?

Los compuestos orgánicos volátiles (VOC) se emiten como gases de ciertos productos que usamos para construir y mantener nuestras casas (como ambientadores, productos de limpieza, cosméticos, aceite de combustible, gasolina, pintura, barnices, alfombras y suelos de vinilo, etc.). Los VOC incluyen una variedad de productos químicos, algunos de los cuales pueden tener efectos adversos para la salud a corto y largo plazo. Ejemplos comunes de VOC que pueden estar presentes en nuestra vida diaria son: benceno, etilenglicol, formaldehído, cloruro de metileno, tetracloroetileno, tolueno, xileno y 1,3-butadieno.

Requisito de energía

El módulo viene con un regulador de voltaje preciso XC6206 de 3.3V y un traductor de voltaje, por lo que puedes usarlo con tu microcontrolador favorito de 3.3V o 5V sin preocupaciones.

El BME680 consume menos de 1 mA durante las mediciones y solo 0.15 µA en modo de suspensión. Este bajo consumo de energía permite su implementación en dispositivos alimentados por batería como teléfonos, wearables o relojes inteligentes.

Interfaces digitales

El sensor se comunica a través de la interfaz I2C o SPI.

Interfaz I2C

El sensor utiliza la interfaz I2C para la comunicación con el Arduino, compatible con dos direcciones I2C separadas: 0x77Hex y 0x76Hex. Esto permite usar dos BME680 en el mismo bus o evitar conflictos de direcciones con otros dispositivos en el bus.

El pin SDO determina la dirección I2C del módulo. Cuando dejas el pin SDO desconectado, la dirección I2C predeterminada es 0x77Hex y cuando lo conectas a GND, la línea se baja y la dirección I2C se convierte en 0x76Hex.

Interfaz SPI

El sensor también puede comunicarse a través de la interfaz SPI.

Si tienes que elegir entre los dos, SPI suele ser la mejor herramienta si necesitas velocidades de transferencia más rápidas (hasta 10 MHz). Por otro lado, I2C es mejor si tienes un número limitado de pines disponibles en tu microcontrolador.

¿Cómo funciona el sensor de gas MEMS BME680?

A diferencia de los sensores MQ2 o MQ3, el sensor de gas BME680 está fabricado con tecnología de sistema microelectromecánico (MEMS). La detección de gas basada en MEMS proporciona una reducción dramática en el tamaño, una reducción en el consumo de energía y la capacidad de aumentar la funcionalidad y la selectividad.

Un sensor de gas MEMS típico consta de una capa semiconductora de óxido metálico (material sensible) que reacciona con el gas objetivo, al menos dos electrodos para monitorear las variaciones de resistencia / corriente eléctrica, y un microplaca caliente para aumentar la temperatura de funcionamiento.

En presencia de gases, la densidad superficial de oxígeno adsorbido disminuye a medida que reacciona con los gases; lo que disminuye la barrera potencial. Los electrones son entonces liberados en la capa de óxido metálico, permitiendo que la corriente fluya libremente a través del sensor.

Pinout del módulo BME680

Veamos a continuación el esquema de pines.

• Pines de alimentación:
• VCC es el pin de alimentación. Puedes conectarlo a la salida de 5V de tu Arduino.
• GND es el común para alimentación y lógica.
• Pines lógicos SPI:
• SCL es el pin de reloj SPI, es una entrada al chip.
• SDA es el pin de datos serie de entrada (SDI / MOSI), para datos enviados desde tu microcontrolador al BME680.
• SDO es el pin de salida de datos serie (SDO / MISO), para datos enviados desde el BME680 a tu microcontrolador.
• CS es el pin de selección del chip, bájalo a LOW para habilitar una comunicación SPI.
• Pines lógicos I2C:
• SCL es también el pin de reloj I2C, conéctalo a la línea de reloj I2C de tu microcontrolador.
• SDA es también el pin de datos I2C, conéctalo a la línea de datos I2C de tu microcontrolador.

Preparando el módulo BME680 para su uso

Antes del primer uso del sensor, se recomienda hacerlo funcionar durante 48 horas para el precalentamiento y luego durante 30 minutos en el modo deseado cada vez que se use el sensor. La razón de esto es que el nivel de sensibilidad del sensor cambia durante el uso inicial y la resistencia aumenta gradualmente a medida que el MOx se calienta hasta su lectura base con el tiempo.

Cableado del módulo BME680 con Arduino

Ahora que conocemos todo sobre el módulo, ¡podemos comenzar a conectarlo a nuestro Arduino!

Cableado I2C

Utiliza este cableado si quieres conectarte a través de la interfaz I2C.

Comienza conectando el pin VCC a la fuente de alimentación, 3V-5V está bien. Utiliza el mismo voltaje que la lógica de tu microcontrolador. Para la mayoría de los Arduinos, eso es 5V. Para dispositivos de lógica de 3.3V, utiliza 3.3V. Ahora conecta GND a tierra común.

Conecta el pin SCL al pin de reloj I2C y el pin SDA al pin de datos I2C en tu Arduino. Ten en cuenta que cada placa de Arduino tiene pines I2C diferentes que se deben conectar en consecuencia. En las placas de Arduino con el diseño R3, el SDA (línea de datos) y SCL (línea de reloj) están en los encabezados de pines cerca del pin AREF. También se conocen como A5 (SCL) y A4 (SDA).

El siguiente esquema muestra el cableado.

Cableado SPI

Dado que es un sensor compatible con SPI, puedes utilizar pines de hardware o software SPI. Sin embargo, se recomienda utilizar los pines de hardware SPI ya que son mucho más rápidos que realizar la interfaz mediante software con otro conjunto de pines.

Nuevamente, cada placa de Arduino tiene pines SPI diferentes que se deben conectar en consecuencia. Para placas Arduino como la UNO/Nano V3.0, esos pines son digitales 13 (SCK), 12 (MISO), 11 (MOSI) y 10 (SS). Si estás utilizando una placa de Arduino diferente, te recomiendo que consultes la documentación oficial sobre la ubicación de los pines SPI antes de proceder.

El siguiente esquema muestra el cableado.

Una vez que tu módulo esté conectado al Arduino, ¡es hora de escribir algo de código!

Instalación de la biblioteca

Para comenzar a leer datos del sensor, deberás instalar la biblioteca de Adafruit_BME680. Esta está disponible en el administrador de bibliotecas de Arduino.

Para instalar la biblioteca, navega hasta Sketch > Include Library > Manage Libraries… Espera a que el Administrador de Bibliotecas descargue el índice de bibliotecas y actualice la lista de bibliotecas instaladas.

Filtra tu búsqueda escribiendo ‘adafruit bme680’. Haz clic en esa entrada y luego selecciona Instalar.

La biblioteca del sensor BME280 utiliza el soporte backend de Adafruit Sensor. Por lo tanto, busca la biblioteca Adafruit Unified Sensor en el administrador de bibliotecas y también instálala (es posible que debas desplazarte un poco)

Ejemplos de código para BME680

La biblioteca Adafruit_BME680 tiene varios ejemplos de código. Puedes usar estos ejemplos de código como base para desarrollar tu propio código.

Para acceder a los ejemplos de código, navega a File > Examples > Adafruit BME680 Library. Verás una selección de ejemplos de código.

Código Arduino – Lectura de gas, presión, humedad, temperatura y altitud

Carga el sketch bme680test de los ejemplos en tu Arduino IDE. Este es un sketch básico de Arduino. Adelante, cárgalo en tu Arduino. Deberías ver la temperatura, la presión, la humedad, el gas y la altitud aproximada en el monitor serie.

«`cpp
#include
#include
#include
#include «Adafruit_BME680.h»

// Descomenta si deseas usar SPI
//#define BME_SCK 13
//#define BME_MISO 12
//#define BME_MOSI 11
//#define BME_CS 10

#define SEALEVELPRESSURE_HPA (1013.25)

Adafruit_BME680 bme;
//Adafruit_BME680 bme(BME_CS); // Descomenta si deseas usar SPI
//Adafruit_BME680 bme(BME_CS, BME_MOSI, BME_MISO, BME_SCK);

void setup() {
Serial.begin(9600);
while (!Serial);

if (!bme.begin()) {
Serial.println(«Could not find a valid BME680 sensor, check wiring!»);
while (1);
}

// Configura la sobremuestreo y la inicialización del filtro
bme.setTemperatureOversampling(BME680_OS_8X);
bme.setHumidityOversampling(BME680_OS_2X);
bme.setPressureOversampling(BME680_OS_4X);
bme.setIIRFilterSize(BME680_FILTER_SIZE_3);
bme.setGasHeater(320, 150); // 320*C por 150 ms
}

void loop() {
if (! bme.performReading()) {
Serial.println(«Failed to perform reading :(«);
return;
}
Serial.print(«Temperature = «);
Serial.print(bme.temperature);
Serial.println(» *C»);

Serial.print(«Pressure = «);
Serial.print(bme.pressure / 100.0);
Serial.println(» hPa»);

Serial.print(«Humidity = «);
Serial.print(bme.humidity);
Serial.println(» %»);

Serial.print(«Gas = «);
Serial.print(bme.gas_resistance / 1000.0);
Serial.println(» KOhms»);

Serial.print(«Approx. Altitude = «);
Serial.print(bme.readAltitude(SEALEVELPRESSURE_HPA));
Serial.println(» m»);

Serial.println();
delay(2000);
}
«`

Necesitas configurar tu monitor serie a una velocidad de 115200 baudios para probar el sketch.

Verás una gran cantidad de datos que muestra los valores de temperatura, presión, humedad, gas y altitud aproximada. Intenta mover tu sensor y observa cómo cambian los datos.

Explicación del código:

El sketch comienza incluyendo cuatro bibliotecas necesarias: Wire.h (para I2C), SPI.h (para SPI), Adafruit_Sensor.h y Adafruit_BME680.h.

Este ejemplo utiliza por defecto el protocolo de comunicación I2C para comunicarse con el sensor. Sin embargo, el código está preparado si quieres usar SPI. Solo necesitas descomentar las siguientes líneas de código que definen los pines SPI.

A continuación, se define una variable llamada SEALEVELPRESSURE_HPA. Esta variable guarda la presión al nivel del mar en milibares y se usa para estimar la altitud para una presión determinada comparándola con la presión al nivel del mar. Este sketch utiliza el valor predeterminado, pero para obtener resultados precisos, reemplaza el valor con la presión al nivel del mar actual en tu ubicación.

Este sketch utiliza el protocolo de comunicación I2C de forma predeterminada. La siguiente línea crea un objeto Adafruit_BME680 llamado bme en los pines I2C de Arduino.

«`cpp
Adafruit_BME680 bme;
«`

Si deseas utilizar SPI, debes comentar la línea anterior y descomentar las siguientes líneas.

«`cpp
//Adafruit_BME680 bme(BME_CS);
//Adafruit_BME680 bme(BME_CS, BME_MOSI, BME_MISO, BME_SCK);
«`

En la función setup, inicializamos la comunicación serie con la PC y llamamos a la función begin(). La función begin() inicializa la interfaz I2C y verifica si la ID del chip es correcta. Luego, reinicia el chip usando un restablecimiento suave y espera que el sensor se calibre después del despertar.

«`cpp
Serial.begin(9600);
while (!Serial);

if (!bme.begin()) {
Serial.println(«Could not find a valid BME680 sensor, check wiring!»);
while (1);
}
«`

A continuación, configuramos algunos parámetros para el sensor.

«`cpp
bme.setTemperatureOversampling(BME680_OS_8X);
bme.setHumidityOversampling(BME680_OS_2X);
bme.setPressureOversampling(BME680_OS_4X);
bme.setIIRFilterSize(BME680_FILTER_SIZE_3);
bme.setGasHeater(320, 150); // 320*C por 150 ms
«`

En el loop, llamamos a la función bme.performReading() para realizar una lectura en modo bloqueante. Una vez hecho esto, podemos acceder a las variables de instancia de bme usando el operador punto (.)

• bme.temperature devuelve la lectura de temperatura.
• bme.pressure devuelve la lectura de presión barométrica.
• bme.humidity devuelve la lectura de humedad relativa.
• bme.gas_resistance devuelve la resistencia al gas.
• bme.readAltitude(SEALEVELPRESSURE_HPA) calcula la altitud (en metros) a partir de la presión atmosférica especificada (en hPa) y la presión al nivel del mar (en hPa).

«`cpp
if (! bme.performReading