Luftqualität mit BME680 messen

Lerne, wie man die Luftqualität mit dem BME680 Umweltsensor und einem ESP32 misst. Der BME680 ist ein winziger Sensor, der nicht nur Temperatur, Luftfeuchtigkeit und Druck misst, sondern auch die Konzentration flüchtiger organischer Verbindungen (VOC), die gesundheitsschädlich sind.

Die BSEC-Arduino-library für den BME680 macht es besonders einfach, die Luftqualität zu bewerten, da er einen Index der Luftqualität (IAQ) mit Werten im Bereich von 0 bis 400 zurückgibt. Die folgende Tabelle zeigt, wie diese IAQ-Werte zu interpretieren sind:

Meaning of IAQ values (source) — Bedeutung der IAQ-Werte (source)

Wir werden diese Funktionalität nutzen, um ein Luftqualitätsmessgerät zu bauen.

Benötigte Teile

Unten findest du die für dieses Projekt benötigten Teile. Neben dem BME680 Sensor benötigst du einen Mikrocontroller. Ich habe einen älteren ESP32 lite gewählt, aber jeder andere ESP32 funktioniert ebenfalls gut. Beachte, dass der BSEC-Arduino-library, den wir verwenden, auch andere Mikrocontroller unterstützt. Schau dir dazu die readme file an.

Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.

Überblick über den BME680 Gassensor

Der BME680 ist ein winziger, aber leistungsstarker 4-in-1 Umweltsensor, der Temperatur, Luftfeuchtigkeit, barometrischen Druck und vor allem für dieses Projekt Gaswiderstand misst, der zur Schätzung der Innenraumluftqualität (IAQ) verwendet wird. Das Bild unten zeigt den Sensor, der nur 3x3x1 mm groß ist:

Der BME680 verwendet einen Gassensor basierend auf Metalloxid-(MOX)-Technologie. Er erkennt nicht einzelne Gase direkt, sondern reagiert auf eine breite Palette von flüchtigen organischen Verbindungen (VOCs) und Gasen wie Kohlenmonoxid (CO) in der Luft. Diese Verbindungen werden häufig freigesetzt durch:

Reinigungsprodukte und Aerosole
Farben und Lacke
Möbel und Teppiche (besonders neue)
Kochen und Rauchen
Atemluft und Körpergeruch
Verbrennungsgeräte

Obwohl der Sensor keine Gaskonzentrationen in ppm misst, verwendet die BSEC-Bibliothek maschinelle Lernmodelle, um die Gaswiderstandswerte des Sensors in einen aussagekräftigen IAQ-Wert umzuwandeln, was ihn für die Überwachung der Innenraumluftqualität geeignet macht.

Was ist IAQ und warum es wichtig ist

Der IAQ-Wert, den die Softwarebibliothek des BME680 zurückgibt, liefert eine numerische Schätzung der Innenraumluftverschmutzung. Er kombiniert mehrere Umweltmesswerte zu einem einzigen Wert, wobei:

0–50 = Ausgezeichnete Luftqualität
51–100 = Gut
101–150 = Leicht verschmutzt
151–200 = Mäßig verschmutzt
201–300 = Stark verschmutzt
301–500 = Sehr stark verschmutzt

Dieser Wert ist besonders nützlich, da er eine klare und leicht verständliche Zahl liefert, anstatt roher Gaswiderstandswerte, die schwer zu interpretieren sind.

Breakout-Board für BME680

Da der eigentliche BME680 Sensor so winzig ist, verwenden wir ein Breakout-Board, um ihn mit dem ESP32 zu verbinden. Das hat auch den Vorteil, dass wir den Sensor mit 3,3V oder 5V betreiben können, da das Board einen Spannungsregler enthält. Das Bild unten zeigt das Breakout-Board mit Regler und dem BME680 Sensor:

Breakout board for BME680 — Breakout-Board für BME680

