In den letzten Jahren ist die Qualität der Luft, die wir einatmen, leider zu einem nicht zu vernachlässigenden Problem geworden. Das gilt schon seit langem für Innenräume, vor allem im Winter, wenn sich viele von uns in schlecht belüfteten Räumen aufhalten, aber auch im Freien, vor allem in den Städten, deren Luft zunehmend durch Schadstoffemissionen von Kraftfahrzeugen, Heizwerken (vergessen wir nicht, dass Erdgas kein reines Methan ist, sondern auch andere Gase und Zusätze zur Geruchs- und Flammenfärbung enthält... ) von Fabriken und Wärmekraftwerken und so weiter; und wo der Mangel an Grün die Sauerstoffanreicherung der Luft nicht fördert, die somit einen niedrigen Sauerstoffgehalt hat und die natürlichen Prozesse des menschlichen und tierischen Organismus nicht fördert.
 

In Innenräumen wird die Luftqualität durch Elemente wie das von uns ausgeatmete Kohlendioxid, aber auch durch Feinstaub und Krankheitserreger, die wir durch Atmen oder Husten ausstoßen, beeinträchtigt; man denke beispielsweise an die COVID 19-Infektion, mit der wir seit langem leben und die einen ihrer Hauptübertragungswege in der Raumluft hat. Die Verbreitung dieses und anderer Viren in geschlossenen Räumen ist im Wesentlichen ein Problem der Luftqualität: Je "verschmutzter" die Luft ist, desto höher ist die Konzentration von Tröpfchen (Speicheltröpfchen und organische Flüssigkeiten von Schleimhäuten), die potenziell mit Krankheitserregern beladen sind und Krankheiten übertragen können. Die Lösung zur Eindämmung der Ansteckung besteht natürlich darin, einen Luftaustausch vorzunehmen, um die Konzentration dieser Krankheitserreger zu verringern. Aber wann soll man das tun, da wir sowohl im Sommer als auch im Winter dazu neigen, unsere Fenster geschlossen zu halten, um den Verbrauch von Klimaanlagen und Heizungssystemen zu reduzieren?
 

Nun, in diesem Artikel schlagen wir ein einfaches Gerät vor, das durch das Ablesen eines CO2- und TVOC-Sensors (d.h. die Konzentration von schwebenden organischen Partikeln in der Luft, in Italien auch unter der Abkürzung VOC - Volatile Organic Compounds - bekannt) eine Vorstellung von der Luftqualität eines Raumes vermittelt und uns durch LEDs signalisiert, wann es Zeit ist, einen Austausch vorzunehmen, so dass wir die Luftqualität unter Kontrolle halten und Energieverluste minimieren können.

Abonnieren
Tag-Benachrichtigung zu ESP32 jetzt abonnieren!

Die Hardware des Projekts

Um das bisher vorgestellte Gerät zu realisieren, haben wir uns entschieden, ein Heltec WiFi Kit 32-Modul als Steuereinheit, einen SGP30-Sensor von Sensirion als Detektorelement für die Kohlendioxid- und TVOC-Konzentration und zwei gewöhnliche LEDs (eine rot und die andere grün) als Signalelemente zu verwenden. Das konzeptionelle Schema des Systems ist in Bild 1 dargestellt.

 

Concept of air quality measurement.
Bild 1: Konzept des Systems zur Messung und Meldung der Luftqualität.

Heltec WiFi Kit 32 Modul

Das Heltec WiFi Kit 32 Modul, das letztlich das Herzstück unseres Systems ist, ist eine kleine Elektronikplatine, die einen ESP32-Mikrocontroller und ein 0,96-Zoll-OLED-Display integriert; Sie können es in Bild 2 sehen. Die Hardware-Merkmale des WiFi Kit 32 Moduls, mit dem wir in diesem Projekt arbeiten werden, sind:

  • 0.96-inch blaues OLED Display;
  • 32-bit Dual-Core Tensilica LX6 Mikrocontroller;
  • Taktfrequenz bis zu 240 MHz;
  • 520 kB interner SRAM;
  • 32 MB Flash-Speicher;
  • Eingebauter 802.11 b/g/n Wi-Fi-Transceiver;
  • Eingebautes Dual-Mode-Bluetooth (klassisch und BLE);
  • Spannungsversorgung: 3,3 V bis 7 V;
  • 28 GPIOs (einige werden zur Steuerung des OLED-Displays verwendet);
  • Eingebautes Lithium-Polymer-Akku-Ladegerät;
  • Arbeitstemperatur: -40 °C bis +90 °C


