GY-21 / SHT21 (Temperatur- und Luftfeuchtigkeitssensor) + ESP32 Tutorial

Übersicht – GY-21 / SHT21 + ESP32

Möchtest du in dein nächstes Smarthome-Projekt starten oder einfach nur die Temperatur und Luftfeuchtigkeit präzise erfassen? Dann ist die Kombination aus dem leistungsstarken ESP32 Mikrocontroller und dem präzisen GY-21 / SHT21 Sensor perfekt für dich. Der GY-21 / SHT21 ist ein hochgenauer Temperatur- und Feuchtigkeitssensor, der über das I2C-Protokoll einfach mit dem ESP32 kommuniziert. Bevor wir mit dem Aufbau beginnen, stellen wir sicher, dass du alle notwendigen Komponenten zur Hand hast.
Was du benötigst
1x ESP32 (Mikrocontroller)
1x Temperatur- und Feuchtigkeitssensor GY-21 / SHT21
4 x Verbindungskabel (Dupont-Kabel)

Pinout – GY-21 / SHT21

Der GY-21 / SHT21 Sensor besitzt vier Anschlusspins, was die Integration in deine Projekte extrem einfach macht. Da der Sensor über das I2C-Protokoll kommuniziert, benötigst du neben der Spannungsversorgung (VIN und GND) nur zwei Datenleitungen: SCL und SDA. Diese minimalistische Pin-Belegung macht den GY-21 / SHT21 zum idealen Partner für den ESP32, da du wenig Kabelaufwand hast.

Die 4 Pins im Detail
Hier siehst du die genaue Belegung der vier Pins des Moduls:
VIN-Pin: Dies ist der Versorgungspin für die Betriebsspannung.
GND-Pin: Dieser Pin stellt den Masse-Anschluss (Ground) dar.
SCL-Pin: Der Serial Clock Pin. Er dient dem Taktsignal für die Datenübertragung des I2C-Protokolls.
SDA-Pin: Der Serial Data Pin. Über diese Leitung werden die eigentlichen Temperatur- und Feuchtigkeitsdaten gesendet und empfangen.

Hardware Aufbau / Verkabelung

Der Aufbau der Schaltung ist dank des I2C-Protokolls des GY-21 / SHT21 Sensors sehr einfach. Du benötigst lediglich vier Verbindungskabel, um den Sensor an den ESP32 anzuschließen. Beginne mit der Stromversorgung: Verbinde den 3,3V-Pin deines ESP32 mit dem VIN-Pin des GY-21 / SHT21 und den GND-Pin des ESP32 mit dem GND-Pin des Sensors. Für die I2C-Datenleitung nutzt du Pin D22 (SCL) des ESP32 und verbindest ihn mit dem SCL-Pin des Sensors, während Pin D21 (SDA) des ESP32 mit dem SDA-Pin des Sensors verbunden wird.

ESP32 3,3V → GY-21 / SHT21 VCC

ESP32 GND → GY-21 / SHT21 GND

ESP32 D22 → GY-21 / SHT21 SCL-Pin

ESP32 D21 → GY-21 / SHT21 SDA-Pin

Die korrekte und sorgfältige Verdrahtung ist von entscheidender Bedeutung, um sicherzustellen, dass dein ESP32 die Signale des GY-21 / SHT21 Sensors ordnungsgemäß erfassen kann.
Sobald du diese Verbindungen erfolgreich hergestellt hast, bist du bereit, mit der Programmierung des ESP32 fortzufahren. Im nächsten Abschnitt werden wir detailliert erklären, wie du die benötigte Bibliothek einbindest und den Code für den GY-21 / SHT21 Sensor programmierst.

Software / Code / Programmierung

Sobald der erfolgreiche Hardware-Aufbau abgeschlossen ist, wenden wir uns nun der ESP32 Programmierung zu. In diesem Abschnitt werden wir ausführlich die essentiellen Schritte zur Codeerstellung behandeln und die Schlüsselfunktionen, die du für das Auslesen des GY-21 / SHT21 Sensors verwenden wirst, im Detail erläutern.