Der BME680 ist das kleine quadratische Metallgehäuse auf der rechten Seite. Links sind die Pins für die I2C- oder SPI-Schnittstelle sowie die Stromversorgungsanschlüsse (VCC, GND).

Wir verwenden die I2C-Schnittstelle, da wir nur SDA und SCL anschließen müssen. Beachte, dass der SDO-Pin die I2C-Adresse des Sensors bestimmt. Wenn SDO nicht verbunden ist, wird die Adresse auf 0x77 gesetzt, während eine Verbindung mit Masse die Adresse auf 0x76 ändert.

Für weitere Informationen zum BME680 Sensor siehe unser BME680 Environmental Sensor with Arduino Tutorial, die BME680 Datasheet und vielleicht die Bosch Website for the BME680.

Anschluss des BME680 an ESP32

Um den BME680 über I2C an einen ESP32 lite anzuschließen, verbinden wir SCL mit Pin 23 und SDA mit Pin 19. Die Pins für Hardware-I2C hängen von deinem Board ab und können unterschiedlich sein. Siehe das Find I2C and SPI default pins Tutorial, um die Pins für dein Board herauszufinden.

Ansonsten müssen wir nur GND mit Masse (G) und VCC mit dem 3V (3,3V) Pin des ESP32 verbinden. Das Bild unten zeigt die komplette Verkabelung:

Connecting BME680 to ESP32 — Anschluss des BME680 an ESP32

Code zum Messen von Umweltdaten mit BME680

Wie bereits erwähnt, verwenden wir die BSEC-Arduino-library, um Daten vom BME680 zu lesen. Du kannst sie über den LIBRARY MANAGER installieren. Suche nach „bsec“ und installiere die „BSEC Software Library“ wie unten gezeigt:

BSEC Software Library installed in LIBRARY MANAGER — BSEC Software Library installiert im LIBRARY MANAGER

Beachte, dass es auch die neuere Bosch-BSEC2-Library gibt, die ich nicht ausprobiert habe. Ich habe jedoch die einfachere Adafruit BME680 library in einem anderen Tutorial verwendet (BME680 Environmental Sensor with Arduino). Diese Bibliothek liefert jedoch keine leicht interpretierbaren Luftqualitätswerte (IAQ), daher können wir sie hier nicht verwenden.

Der folgende Code zeigt dir, wie du Luftqualitätsdaten wie IAQ, Gasanteil und auch einfache Umweltdaten wie Temperatur, Luftfeuchtigkeit und Druck mit dem BME680 erfassen kannst. Ich werde den Code Stück für Stück erklären und erläutern, was jeder Abschnitt macht:

#include "bsec.h"

Bsec sensor;

void checkSensor() {
  if (sensor.bsecStatus != BSEC_OK) {
    Serial.println("BSEC status: " + String(sensor.bsecStatus));
  }
  if (sensor.bme68xStatus != BME68X_OK) {
    Serial.println("BME68X status: " + String(sensor.bme68xStatus));
  }
}

void setup(void) {
  Serial.begin(115200);
  delay(1000);

  sensor.begin(BME68X_I2C_ADDR_HIGH, Wire);
  checkSensor();

  bsec_virtual_sensor_t sensorList[8] = {
    BSEC_OUTPUT_IAQ,
    BSEC_OUTPUT_STATIC_IAQ,
    BSEC_OUTPUT_CO2_EQUIVALENT,
    BSEC_OUTPUT_BREATH_VOC_EQUIVALENT,
    BSEC_OUTPUT_RAW_PRESSURE,
    BSEC_OUTPUT_SENSOR_HEAT_COMPENSATED_TEMPERATURE,
    BSEC_OUTPUT_SENSOR_HEAT_COMPENSATED_HUMIDITY,
    BSEC_OUTPUT_GAS_PERCENTAGE
  };

  sensor.updateSubscription(sensorList, 8, BSEC_SAMPLE_RATE_LP);
  checkSensor();
}

