Temperatur- und Feuchtesensor SHT21 GY-21, hochpräzise, I2C-Schnittstelle, 3-5V, 0-100%RH

Dieses Tutorial verwendet das Arduino-Uno-Board, denn das Modul GY-21 ist ein I2C-Sensor, der unbedingt einen Mikrocontroller braucht, der ihn abfragt. Das Modul trägt den Sensor SHT21 und misst die Lufttemperatur und die relative Luftfeuchtigkeit, mit einem bereits kalibrierten digitalen Ausgang. Sie können ihn in Innenraum-Wetterstationen, bei der Überwachung eines Gewächshauses, eines Lagers oder eines Raums mit Luftbefeuchter sowie in selbst gebauten Thermostaten und Hygrostaten einsetzen.

Anders als ein analoger Sensor benötigt der SHT21 keine Kalibrierung und keinen externen Analog-Digital-Wandler. Der Mikrocontroller sendet einen Befehl über zwei Leitungen und erhält den gemessenen Wert zurück, begleitet von einer Prüfsumme. In den folgenden Schritten schließen Sie das Modul an, lesen die Werte mit einer minimalen Bibliothek (nur Wire) aus und sehen, wie sich die Rohzahlen in Grad Celsius und Prozent Luftfeuchtigkeit umrechnen lassen.

So funktioniert es:

Im Inneren des SHT21 befinden sich ein kapazitives Polymer-Element für die Feuchtigkeit und ein Temperatursensor vom Bandgap-Typ. Ein integrierter Analog-Digital-Wandler wandelt beide Größen in Zahlen um, und die Auswerteschaltung wendet die werkseitige Kalibrierung an. Das Ergebnis wird über den I2C-Bus an der festen Adresse 0x40 ausgegeben, mit einer Taktfrequenz von höchstens 400 kHz.

Eine Messung besteht aus vier Schritten. Der Mikrocontroller sendet die Adresse 0x40 und einen Befehl: 0xF3 startet die Temperaturmessung und 0xF5 startet die Feuchtigkeitsmessung, beide im Modus ohne Clock-Halt (no hold master). Danach wartet er die Dauer der Wandlung ab, höchstens 85 ms für die Temperatur mit 14 Bit und höchstens 29 ms für die Feuchtigkeit mit 12 Bit. Anschließend liest er drei Bytes: zwei Datenbytes und ein CRC-Byte. Zum Schluss berechnet er den echten Wert aus der Rohzahl.

Die letzten beiden Bits des zweiten Bytes sind Statusbits und müssen vor der Berechnung auf null gesetzt werden. Mit der Rohzahl S lauten die Formeln: Temperatur in °C = -46.85 + 175.72 x S / 65536 und relative Feuchtigkeit in %RH = -6 + 125 x S / 65536. Die Zahl 65536 ist 2 hoch 16, also die Anzahl der Werte, die ein 16-Bit-Wort annehmen kann. Beispiel: Für S = 26000 ergibt sich bei der Temperatur -46.85 + 175.72 x 26000 / 65536 = 22.86 °C, und für S = 31000 ergibt sich bei der Feuchtigkeit -6 + 125 x 31000 / 65536 = 53.13 %RH.

Die CRC-8-Prüfsumme verwendet das Polynom x hoch 8 + x hoch 5 + x hoch 4 + 1 (im Code die Konstante 0x31) und beginnt mit dem Wert 0. Weicht die berechnete CRC vom empfangenen Wert ab, wurde die Übertragung durch Rauschen gestört, und der Messwert muss verworfen werden.

Anschluss:

Der Chip SHT21 arbeitet mit 2.1 - 3.6 V, aber das Modul GY-21 besitzt auf der Platine einen Spannungsregler für 3.3 V (Aufdruck 662K) sowie Pegelwandler mit Transistoren auf den I2C-Leitungen. Deshalb speisen Sie das Modul direkt vom 5V-Pin des Arduino Uno, und die Leitungen SDA und SCL werden direkt verbunden, ohne externen Logikpegelwandler. Das Modul hat außerdem eigene Pull-up-Widerstände, daher benötigen Sie bei einem einzelnen Modul keine externen Widerstände. Löten Sie zuerst die mitgelieferte 4-polige Steckerleiste auf die Platine des Moduls. Die Pins des Moduls sind der Reihe nach VIN, GND, SCL und SDA.