Dieses Modul erweist sich als perfekt für unseren Zweck, da es bereits ein OLED-Display integriert hat, das wir für die Anzeige der Luftqualitätswerte und für Benutzernachrichten verwenden werden, sowie mehrere GPIO-Kanäle, die wir für die Steuerung unserer Signalgeber benötigen; in dieser ersten Version planen wir, nur 2 LEDs zu verwenden, aber die Anzahl der verfügbaren GPIOs (insgesamt 28) würde es uns leicht ermöglichen, andere Elemente hinzuzufügen, wie z. B. einen Summer, um akustische Signale zu erzeugen. Zusätzlich zu diesen Funktionen verfügt das Modul über 520 KByte On-Board-RAM und bis zu 32 MByte Flash, Funktionen, die es uns ermöglichen, in Bezug auf die Speicherressourcen für unsere Steuerungssoftware komfortabel zu sein.

Bild 2: Das Heltec WiFi Kit 32 Modul.

Darüber hinaus verfügt das Modul über einen standardmäßigen 802.11 WiFi-Transceiver, den wir für künftige Entwicklungen dieses Geräts nutzen können (z. B. zur Veröffentlichung von Daten über CO2- und TVOC-Konzentrationen direkt auf einer Webseite oder zum Senden von Alarmen über Telegram), sowie über ein Bluetooth-Funkgerät, das wir für die Verbindung mit externen Geräten wie Smartphones und PCs nutzen können, die wir schließlich zur Konfiguration des Geräts selbst verwenden können. Schließlich verfügt die Platine auch über ein integriertes LiPo-Ladegerät, das es uns ermöglicht, eine einzellige Batterie anzuschließen, was sehr nützlich ist, um das Gerät auch bei fehlender Netzspannung mit Strom zu versorgen. Bild 3 zeigt die Pinbelegung unseres Moduls.

 

230543-005-94-ORIGINAL-figura3.png
Bild 3: Pinbelegung des Wi-Fi Kit 32-Moduls.

Der SGP30-Sensor

Um die Kohlendioxid- und TVOC-Konzentration in der Luft zu bestimmen, haben wir uns für ein Breakout-Board entschieden, das auf dem SGP30-Sensor von Sensirion basiert. Mit diesem winzigen Sensor können wir die Konzentration von Kohlendioxid (um festzustellen, wie stark die Luft in einer geschlossenen Umgebung verschmutzt ist) und TVOC (Total Volatile Organic Compounds), d. h. die Konzentration von Schwebeteilchen in Teilen pro Milliarde, ermitteln. Ein Bild des Breakout-Boards ist in Bild 4 zu sehen. Die detaillierten Hardware-Merkmale des Breakout-Boards sind wie folgt:

  • Sensor: Sensirion SGP30 (TVOC und CO2);
  • TVOC (Total Volatile Organic Compounds) Nachweis: 0 bis 60.000 ppb (Teile pro Milliarde);
  • CO2-Erkennung: 400 bis 60.000 ppm (Teile pro Million);
  • Abtastfrequenz: 1 Hz;
  • Schnittstelle: I2C (Adresse 0x58)
  • Spannungsversorgung: 3,3 V oder 5 V.
 
230543-012-94-ORIGINAL-figura4.png
Bild 4: Das Breakout-Board für den SGP30-Sensor.

Hardware-Verdrahtung

Sehen wir uns nun an, wie unser Gerät in der Praxis aufgebaut wird, beginnend mit dem physischen Aufbau und dann der Verdrahtung der Komponenten. Die Verbindung zwischen der Sensorplatine und den LEDs ist so einfach, dass sie mit Hilfe von Überbrückungsdrähten (männlich/weiblich) wie bei Arduino oder mit Hilfe eines Breadboards hergestellt werden kann, wie Sie auf diesen Seiten sehen. Der SGP30-Sensor ist ein Breakout-Board, das über den I²C-Bus angeschlossen wird. Daher sind insgesamt vier Anschlüsse erforderlich, da zusätzlich zu den Takt- (SCL) und Datenleitungen (SDA) des I²C-Busses auch die beiden Stromversorgungsleitungen (GND und die positive 3,3-V-Leitung) angeschlossen werden müssen.

Diagram of air quality meter.
Bild 5: Gesamtverdrahtungsplan des Messgeräts.