Schritt 1: IDE Projekt
Öffne die Arduino-IDE und erstelle ein neues Projekt.
Um mit der Arduino-IDE arbeiten zu können, öffnest du zunächst die Anwendung auf deinem Computer. Falls du die Arduino-IDE noch nicht installiert oder für den ESP32 konfiguriert hast, kannst du unter folgendem Link eine Anleitung hierzu finden. Nachdem du die IDE geöffnet hast, erstellst du ein neues Projekt, indem du auf „Datei“ klickst und dann auf „Neu“. Dadurch wird ein neuer Sketch geöffnet, in dem du deinen Code eingeben kannst.

// Hier kommt dein Code
void setup(){
  // Initialisierung
}

void loop(){
  // Schleife
}

Schritt 2: Bibliothek einbinden
Um die Messdaten des GY-21 / SHT21 Sensors auszulesen, ist es notwendig, eine geeignete Bibliothek in deine Arduino-IDE einzubinden.
Gehe dazu in der Menüleiste auf „Sketch“ und wähle „Bibliothek einbinden“ aus. Klicke anschließend auf „Bibliotheken verwalten…“. Suche dort nach der Bibliothek ChipNorm_SHT21.h und installiere sie. Nur so erhältst du die erforderlichen Funktionen, damit du die Temperatur- und Feuchtigkeitsdaten erfassen und auslesen kannst.

#include <ChipNorm_SHT21.h>

Schritt 3: Initialisierung
Dieser Abschnitt befindet sich ganz oben in deinem Sketch, noch vor der void setup() Funktion. Hier definierst du zunächst, welche Pins des ESP32 für die I2C-Kommunikation mit dem GY-21 / SHT21 verwendet werden sollen. Wir definieren Pin 22 für SCL und Pin 21 für SDA, wie es in der Verdrahtung festgelegt wurde. Anschließend erzeugen wir ein Objekt (sht21) der Klasse ChipNorm_SHT21, welches es uns ermöglicht, später die Funktionen der Bibliothek aufzurufen und mit dem Sensor zu kommunizieren.

#define SCL 22 //SCL mit D22 verbinden
#define SDA 21 //SDA mit D21 verbinden

ChipNorm_SHT21 sht21(SCL, SDA); //Initialisiert die Bibliothek (Objekt sht21 der Klasse ChipNorm_SHT21 erstellt)

Schritt 4: Void Setup
Die void setup() Funktion wird, wie der Name schon sagt, nur einmal ausgeführt, wenn der ESP32 gestartet oder resettet wird. Zuerst initialisieren wir die serielle Kommunikation mit 9600 Baud, damit wir die Messwerte auf deinem Computer ausgeben können. Danach wird der GY-21 / SHT21 Sensor mithilfe von sht21.begin() initialisiert. Falls die Initialisierung fehlschlägt, geben wir eine Fehlermeldung aus und stoppen das Programm, um Probleme beim Start zu melden.

void setup() {
  Serial.begin(9600); // Serielle Kommunikation initialisieren - 9600 bits pro Sekunde
  
  // Initialisiert den SHT21-Sensor
  if (!sht21.begin()) {
    Serial.println("Fehler beim Initialisieren des SHT21-Sensors!");
    delay(1000);
    while (true); // Stoppt das Programm bei einem Fehler.
  }
  Serial.println("SHT21 Sensor initialisiert.");
}

Schritt 5: Loop Setup
Die void loop() Funktion enthält den Code, der kontinuierlich in einer Schleife ausgeführt wird. Hier rufen wir in jedem Durchlauf die Funktionen sht21.readTemperature() und sht21.readHumidity() auf, um die aktuellen Werte des GY-21 / SHT21 zu erfassen. Die gelesenen Werte werden dann auf der seriellen Schnittstelle ausgegeben. Eine kurze Fehlerprüfung sorgt dafür, dass nur gültige Werte (kein NaN) auf dem Monitor erscheinen, bevor die Schleife für 1000 Millisekunden (delay(1000)) pausiert.