Auf dem Arduino Uno sind die Pins A4 und A5 dieselben Leitungen wie die Pins SDA und SCL auf der rechten Seite der oberen Leiste, Sie können also einen beliebigen davon verwenden. Die Platine wird über das USB-Kabel vom Computer mit Strom versorgt. Bei manchen Varianten des Moduls ist der Versorgungspin mit VCC statt VIN beschriftet, die Funktion ist dieselbe. Prüfen Sie die Beschriftung auf der Platine vor dem Löten und vor dem Anschließen.

Board und Bibliotheken:

Wählen Sie in der Arduino IDE unter Werkzeuge > Board das Board Arduino Uno aus dem Paket Arduino AVR Boards, das zusammen mit der Arduino IDE installiert wird. Falls es nicht in der Liste erscheint, installieren Sie es über Werkzeuge > Board > Boards Manager, indem Sie nach Arduino AVR Boards suchen. Unter Werkzeuge > Port wählen Sie den seriellen Port der Platine aus.

Das Programm verwendet nur die Bibliothek Wire, die mit der Arduino IDE mitgeliefert wird, daher müssen Sie keine Bibliothek installieren. Die Kommunikation mit dem Sensor ist direkt programmiert, sodass Sie jeden Schritt des Protokolls nachvollziehen können.

Der Code:

Das folgende Programm liest alle 2 Sekunden die Temperatur und die Feuchtigkeit, prüft die Prüfsumme und gibt das Ergebnis auf dem seriellen Monitor aus.

/*
  SHT21 / GY-21 temperature and humidity example
  Board (Arduino IDE, Tools > Board): Arduino Uno
  Board package: Arduino AVR Boards (comes with the Arduino IDE)
  Libraries: none to install, only the built-in Wire library is used.
  Wiring (the GY-21 module has its own 3.3 V regulator, level shifters
  and pull-up resistors on the I2C lines):
    Module VIN -> Arduino 5V
    Module GND -> Arduino GND
    Module SDA -> Arduino A4
    Module SCL -> Arduino A5
*/
#include <Wire.h>
// I2C address of the sensor
const uint8_t SHT21_ADDRESS = 0x40;
// Sensor commands
const uint8_t CMD_TRIGGER_TEMP_NO_HOLD = 0xF3; // start temperature measurement
const uint8_t CMD_TRIGGER_HUM_NO_HOLD  = 0xF5; // start humidity measurement
const uint8_t CMD_SOFT_RESET           = 0xFE; // reset the sensor
// Waiting times in milliseconds, slightly above the maximum conversion time
const uint16_t TEMP_WAIT_MS = 100; // 14 bit temperature
const uint16_t HUM_WAIT_MS  = 40;  // 12 bit humidity
// CRC-8 with polynomial 0x31, start value 0
uint8_t crc8(const uint8_t *data, uint8_t length) {
  uint8_t crc = 0;
  for (uint8_t i = 0; i < length; i++) {
    crc ^= data[i];
    for (uint8_t bit = 0; bit < 8; bit++) {
      if (crc & 0x80) {
        crc = (crc << 1) ^ 0x31;
      } else {
        crc = crc << 1;
      }
    }
  }
  return crc;
}
// Send a measurement command, wait, read 3 bytes and check the CRC
bool readRaw(uint8_t command, uint16_t waitMs, uint16_t &raw) {
  Wire.beginTransmission(SHT21_ADDRESS);
  Wire.write(command);
  if (Wire.endTransmission() != 0) {
    return false; // sensor did not acknowledge
  }
  delay(waitMs); // wait for the conversion to finish
  if (Wire.requestFrom(SHT21_ADDRESS, (uint8_t)3) != 3) {
    return false; // fewer than 3 bytes received
  }
  uint8_t data[3];
  for (uint8_t i = 0; i < 3; i++) {
    data[i] = Wire.read();
  }
  if (crc8(data, 2) != data[2]) {
    return false; // checksum error
  }
  raw = ((uint16_t)data[0] << 8) | data[1];
  raw &= 0xFFFC; // clear the two status bits
  return true;
}
void setup() {
  Serial.begin(9600);
  Wire.begin();
  Serial.println("SHT21 / GY-21 test started");
  // Check that the sensor answers at its address
  Wire.beginTransmission(SHT21_ADDRESS);
  if (Wire.endTransmission() != 0) {
    Serial.println("Sensor not found at address 0x40, check wiring");
    while (true) {
      delay(1000); // stop here
    }
  }
  Serial.println("Sensor found at address 0x40");
  // Soft reset, the sensor needs up to 15 ms to restart
  Wire.beginTransmission(SHT21_ADDRESS);
  Wire.write(CMD_SOFT_RESET);
  Wire.endTransmission();
  delay(20);
}
void loop() {
  uint16_t rawTemperature = 0;
  uint16_t rawHumidity = 0;
  if (readRaw(CMD_TRIGGER_TEMP_NO_HOLD, TEMP_WAIT_MS, rawTemperature) &&
      readRaw(CMD_TRIGGER_HUM_NO_HOLD, HUM_WAIT_MS, rawHumidity)) {
    // Convert raw values to physical values
    float temperatureC = -46.85 + 175.72 * (float)rawTemperature / 65536.0;
    float humidityRH = -6.0 + 125.0 * (float)rawHumidity / 65536.0;
    // Limit humidity to the physical range
    if (humidityRH < 0.0) humidityRH = 0.0;
    if (humidityRH > 100.0) humidityRH = 100.0;
    Serial.print("Temperature: ");
    Serial.print(temperatureC, 2);
    Serial.print(" C, Humidity: ");
    Serial.print(humidityRH, 1);
    Serial.println(" %RH");
  } else {
    Serial.println("Read error (no answer or CRC mismatch)");
  }
  delay(2000); // one reading every 2 seconds
}