Die beiden LEDs hingegen werden über zwei Standard-GPIOs aus dem WiFi-Modul-Bausatz 32 angeschlossen; diese LEDs können nicht direkt über die Leitungen auf der Platine angesteuert werden, um eine Überlastung der GPIOs zu vermeiden, sondern wir müssen geeignete strombegrenzende Widerstände in Reihe mit ihnen schalten, die wir auf jeweils 220 Ohm berechnet haben. Um Ihnen das Herstellen der Verbindungen zu erleichtern, ist in Bild 5 der Schaltplan dargestellt, der zu verwenden ist, wenn Sie die verschiedenen Elemente über gelötete Leitungen oder Steckbrücken miteinander verbinden wollen. Darüber hinaus zeigt Tabelle 1 die Verbindungen zwischen dem WiFi Kit 32 Modul und dem SGP30 Breakout Board. Tabelle 2 hingegen zeigt die für die beiden Signal-LEDs verwendeten Pins des WiFi Kit 32-Moduls.

Tabelle1: Verbindungen zwischen WiFi Kit 32 und SGP30 Breakout.
Function WiFi Kit 32 Pin SGP30 Breakout Pin
SDA 19 sda
SCL 18 scl
Ground GND GND
3.3 V 3V3 Vcc

 

Tabelle 2: LED Verbindungen.
LED WiFi Kit 32 Pin
Green 2
Red 17

 

Software Realisierung

Nachdem wir uns die Hardware-Details unseres Systems angeschaut haben, gehen wir zur Software über. Für die Entwicklung der Steuerungssoftware haben wir uns für MicroPython entschieden, und zwar speziell für den Port für ESP32. MicroPython ist ein leistungsfähiges System für die Softwareentwicklung von Anwendungen für moderne, IoT-orientierte Mikrocontroller wie den ESP32, und darüber hinaus erleichtert die große Menge an vorhandenen Bibliotheken für den Umgang mit Sensoren, Aktoren und Schnittstellen diese Phase der Entwicklung erheblich.

Abonnieren
Tag-Benachrichtigung zu MicroPython jetzt abonnieren!

MicroPython Installation

Um MicroPython auf dem WiFi Kit 32 zu verwenden, muss als erstes der interpreter installiert werden, da das WiFi Kit 32 ihn nicht standardmäßig enthält. Die für die Entwicklung dieser Anwendung verwendete Version ist v1.19 (2022-06-18). Laden Sie die FW herunter und speichern Sie sie in einem Ordner auf Ihrem PC. Zu diesem Zeitpunkt müssen Sie sich auch mit esptool ausstatten, einem Tool zum Beschreiben des Flash-Speichers des ESP32, das von Espressif kostenlos zur Verfüngung gestellt wird (the company that manufactures the ESP32 and ESP8266). An diesem Punkt müssen Sie den Gerätespeicher löschen und dann das MicroPython-Binary "flashen" (in den Flash-Speicher laden).

Löschen des Speichers

Schließen Sie zunächst das WiFi Kit 32 über ein Micro-USB-Kabel an Ihren PC an. Das Gerät sollte mit einem virtuellen COM-Port verbunden sein (z.B. COM3, aber die genaue Anzahl hängt davon ab, wie viele Ports Sie bereits in Ihrem System haben). Versetzen Sie nun die Karte in den Programmiermodus, indem Sie die PRG-Taste gedrückt halten und die RST-Taste drücken und loslassen. Jetzt müssen Sie nur noch das Skript esptool.py verwenden, um den Speicher zu löschen. Sie können den Pfad des Skripts in Ihren Systempfad einfügen oder direkt von diesem Ordner aus arbeiten und den Speicher mit folgendem Befehl löschen (gültig in Windows-Umgebung):


python esptool.py --port <port_numb> erase_flash


Ersetzen Sie <port_numb> durch den Ihrem Gerät zugewiesenen virtuellen COM-Port (z. B. COM3).
 

Flashen des MicroPython-Interpreters

An diesem Punkt können Sie MicroPython flashen (in ESP32 sollte der Interpreter an der Adresse 0x1000 geflasht werden). Sie können den folgenden Konsolenbefehl verwenden, ebenfalls unter Windows:


python esptool.py --chip esp32 --port <port_numb> --baud 460800 write_flash -z 0x1000 esp32.bin