void loop(void) {
  if (sensor.run()) {
    Serial.printf("Acc:  %d\n", sensor.iaqAccuracy);
    Serial.printf("IAQ:  %.0f\n", sensor.iaq);
    Serial.printf("sIAQ: %.0f\n", sensor.staticIaq);
    Serial.printf("gas:  %.0f %%\n", sensor.gasPercentage);
    Serial.printf("temp: %.1f C\n", sensor.temperature);
    Serial.printf("hum:  %.0f %%\n", sensor.humidity);
    Serial.printf("pres: %.0f hPa\n", sensor.pressure / 100.0);
    Serial.println();
  }
}

Bibliotheken

Oben im Code wird die BSEC library eingebunden, was für Bosch Sensortec Environmental Cluster steht. Diese Bibliothek kombiniert Rohdaten des BME680 und wendet Algorithmen an, um aussagekräftige Luftqualitätsmesswerte wie IAQ und Gasanteil auszugeben.

#include "bsec.h"

Objekte

Als nächstes erstellen wir eine Instanz der Bsec Klasse namens sensor. Dieses Objekt gibt dir Zugriff auf alle BSEC-Funktionen.

Bsec sensor;

checkSensor

Die checkSensor() Funktion ist eine einfache Fehlerprüfroutine. Sie überprüft sowohl den BSEC Algorithmusstatus als auch den BME688 Hardwarestatus. Wenn ein Problem vorliegt, werden die entsprechenden Fehlercodes im Serial Monitor ausgegeben, damit du sie debuggen kannst.

void checkSensor() {
  if (sensor.bsecStatus != BSEC_OK) {
    Serial.println("BSEC status: " + String(sensor.bsecStatus));
  }
  if (sensor.bme68xStatus != BME68X_OK) {
    Serial.println("BME68X status: " + String(sensor.bme68xStatus));
  }
}

Beachte, dass positive Statuscodes eine Warnung anzeigen, während negative Statuscodes einen Fehler bedeuten!

setup

In der setup() Funktion startet der Code die serielle Kommunikation mit 115200 Baud, um Ausgaben im Serial Monitor anzuzeigen. Es gibt auch eine kurze Verzögerung, um sicherzustellen, dass der serielle Port bereit ist, bevor es weitergeht.

void setup(void) {
  Serial.begin(115200);
  delay(1000);

Dann wird der BME688 Sensor über I2C mit der sensor.begin() Funktion initialisiert. Die Adresse BME68X_I2C_ADDR_HIGH wird verwendet, was 0x77 entspricht. Nach der Initialisierung wird der Sensorstatus überprüft.

sensor.begin(BME68X_I2C_ADDR_HIGH, Wire);
checkSensor();

Die Konstante heißt „HIGH“, da, wenn der SDO-Pin nicht verbunden ist, ein interner Widerstand ihn auf High zieht. Wenn du die andere I2C-Adresse (0x76) verwenden möchtest, indem du SDO mit Masse verbindest, ändere dies entsprechend.

Als nächstes definiert das Sketch, welche virtuellen Sensoren abonniert werden sollen. So kannst du auswählen, welche Sensoren (Temperatur, Luftfeuchtigkeit, …) und welche abgeleiteten Werte (z.B. Roh- vs. wärmekompensierte Temperatur) verwendet werden. Das ist wichtig, wenn du den Stromverbrauch durch Deaktivieren ungenutzter Sensoren reduzieren möchtest.

Die sensor.updateSubscription() Funktion teilt der Bibliothek mit, welche Daten von welchem Sensor wir wollen und wie oft:

bsec_virtual_sensor_t sensorList[8] = {
    BSEC_OUTPUT_IAQ,
    BSEC_OUTPUT_STATIC_IAQ,
    BSEC_OUTPUT_CO2_EQUIVALENT,
    BSEC_OUTPUT_BREATH_VOC_EQUIVALENT,
    BSEC_OUTPUT_RAW_PRESSURE,
    BSEC_OUTPUT_SENSOR_HEAT_COMPENSATED_TEMPERATURE,
    BSEC_OUTPUT_SENSOR_HEAT_COMPENSATED_HUMIDITY,
    BSEC_OUTPUT_GAS_PERCENTAGE
  };

  sensor.updateSubscription(sensorList, 8, BSEC_SAMPLE_RATE_LP);
  checkSensor();
}