So funktioniert der Code:

Am Anfang werden die Adresse des Sensors (SHT21_ADDRESS, 0x40), die Messbefehle (CMD_TRIGGER_TEMP_NO_HOLD und CMD_TRIGGER_HUM_NO_HOLD) und der Resetbefehl (CMD_SOFT_RESET) definiert. Die Konstanten TEMP_WAIT_MS und HUM_WAIT_MS legen fest, wie lange das Programm nach dem Befehl wartet, etwas über den maximalen Wandlungszeiten des Sensors.

Die Funktion crc8 berechnet die Prüfsumme mit dem Polynom 0x31, beginnend mit dem Wert 0, über die beiden empfangenen Datenbytes. Die Funktion readRaw sendet den Befehl, wartet auf die Wandlung, fordert drei Bytes mit Wire.requestFrom an, vergleicht die berechnete CRC mit der empfangenen und bildet, wenn alles stimmt, die Rohzahl aus den beiden Datenbytes, wobei die beiden Statusbits mit der Maske 0xFFFC ausgeblendet werden. Die Funktion gibt false zurück, wenn der Sensor nicht antwortet, wenn weniger als 3 Bytes ankommen oder wenn die Prüfsumme nicht übereinstimmt.

Im setup wird der serielle Port mit 9600 Baud und der I2C-Bus mit Wire.begin gestartet. Danach prüft das Programm, ob der Sensor an der Adresse 0x40 antwortet, und falls nicht, stoppt es mit einer Meldung, die auf die Überprüfung der Verbindungen hinweist. Bei Erfolg sendet es den softwareseitigen Resetbefehl und wartet 20 ms, die der Sensor für den Neustart benötigt.