Wie zuvor ersetzen Sie <port_numb> durch den virtuellen COM-Port, der Ihrem Gerät zugewiesen ist, und esp32.bin durch den Namen (und möglicherweise den Pfad, falls er nicht mit demjenigen übereinstimmt, von dem aus Sie arbeiten) der Binärdatei, die Sie zuvor heruntergeladen haben. Bild 6 zeigt das Ergebnis dieses Vorgangs.

230543-007-94-ORIGINAL-figura5.png
Bild 6: Ausgabe der Windows-Konsole nach dem Flashen von MicroPython.

Steuerungssoftware

An diesem Punkt können wir mit der Verwaltung der Steuerungssoftware für unser Board fortfahren. Wie bereits erwähnt, wollen wir die vom SGP30-Sensor gelieferten Daten für CO2- und TVOC-Werte erfassen, diese Daten auf einem OLED-Display anzeigen und die Benutzerschwellenwerte für CO2-Grenzwerte (mit zugehöriger Hysterese) aus dem Dateisystem lesen. Verwaltung von zwei Anzeige-LEDs (rot und grün), die anzeigen, ob der CO2-Gehalt über dem maximal zulässigen Grenzwert liegt. Um diese Software zu implementieren, benötigen wir zunächst geeignete Treiber für die Verwaltung des OLED-Displays und des SGP30-Sensors. Glücklicherweise sind beide Treiber verfügbar, entwickelt von Adafruit. Sie können unter den folgenden Links heruntergeladen werden:

 
air_quality.py (main file of the application); ssd1306.py (OLED display driver); adafruit_sgp30.py (SGP30 sensor driver).
Bild 7: Software Architektur.

Das architektonische Diagramm der Software, die wir zu implementieren vorschlagen, ist in Bild 7 dargestellt. Das gesamte Projekt ergibt sich also aus diesen drei Dateien:

  • - air_quality.py (Hauptdatei der Anwendung);
  • - ssd1306.py (OLED-Display-Treiber);
  • - adafruit_sgp30.py (SGP30-Sensortreiber).
 
230543-009-94-ORIGINAL-figura7.png
Bild 8: Konfiguration der MicroPython-Portierung für ESP32 in Thonny.

Als Entwicklungs-IDE für diese Anwendung werden wir Thonny verwenden, eine der am weitesten verbreiteten IDEs für Python, die sowohl die Entwicklung von Standard-Python- als auch von MicroPython-Anwendungen ermöglicht. Thonny kann kostenlos von hier heruntergeladen werden. Die Verbindung mit MicroPython ist sehr einfach: Nachdem Sie die WiFi Kit 32-Karte an den USB-Port des PCs angeschlossen haben, öffnen Sie Thonny und klicken Sie auf die untere rechte Ecke: In dem Dropdown-Menü, das sich nach dem Klicken öffnet, wählen Sie unter den verschiedenen verfügbaren Interpretern ESP32 aus, wie in Bild 8 dargestellt. Sollte der Interpreter nicht vorhanden sein, wählen Sie Interpreter konfigurieren... und geben Sie manuell den Interpreter und den zu verwendenden COM-Port an, wie in Bild 9 dargestellt.

230543-01.jpg
Bild 9: Manuelle Einrichtung des Interpreters und der COM-Schnittstelle in Thonny.

Wir wenden uns nun den Details der Anwendungssoftware zu, die vollständig in der Datei air_quality.py enthalten ist und in zwei verschiedene Phasen unterteilt ist:

  • System-Einrichtung
  • Hauptschleife
 
// -------------------------------------------------
// - SYSTEM INIT
// -------------------------------------------------
// LEDs
led_green = Pin(2, Pin.OUT)
led_red = Pin(17, Pin.OUT)
led_green.on()
led_red.off()

// Initialize I2C buses
s_i2c = I2C(scl=Pin(18), sda=Pin(19), freq=100000)
d_i2c = SoftI2C(scl=Pin(15), sda=Pin(4), freq=100000)


// OLED enable pin
oled_sts = Pin(16, Pin.OUT)
oled_sts.on()


// OLED initialization
oled_width = 128
oled_height = 64
oled = ssd1306.SSD1306_I2C(oled_width, oled_height, d_i2c)


// Air quality sensor init
sgp30 = adafruit_sgp30.Adafruit_SGP30(s_i2c)


// Initialize SGP-30 internal drift compensation algorithm.
sgp30.iaq_init()


// Wait 15 seconds for the SGP30 to properly initialize
user_message(‘Sensor Init...’)
time.sleep(SENS_INIT_DELAY_S)


// User threshold for LEDs indication
get_user_threshold()