void loop() {
  float temperature = sht21.readTemperature(); // Auslesen der Temperatur
  float humidity = sht21.readHumidity(); // Auslesen der Feuchtigkeit

  // Prüft auf Lesefehler (falls NAN zurückgegeben wurde).
  if (isnan(temperature) || isnan(humidity)) {
    Serial.println("Fehler beim Lesen der Sensorwerte!");
  } else {
    // Ausgabe der Messwerte
    Serial.print("Temperature: ");
    Serial.print(temperature, 1); // Ausgabe Temperautur mit einer Dezimalstelle
    Serial.println("°C");
    Serial.print("Humidity: ");
    Serial.print(humidity, 1); // Ausgabe Feuchtigkeit mit einer Dezimalstelle
    Serial.println("%");
    Serial.println("");
  }
  
  delay(1000); // Wartet 1 Sekunde
}

Gesamter Code

Nach der detaillierten Betrachtung der einzelnen Schritte siehst du hier noch einmal zur Übersicht den gesamten Programmier-Code für den ESP32 mit dem GY-21 / SHT21 Sensor aufgezeigt.

#include <ChipNorm_SHT21.h>

#define SCL 22 //SCL mit D22 verbinden
#define SDA 21 //SDA mit D21 verbinden

ChipNorm_SHT21 sht21(SCL, SDA); //Initialisiert die Bibliothek (Objekt sht21 der Klasse ChipNorm_SHT21 erstellt)

void setup() {
  Serial.begin(9600); // Serielle Kommunikation initialisieren - 9600 bits pro Sekunde
  
  // Initialisiert den SHT21-Sensor
  if (!sht21.begin()) {
    Serial.println("Fehler beim Initialisieren des SHT21-Sensors!");
    delay(1000);
    while (true); // Stoppt das Programm bei einem Fehler.
  }
  Serial.println("SHT21 Sensor initialisiert.");
}

void loop() {
  float temperature = sht21.readTemperature(); // Auslesen der Temperatur
  float humidity = sht21.readHumidity(); // Auslesen der Feuchtigkeit

  // Prüft auf Lesefehler (falls NAN zurückgegeben wurde).
  if (isnan(temperature) || isnan(humidity)) {
    Serial.println("Fehler beim Lesen der Sensorwerte!");
  } else {
    // Ausgabe der Messwerte
    Serial.print("Temperature: ");
    Serial.print(temperature, 1); // Ausgabe Temperautur mit einer Dezimalstelle
    Serial.println("°C");
    Serial.print("Humidity: ");
    Serial.print(humidity, 1); // Ausgabe Feuchtigkeit mit einer Dezimalstelle
    Serial.println("%");
    Serial.println("");
  }
  
  delay(1000); // Wartet 1 Sekunde
}

Ausführung / Anwendung

Nachdem der Code nun in die Arduino IDE eingegeben ist, muss dieser noch ausgeführt und auf deinen ESP32 Mikrocontroller übertragen werden. Nur so kannst du die Messwerte des GY-21 / SHT21 Sensors auslesen.
Den Code auf den ESP32 übertragen
Um dein Programm auf den ESP32 zu laden und die Temperatur- sowie Feuchtigkeitswerte zu sehen, gehst du wie folgt vor:
Kompilieren (Haken-Symbol): Zuerst klickst du auf das Häkchen-Symbol (Verifizieren), um den Code zu kompilieren. Dadurch prüft die IDE, ob Fehler im Code enthalten sind.
Hochladen (Pfeil-Symbol): Ist die Kompilierung erfolgreich, klickst du auf das Pfeil-Symbol (Hochladen). Der Code wird nun auf den ESP32 übertragen.
Serieller Monitor öffnen: Nach erfolgreichem Upload öffnest du den seriellen Monitor in der oberen rechten Ecke. Wichtig: Stelle sicher, dass die Baudrate auf 9600 eingestellt ist.
Werte anzeigen: Nun wird dir im seriellen Monitor kontinuierlich die aktuelle Temperatur in Grad Celsius (°C) und die relative Luftfeuchtigkeit in Prozent (%) angezeigt, welche der GY-21 / SHT21 misst.

Weitere Themen

BME280 + ESP32

OLED Display + ESP32

Vibrationsmotor + ESP32