Die Konstante BSEC_SAMPLE_RATE_LP steht für Low Power (LP) Sampling. Das ist eine weitere Möglichkeit, den Stromverbrauch des Sensors zu senken. Es gibt z.B. auch einen BSEC_SAMPLE_RATE_ULP für Ultra Low Power (ULP) Verbrauch. Du kannst sogar unterschiedliche Abtastraten für verschiedene virtuelle Sensoren definieren. Siehe das basic_config_state_ULP_LP Beispiel.

loop

Die loop() Funktion erledigt die Echtzeitarbeit. Die sensor.run() Funktion prüft, ob neue Daten von der BSEC-Bibliothek verfügbar sind. Falls ja, gibt der Code verschiedene Messwerte im Serial Monitor aus:

void loop(void) {
  if (sensor.run()) {
    Serial.printf("Acc:  %d\n", sensor.iaqAccuracy);
    Serial.printf("IAQ:  %.0f\n", sensor.iaq);
    Serial.printf("sIAQ: %.0f\n", sensor.staticIaq);
    Serial.printf("gas:  %.0f %%\n", sensor.gasPercentage);
    Serial.printf("temp: %.1f C\n", sensor.temperature);
    Serial.printf("hum:  %.0f %%\n", sensor.humidity);
    Serial.printf("pres: %.0f hPa\n", sensor.pressure / 100.0);
    Serial.println();
  }
}

Beachte, dass dies nur ein kleiner Ausschnitt der möglichen Messwerte ist, die die BSEC-Bibliothek zurückgeben kann. Die folgende Tabelle listet alle Werte, ihre Bedeutung und ihren Bereich auf:

Wert	Beschreibung	Einheit/Bereich	Art	Typ
`iaq`	Indoor Air Quality Index (Echtzeit, dynamisch)	Index (0–500)	Verarbeitet	`float`
`iaqAccuracy`	Vertrauen in den `iaq` Wert	0–3	Status	`uint8_t`
`staticIaq`	Geglätteter IAQ-Wert (weniger empfindlich gegenüber Schwankungen)	Index (0–500)	Verarbeitet	`float`
`staticIaqAccuracy`	Vertrauen in den `staticIaq`	0–3	Status	`uint8_t`
`co2Equivalent`	Geschätzte CO₂-Konzentration aus VOCs	ppm	Verarbeitet	`float`
`co2Accuracy`	Vertrauen in den `co2Equivalent`	0–3	Status	`uint8_t`
`breathVocEquivalent`	Geschätzter VOC-Äquivalentwert der Atemluft	ppm	Verarbeitet	`float`
`breathVocAccuracy`	Vertrauen in den `breathVocEquivalent`	0–3	Status	`uint8_t`
`compGasValue`	Kompensierter Gaswert, intern verwendet	Ohm (normalisiert)	Intern	`float`
`compGasAccuracy`	Vertrauen in den `compGasValue`	0–3	Status	`uint8_t`
`gasPercentage`	Geschätzter Anteil sauberer Luft	%	Verarbeitet	`float`
`gasPercentageAccuracy`	Vertrauen in den `gasPercentage`	0–3	Status	`uint8_t`
`rawTemperature`	Unkompensierte Temperatur vom Sensor	°C	Rohwert	`float`
`temperature`	Kompensierte Temperatur (korrigiert für Eigenwärme des Sensors)	°C	Kompensiert	`float`
`rawHumidity`	Unkompensierte relative Luftfeuchtigkeit	%	Rohwert	`float`
`humidity`	Kompensierte relative Luftfeuchtigkeit	%	Kompensiert	`float`
`pressure`	Barometrischer Druck	hPa	Rohwert	`float`
`gasResistance`	Rohwiderstand des Gassensors	Ohm	Rohwert	`float`
`stabStatus`	Ob die Probe stabilisiert ist	0 oder 1 (boolescher Wert)	Status	`float`
`runInStatus`	Ob der Sensor sich noch in der Einlaufphase befindet	0 oder 1	Status	`float`