// Sensor Calibration
get_sensor_baseline()


// Store the time at which last baseline has been saved
baseline_time = time.time()


Die erste Phase stellt, wie der Name schon sagt, die Initialisierungsphase des Systems dar, während die zweite die Hauptschleife ist, in der die Messung, das Drucken der Werte auf dem OLED-Display und die Statusmeldung über die LEDs erfolgen. Die erste Phase, deren Code in Listing 1 wiedergegeben ist, ist für die Initialisierung aller Peripheriegeräte des Systems verantwortlich, wie z. B. die LEDs, die beiden I²C-Busse (einer wird für die Anbindung des OLED-Displays verwendet, der andere für die Verwaltung des SGP30-Sensors), und für das Abrufen der Werte der SGP30-Sensor-Basislinie und des vom Benutzer eingestellten CO2-Grenzwerts aus dem Dateisystem. Diese Dateien sind Textdateien, die die Software im Dateisystem erwartet. Die Sensor-Basislinienwerte sind Kalibrierungswerte, die die Messgenauigkeit verbessern, und werden von der Software automatisch erstellt, wenn sie nicht vorhanden sind. Dateien, die den Alarmschwellenwert für den CO2-Wert enthalten, müssen dagegen vom Benutzer erstellt werden; sind sie nicht vorhanden, werden Standardwerte geladen. Die folgenden beiden Dateien müssen erstellt werden, um diesen Schwellenwert festzulegen:

  • co2eq_th.txt = enthält den Alarmwert für den CO2-Wert in ppm (parts per million);
  • hist_th.txt = enthält die Hysterese des vorherigen Schwellenwerts, ebenfalls in ppm.
 
230543-011-94-ORIGINAL-figura9.png
Bild 10: Zugriff auf den Speicher des Geräts von Thonny aus.

Die Erstellung dieser Dateien ist einfach: Wählen Sie in der Thonny-Umgebung bei über USB angeschlossenem Board das Dateisymbol oder Datei > Neu. Wiederholen Sie dies zweimal, um zwei Dateien zu erstellen, und schreiben Sie die Werte hinein (z. B. 450 in die Datei co2eq_th.txt und 10 in die Datei hist_th.txt, so dass Sie einen Schwellenwert von 450 ppm CO2 und eine Hysterese von 10 ppm haben). Klicken Sie nun auf das Diskettensymbol (oder wählen Sie Datei > Speichern) und wählen Sie in dem daraufhin angezeigten Popup-Fenster Micropython-Gerät, wie in Bild 10 dargestellt. Dadurch können Sie auf das Dateisystem des Geräts zugreifen und die zuvor erstellten Dateien speichern. So können Sie den CO2-Schwellenwert des Gehäuses einstellen. Sobald die Initialisierungsphase abgeschlossen ist, wechselt die Software in die Hauptschleife, die in Listing 2 dargestellt ist.

// ------------------------------------------------
// - MAIN LOOP
// ------------------------------------------------
while True:
    // Get CO2 and TVOC data
    co2eq, tvoc = sgp30.iaq_measure()
    
    // Print values on Display
    oled_data(co2eq, tvoc)
    
    // Manage LEDs
    if (co2eq > co2eq_th):
        led_green.off()
        led_red.on()
    elif (co2eq < (co2eq_th - hysteresis)):
        led_green.on()
        led_red.off()        
    
    // Update sensor baseline
    update_sensor_baseline()

   
// Wait for the new sampling time
    time.sleep(SAMPLING_TIME_S)


Dabei werden die folgenden Operationen nacheinander durchgeführt. Durch eine iaq_measure() Funktion der adafruit_sgp30-Bibliothek (sgp30_iaq_measure()) werden die CO2- und TVOC-Werte erfasst und in den beiden Variablen co2eq bzw. tvocgespeichert. In der nächsten Zeile werden die Werte über die Funktion oled_data()auf dem OLED-Display ausgegeben. Als nächstes wird durch eine Reihe von if...elif Anweisungen die LED-Signalisierung behandelt. Ist der in der Variablen co2eq gespeicherte Wert größer als der vom Benutzer festgelegte Schwellenwert co2eq_th, werden die roten LEDs eingeschaltet und die grünen LEDs ausgeschaltet; ist der Wert dagegen kleiner als der Schwellenwert abzüglich der Hysterese (co2eq_th - hysteresis), werden die roten LEDs ausgeschaltet und die grünen LEDs eingeschaltet. Nach Abschluss dieser Phase wird die Funktion update_sensor_baseline() aufgerufen, um die Basislinie des Sensors zu aktualisieren.

 