Im loop werden nacheinander die Temperatur (rawTemperature) und die Feuchtigkeit (rawHumidity) angefordert. Die Rohwerte werden mit den Formeln aus dem Abschnitt zur Funktionsweise in temperatureC und humidityRH umgerechnet, und die Feuchtigkeit wird auf den Bereich 0 - 100 %RH begrenzt. Das Ergebnis wird auf dem seriellen Monitor ausgegeben, bei einer fehlerhaften Messung erscheint eine Fehlermeldung. Die Pause von 2 Sekunden zwischen den Messungen erfolgt mit delay(2000).

Ergebnis:

Öffnen Sie den seriellen Monitor der Arduino IDE (Werkzeuge > Serieller Monitor) und stellen Sie die Geschwindigkeit auf 9600 Baud ein. Alle 2 Sekunden erscheint eine Zeile mit der gemessenen Temperatur und Feuchtigkeit, wie im folgenden Beispiel.

SHT21 / GY-21 test started
Sensor found at address 0x40
Temperature: 23.41 C, Humidity: 48.7 %RH
Temperature: 23.43 C, Humidity: 48.6 %RH
Temperature: 23.44 C, Humidity: 48.8 %RH
Temperature: 23.46 C, Humidity: 51.9 %RH
Temperature: 23.52 C, Humidity: 56.3 %RH
Temperature: 23.49 C, Humidity: 53.1 %RH
Temperature: 23.45 C, Humidity: 49.5 %RH

Häufige Probleme:

Es erscheint die Meldung, dass der Sensor an der Adresse 0x40 nicht gefunden wurde. Die häufigste Ursache ist eine falsche Verbindung oder eine fehlende gemeinsame Masse. Prüfen Sie, ob SDA an A4 und SCL an A5 liegt, ob sie nicht vertauscht sind, ob GND angeschlossen ist und ob die Pins der Steckerleiste auf der Platine des Moduls richtig verlötet sind.

Es erscheint die Meldung über einen Lesefehler (keine Antwort oder falsche CRC). Die Ursache sind meist Störungen auf langen Leitungen oder schlechte Kontakte. Kürzen Sie die Leitungen SDA und SCL, halten Sie sie von Stromkabeln oder Motoren fern und prüfen Sie die Lötstellen.

Die angezeigte Temperatur ist höher als die tatsächliche. Der Sensor nimmt Wärme von benachbarten Bauteilen auf, zum Beispiel vom Spannungsregler des Arduino-Boards. Montieren Sie das Modul in einem Abstand, am besten mit längeren Leitungen, und lassen Sie es einige Minuten zur Stabilisierung laufen.

Die Feuchtigkeit bleibt bei 100 %RH oder steigt plötzlich an. Der Sensor war Kondensat oder Wasser ausgesetzt. Lassen Sie ihn an einem gut belüfteten Ort trocknen, und schützen Sie ihn bei der Montage vor Spritzwasser und vor direktem Kontakt mit Flüssigkeiten.

Auf dem seriellen Monitor erscheint nichts. Prüfen Sie, ob Sie unter Werkzeuge > Port den richtigen Port gewählt haben, ob als Board Arduino Uno eingestellt ist und ob die Geschwindigkeit des seriellen Monitors 9600 Baud beträgt.

Einschränkungen und Tipps:

Die typische Genauigkeit beträgt ±2 %RH für die Feuchtigkeit und ±0.3 °C für die Temperatur, im Bereich von 0 - 100 %RH bzw. -40 - 125 °C. Der Sensor ist nicht für Messungen in Flüssigkeiten oder bei Kondensat vorgesehen und reagiert nicht augenblicklich, da sich die Feuchtigkeit innerhalb weniger Sekunden stabilisiert. Die Adresse 0x40 ist fest, daher kann auf demselben I2C-Bus nur ein solches Modul betrieben werden.

Eine Messung alle 2 Sekunden reicht für die meisten Umgebungsanwendungen aus. Als Nächstes können Sie die Werte auf einem OLED- oder LCD-Display anzeigen, auf einer SD-Karte protokollieren oder je nach gewünschten Schwellenwerten ein Relais für einen Luftbefeuchter oder eine Lüftung steuern, mit einer Hysterese von einigen Prozent, um häufiges Schalten zu vermeiden.