Im Code geben wir die Werte iaqAccuracy (Acc), iaq (IAQ), staticIaq (sIAQ), gasPercentage (gas), temperature (temp), humidity (hum) und pressure (pres) aus. Temperatur und Luftfeuchtigkeit sind die kompensierten Werte (unter Berücksichtigung der Heizung des Gassensors) und der Druck wird durch 100 geteilt, um den Druck in Hektopascal (hPa) zurückzugeben.

Die interessantesten Werte sind iaq (IAQ) und staticIaq (sIAQ), wobei letzterer nur eine stabilere Version des ersten ist. Der IAQ-Wert ist direkt mit einer umsetzbaren Interpretation der Luftqualität verbunden, wie in der folgenden Tabelle gezeigt:

Ausgabe

Wenn du den Code hochlädst und ausführst, solltest du die Messwerte im Serial Monitor sehen:

Output in Serial Monitor — Ausgabe im Serial Monitor

Der Gassensor des BME680 benötigt jedoch eine beträchtliche Einlaufzeit, die je nach Umgebungsbedingungen und Abtastrate zwischen ~5 bis 30 Minuten liegt. Bis dahin erscheint der IAQ-Wert typischerweise fix bei 25 oder 50.

Der iaqAccuracy Wert, der als Acc im Serial Monitor ausgegeben wird, ist ein Vertrauensindikator für IAQ- (und andere) gasbezogene Messungen.

Anfangs siehst du einen Wert von 0, was bedeutet, dass die IAQ-Messungen noch nicht gültig sind (siehe Beispielausgabe oben). Mit der Zeit steigt der iaqAccuracy Wert von 0 → 1 → 2 → 3 und sobald er 3 erreicht, gelten die IAQ-Messwerte als gültig! Unten ein Beispiel für eine Ausgabe nach abgeschlossener Einlaufphase des Sensors mit einem iaqAccuracy (Acc) von 3:

Output in Serial Monitor after burn-in — Ausgabe im Serial Monitor nach Einlaufphase

Es ist natürlich sehr lästig, jedes Mal bis zu 20 Minuten auf gültige Messwerte warten zu müssen, wenn der BME680 zurückgesetzt wird oder die Stromversorgung verliert. Glücklicherweise kann die Einlaufzeit verkürzt werden, indem man den Zustand des BME680 Sensors speichert und wiederherstellt. Wie das geht, wird im nächsten Abschnitt beschrieben.

Code zum Speichern und Wiederherstellen des BME680-Zustands

Der folgende Code erweitert unseren vorherigen Code um zwei Funktionen, saveState und loadState, mit denen wir den Zustand des BME680 Sensors speichern und die Zeit bis zu verfügbaren gasbezogenen Messungen verkürzen können:

#include <Preferences.h>
#include "bsec.h"

const unsigned long savePeriod = 3600 * 1000;  // 1 hour

Bsec sensor;
Preferences prefs;

void checkSensor() {
  if (sensor.bsecStatus != BSEC_OK) {
    Serial.println("BSEC status: " + String(sensor.bsecStatus));
  }
  if (sensor.bme68xStatus != BME68X_OK) {
    Serial.println("BME68X status: " + String(sensor.bme68xStatus));
  }
}

void saveState() {
  uint8_t state[BSEC_MAX_STATE_BLOB_SIZE];
  sensor.getState(state);
  prefs.begin("bsec", false);
  prefs.putBytes("state", state, BSEC_MAX_STATE_BLOB_SIZE);
  prefs.end();
  Serial.println("Sensor state saved");
}