Um einen optimalen Betrieb des Sensors zu gewährleisten, aktualisiert die Software die Basislinie zum ersten Mal nach 12 Betriebsstunden und danach jede Stunde, wie im Datenblatt des SGP30-Herstellers angegeben. Zu diesem Zeitpunkt pausiert die Schleife für 60 Sekunden, bevor ein neuer Datenerfassungszyklus gestartet wird. Das vollständige Softwareprojekt dieser Anwendung, komplett mit Beschreibung und allen erforderlichen MicroPython-Bibliotheken, kann vom entsprechenden GitHub repository heruntergeladen werden.

 

Um die Software zu testen, müssen Sie die beiden Dateien, die die Treiber enthalten, im Speicher der WiFi Kit 32-Karte speichern, wobei Sie das gleiche Verfahren wie beim Speichern der Benutzerdateien anwenden und darauf achten, die gleichen Dateinamen beizubehalten und die Erweiterung .py nicht zu vergessen. Die Hauptdatei kann direkt von Thonny aus gestartet oder im Speicher des Geräts gespeichert werden, indem man sie in main.py umbenennt, was notwendig ist, wenn man das Gerät im Standalone-Modus betreiben will, d.h. wenn es nicht mit dem PC verbunden ist (die Datei main.py ist nämlich die Datei, die vom MicroPython-Interpreter beim Start automatisch durchsucht wird). Bild 11 zeigt ein Bild des Geräts, das auf einer Lochrasterplatine verdrahtet ist, während es Daten zur Luftqualität erfasst und die LEDs aktiviert.

Checking air quality
Bild 11: Der Prototyp, zu Testzwecken verdrahtet auf einem Breadboard.

Konfiguration

Die Software verfügt auch über einige Konfigurationsoptionen, die vom Benutzer geändert werden können und die sich alle in der Datei air_quality.py befinden. Insbesondere ist es möglich:

a. die Standardwerte des CO2-Alarmschwellenwerts und seiner Hysterese zu ändern, indem die beiden Parameter co2eq_th und hysteresis, die standardmäßig auf 450 und 10 gesetzt sind, wie in Listing 3 dargestellt, geändert werden (um die Standardwerte zu ändern, müssen die Werte dieser beiden Parameter nicht im Dateisystem gespeichert werden);

b. Ändern Sie die anfängliche Wartezeit für die Sensorstabilisierung und die Abtastzeit (SENS_INIT_DELAY_S and SAMPLING_TIME_S), die standardmäßig auf 15 und 60 Sekunden eingestellt sind, wie ebenfalls in Listing 3 dargestellt (wir empfehlen jedoch, diese Einstellungen nicht zu ändern).

-------------------------------
// - USER TH DEFAULT VALUES
-------------------------------
co2eq_th = 450
hysteresis = 10
-------------------------------
// - TIMING CONST
// -------------------------------
SAMPLING_TIME_S = 60
SENS_INIT_DELAY_S = 15

Zusammenfassend...

In diesem Artikel haben wir die Implementierung eines Geräts zur Überwachung der Luftqualität detailliert beschrieben. Durch Auslesen eines Luftqualitätssensors (SGP30) kann es die CO2- und TVOC-Konzentrationen auf einem Display anzeigen. Darüber hinaus kann es durch Auslesen einer Benutzerdatei, die die Toleranzschwelle für die CO2-Konzentration enthält, über eine LED ein visuelles Signal geben, um einen Luftaustausch im Raum zu betreiben. Angesichts der zahlreichen zusätzlichen Peripheriegeräte in der verwendeten Plattform ist es möglich, dieses Gerät mit IoT-Funktionen zu erweitern, z. B. mit einer Webseite, die Fernabfrage von Daten und die Alarmierung per E-Mail oder Telegramm ermöglicht.


Komponentenliste

Module

  • 1 × Heltec WiFi Kit 32
  • 1 × Sensirion SGP30

LED

  • 1 × Rot, 5 mm, hoher Wirkungsgrad
  • 1 × Grün, 5 mm, hoher Wirkungsgrad

Widerstände

  • 2 × 220 Ω, 0.25 W, 5%

Anmerkungen der Redaktion: Dieses Projekt erschien ursprünglich in Elettronica IN
elektor
 



Übersetzung: Ulrich Drees