void loadState() {
  prefs.begin("bsec", true); 
  if (prefs.getBytesLength("state") > 0) {
    uint8_t state[BSEC_MAX_STATE_BLOB_SIZE];
    prefs.getBytes("state", state, BSEC_MAX_STATE_BLOB_SIZE);
    sensor.setState(state);
    Serial.println("Sensor state loaded");
  }
  prefs.end();
}

void setup(void) {
  Serial.begin(115200);
  delay(1000);

  sensor.begin(BME68X_I2C_ADDR_HIGH, Wire);
  checkSensor();
  loadState();

  bsec_virtual_sensor_t sensorList[8] = {
    BSEC_OUTPUT_IAQ,
    BSEC_OUTPUT_STATIC_IAQ,
    BSEC_OUTPUT_CO2_EQUIVALENT,
    BSEC_OUTPUT_BREATH_VOC_EQUIVALENT,
    BSEC_OUTPUT_RAW_PRESSURE,
    BSEC_OUTPUT_SENSOR_HEAT_COMPENSATED_TEMPERATURE,
    BSEC_OUTPUT_SENSOR_HEAT_COMPENSATED_HUMIDITY,
    BSEC_OUTPUT_GAS_PERCENTAGE
  };

  sensor.updateSubscription(sensorList, 8, BSEC_SAMPLE_RATE_LP);
  checkSensor();
}

void loop(void) {
  static unsigned long lastSave = millis();

  if (sensor.run()) {
    Serial.printf("Acc:  %d\n", sensor.iaqAccuracy);
    Serial.printf("IAQ:  %.0f\n", sensor.iaq);
    Serial.printf("sIAQ: %.0f\n", sensor.staticIaq);
    Serial.printf("gas:  %.0f %%\n", sensor.gasPercentage);
    Serial.printf("temp: %.1f C\n", sensor.temperature);
    Serial.printf("hum:  %.0f %%\n", sensor.humidity);
    Serial.printf("pres: %.0f hPa\n", sensor.pressure / 100.0);
    Serial.println();

    if (millis() - lastSave > savePeriod && sensor.iaqAccuracy >=3) {
      saveState();
      lastSave = millis();
    }
  }
}

saveState

Die saveState Funktion nutzt den Preferences library des ESP32, um den Zustand des BME680 im nichtflüchtigen Speicher (NVS) des ESP32 zu speichern. Diese Daten bleiben auch bei Neustarts und Stromausfällen erhalten.

void saveState() {
  uint8_t state[BSEC_MAX_STATE_BLOB_SIZE];
  sensor.getState(state);
  prefs.begin("bsec", false);
  prefs.putBytes("state", state, BSEC_MAX_STATE_BLOB_SIZE);
  prefs.end();
  Serial.println("Sensor state saved");
}

Der Zustand umfasst gelernte Baselines für Gaswiderstand, Temperatur und Luftfeuchtigkeit, die der Sensor zur genauen Berechnung von IAQ und anderen Werten verwendet.

Die Funktion reserviert einen Speicherblock der Größe BSEC_MAX_STATE_BLOB_SIZE für den Zustand und kopiert dann den Sensorzustand in diesen Speicherblock, indem sie getState(state) aufruft.

Anschließend öffnen wir einen Namespace namens "bsec" im NVS des ESP32 durch Aufruf von prefs.begin("bsec", false), wobei false für Lese- und Schreibmodus steht.

Danach speichern wir das binäre Zustandsarray unter dem Schlüssel "state" im Flash-Speicher und schließen die NVS-Sitzung (prefs.end), um sicherzustellen, dass die Daten geschrieben werden.

loadState

Die loadState Funktion lädt den zuvor gespeicherten Zustand, falls vorhanden:

void loadState() {
  prefs.begin("bsec", true); 
  if (prefs.getBytesLength("state") > 0) {
    uint8_t state[BSEC_MAX_STATE_BLOB_SIZE];
    prefs.getBytes("state", state, BSEC_MAX_STATE_BLOB_SIZE);
    sensor.setState(state);
    Serial.println("Sensor state loaded");
  }
  prefs.end();
}

Wenn prefs.getBytesLength("state") 0 zurückgibt, wurde der Sensorzustand noch nicht gespeichert und das Laden wird übersprungen.

Andernfalls rufen wir prefs.getBytes("state", state, BSEC_MAX_STATE_BLOB_SIZE) auf, um den Zustand abzurufen und schreiben ihn mit sensor.setState(state) in den Sensor.

setup

In der setup Funktion rufen wir loadState nach der Initialisierung des Sensors auf. Somit wird beim Verlust der Stromversorgung oder Reset des ESP32 und damit des BME680 Sensors setup aufgerufen und der Sensorzustand wiederhergestellt – sofern er gespeichert wurde.

void setup(void) {
  ...

  sensor.begin(BME68X_I2C_ADDR_HIGH, Wire);

  loadState();

  ...
}

loop

In der loop-Funktion speichern wir regelmäßig den Sensorzustand, z.B. jede Stunde, vorausgesetzt iaqAccuracy ist 3 (oder höher):

void loop(void) {
  static unsigned long lastSave = millis();

  if (sensor.run()) {
    Serial.printf("Acc:  %d\n", sensor.iaqAccuracy);
    ...

    if (millis() - lastSave > savePeriod && sensor.iaqAccuracy >=3) {
      saveState();
      lastSave = millis();
    }
  }
}

Der Zeitraum für das Speichern wird durch die Konstante savePeriod gesteuert. Ich habe eine Stunde gewählt, aber du musst nicht so häufig speichern. Auch alle drei oder vier Stunden sind in Ordnung.

const unsigned long savePeriod = 3600 * 1000;  // 1 hour

Beachte, dass trotz Speichern und Wiederherstellen des Sensorzustands der iaqAccuracy nach einem Neustart des Sensors noch 0 sein wird, aber die Zeit bis zum Erreichen von 3 kürzer ist.

Fazit

In diesem Tutorial hast du gelernt, wie man die Luftqualität mit dem BME680 Umweltsensor, einem ESP32 und der BSEC-Arduino-library misst.

Die BSEC-Arduino-library enthält mehrere Codebeispiele, die einen Blick wert sind. Der Code in diesem Tutorial basiert auf dem basic.ino Beispiel. Das basic_config_state.ino Beispiel zeigt, wie man den Sensorzustand speichert und wiederherstellt. Und mit dem basic_config_state_ulp_plus.ino kannst du den Sensor im Ultra-Low-Power-(ULP)-Modus betreiben. Für Deep-Sleep siehe das esp32DeepSleep.ino Beispiel.

Der BME680 misst auch Temperatur, Luftfeuchtigkeit und Druck, aber wenn das dein Hauptinteresse ist und du keine IAQ-Werte brauchst, verwende den Adafruit BME680 library statt des komplexeren BSEC-Arduino-library. Siehe das BME680 Environmental Sensor with Arduino Tutorial für Details.

Wenn du keine Gas-Messungen benötigst, empfehle ich den BME280 Sensor, der kleiner und günstiger ist. Siehe das How To Use BME280 Pressure Sensor With Arduino Tutorial für mehr Informationen.

Wenn du Fragen hast, hinterlasse sie gerne im Kommentarbereich.

Viel Spaß beim Tüfteln ; )

Stefan Maetschke

Benötigte Teile

BME680 Sensor

ESP32 lite

USB-Datenkabel

Dupont-Kabelsatz

Breadboard

Überblick über den BME680 Gassensor

Was ist IAQ und warum es wichtig ist

Breakout-Board für BME680

Anschluss des BME680 an ESP32

Code zum Messen von Umweltdaten mit BME680

Bibliotheken

Objekte

checkSensor

setup

loop

Ausgabe

Code zum Speichern und Wiederherstellen des BME680-Zustands

saveState

loadState

setup

loop

Fazit