SHT21 GY-21 hőmérséklet- és páratartalom-érzékelő modul, pontos, I2C interfész, 3-5V, 0-100%RH

Ez a bemutató Arduino Uno kártyát használ, mert a GY-21 modul I2C szenzor, amelyhez feltétlenül szükség van egy mikrokontrollerre, amely lekérdezi. A modul az SHT21 szenzort tartalmazza, amely a levegő hőmérsékletét és relatív páratartalmát méri, gyárilag kalibrált digitális kimenettel. Beltéri meteorológiai állomásokban, üvegház, raktár vagy párásítóval ellátott helyiség felügyeletében, valamint saját építésű termosztátokban és higrosztátokban fogjátok használni.

Az analóg szenzorokkal ellentétben az SHT21 nem igényel kalibrálást, és nincs szüksége külső analóg-digitális átalakítóra. A mikrokontroller két vezetéken küld egy parancsot, és visszakapja a mért értéket, amelyet egy ellenőrző összeg kísér. Az alábbi lépésekben csatlakoztatjátok a modult, olvassátok ki az értékeket egy minimális könyvtárral (csak Wire), és megnézhetitek, hogyan alakulnak át a nyers számok Celsius-fokokká és páratartalom-százalékokká.

Hogyan működik:

Az SHT21 belsejében egy polimer kapacitív elem található a páratartalom méréséhez, valamint egy bandgap típusú hőmérséklet-érzékelő. Egy integrált analóg-digitális átalakító mindkét mennyiséget számokká alakítja, a feldolgozó áramkör pedig alkalmazza a gyári kalibrálást. Az eredmény az I2C buszon jelenik meg, a rögzített 0x40 címen, legfeljebb 400 kHz órajel-frekvencián.

Egy mérés négy lépésből áll. A mikrokontroller elküldi a 0x40 címet és egy parancsot: a 0xF3 a hőmérséklet-mérést, a 0xF5 a páratartalom-mérést indítja, mindkettő zárolás nélküli órajel-módban (no hold master). Ezután megvárja az átalakítás idejét, ami legfeljebb 85 ms a 14 bites hőmérsékletnél és legfeljebb 29 ms a 12 bites páratartalomnál. Ezt követően három bájtot olvas be: két adatbájtot és egy CRC bájtot. Végül a nyers számból kiszámítja a valós értéket.

A második bájt utolsó két bitje állapotbit, ezeket a számítás előtt nullázni kell. A nyers S értékkel a képletek a következők: hőmérséklet °C-ban = -46.85 + 175.72 x S / 65536, relatív páratartalom %RH-ban = -6 + 125 x S / 65536. A 65536 a 2 a 16. hatványon, vagyis annyi értéket, amennyit egy 16 bites szó felvehet. Példa: S = 26000 esetén a hőmérséklet -46.85 + 175.72 x 26000 / 65536 = 22.86 °C, S = 31000 esetén a páratartalom pedig -6 + 125 x 31000 / 65536 = 53.13 %RH.

A CRC-8 ellenőrző összeg az x a 8. hatványon + x az 5. hatványon + x a 4. hatványon + 1 polinomot használja (kódban a 0x31 konstans), és a 0 értékből indul. Ha a kiszámított CRC eltér a kapottól, az olvasást zaj érte, ezért figyelmen kívül kell hagyni.

Csatlakoztatás:

Az SHT21 chip 2.1 - 3.6 V feszültségen működik, de a GY-21 modulon van egy 3.3 V-os stabilizátor (662K jelöléssel) és tranzisztoros szintillesztők az I2C vonalakon. Ezért a modult közvetlenül az Arduino Uno 5V tápcsatlakozójáról táplálják, az SDA és SCL vonalakat pedig közvetlenül kötik be, külső logikai szintillesztő nélkül. A modulnak saját felhúzó ellenállásai is vannak, ezért egyetlen modul esetén nincs szükség külső ellenállásokra. Először forrasszátok be a mellékelt 4 tűs csatlakozót a modul kártyájára. A modul tűi sorrendben: VIN, GND, SCL és SDA.

Az Arduino Unón az A4 és A5 tűk ugyanazok a vonalak, mint a felső csatlakozósor jobb oldalán lévő SDA és SCL tűk, ezért bármelyiket használhatjátok. A kártya a számítógéphez csatlakoztatott USB-kábelen keresztül kap tápellátást. A modul egyes változatain a tápcsatlakozó VCC feliratú a VIN helyett, a szerepe ugyanaz. Forrasztás és csatlakoztatás előtt ellenőrizzétek a kártyán lévő feliratot.

Kártya és könyvtárak:

Az Arduino IDE-ben a Tools > Board menüben válasszátok ki az Arduino Uno kártyát az Arduino AVR Boards csomagból, amely az Arduino IDE-vel együtt települ. Ha nem szerepel a listában, telepítsétek a Tools > Board > Boards Manager menüből, az Arduino AVR Boards keresésével. A Tools > Port menüben válasszátok ki a kártya soros portját.

A program csak a Wire könyvtárat használja, amely az Arduino IDE-vel együtt érkezik, ezért semmilyen könyvtárat nem kell telepíteni. A szenzorral való kommunikációt közvetlenül írjuk meg, így az protokoll minden lépését láthatjátok.

A kód:

Az alábbi program 2 másodpercenként olvassa ki a hőmérsékletet és a páratartalmat, ellenőrzi az ellenőrző összeget, és az eredményt a soros monitoron jeleníti meg.

/*
  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
}

A kód működése:

A elején meghatározzuk a szenzor címét (SHT21_ADDRESS, 0x40), a mérési parancsokat (CMD_TRIGGER_TEMP_NO_HOLD és CMD_TRIGGER_HUM_NO_HOLD), valamint a szoftveres újraindító parancsot (CMD_SOFT_RESET). A TEMP_WAIT_MS és HUM_WAIT_MS konstansok határozzák meg, mennyit vár a program a parancs után, valamivel a szenzor maximális átalakítási idői felett.

A crc8 függvény a 0x31 polinommal számítja ki az ellenőrző összeget, a 0 értékből indulva, a kapott két adatbájton. A readRaw függvény elküldi a parancsot, megvárja az átalakítást, három bájtot kér a Wire.requestFrom segítségével, összehasonlítja a kiszámított CRC-t a kapottal, és ha minden rendben van, a két adatbájtból összeállítja a nyers számot, a 0xFFFC maszkkal pedig nullázza a két állapotbitet. A függvény false értéket ad vissza, ha a szenzor nem válaszol, ha 3 bájtnál kevesebb érkezik, vagy ha az ellenőrző összeg nem egyezik.

A setup függvényben a soros portot 9600 baudon indítjuk, az I2C buszt pedig a Wire.begin paranccsal. A program ezután ellenőrzi, hogy a szenzor válaszol-e a 0x40 címen, és ha nem, egy üzenettel, a kapcsolatok ellenőrzésére figyelmeztetve leáll. Sikeres esetben szoftveres újraindító parancsot küld, és vár 20 ms-ot, amennyi idő alatt a szenzor újraindul.

A loop függvényben sorban lekérjük a hőmérsékletet (rawTemperature) és a páratartalmat (rawHumidity). A nyers értékeket a működésről szóló rész képleteivel alakítjuk át temperatureC és humidityRH értékekké, a páratartalmat pedig a 0 - 100 %RH tartományra korlátozzuk. Az eredményt a soros monitoron jelenítjük meg, hibás olvasás esetén pedig hibaüzenet jelenik meg. A mérések közötti 2 másodperces szünetet a delay(2000) adja.

Eredmény:

Nyissátok meg a soros monitort az Arduino IDE-ben (Tools > Serial Monitor), és állítsátok a sebességet 9600 baudra. 2 másodpercenként megjelenik egy sor a mért hőmérséklettel és páratartalommal, ahogy az alábbi példában látható.

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

Gyakori problémák:

Az a üzenet jelenik meg, hogy a szenzor nem található a 0x40 címen. A leggyakoribb ok hibás csatlakoztatás vagy a közös föld hiánya. Ellenőrizzétek, hogy az SDA az A4-re, az SCL pedig az A5-re csatlakozik, nincsenek-e felcserélve, hogy a GND be van-e kötve, és hogy a csatlakozó tűi megfelelően vannak-e forrasztva a modul kártyáján.

Olvasási hibaüzenet jelenik meg (nincs válasz vagy hibás CRC). Az ok általában a hosszú vezetékek zaja vagy a rossz érintkezés. Rövidítsétek le az SDA és SCL vezetékeket, távolítsátok őket a tápkábelektől és a motoroktól, és ellenőrizzétek a forrasztásokat.

A kijelzett hőmérséklet magasabb a valósnál. A szenzor elnyeli a közeli kártyák hőjét, például az Arduino stabilizátorának hőjét. Szereljétek a modult távolabb, lehetőleg hosszabb vezetéken, és hagyjátok néhány percig stabilizálódni.

A páratartalom 100 %RH-n marad vagy hirtelen megnő. A szenzort páralecsapódás vagy víz érte. Hagyjátok egy jól szellőző helyen megszáradni, a beszereléskor pedig védjétek a fröccsenéstől és a folyadékkal való közvetlen érintkezéstől.

Semmi nem jelenik meg a soros monitoron. Ellenőrizzétek, hogy a megfelelő portot választottátok-e a Tools > Port menüben, hogy az Arduino Uno van-e kiválasztva kártyaként, és hogy a soros monitor sebessége 9600 baud-e.

Korlátok és tanácsok:

A tipikus pontosság ±2 %RH a páratartalomra és ±0.3 °C a hőmérsékletre, a 0 - 100 %RH és a -40 - 125 °C tartományban. A szenzort nem folyadékok mérésére vagy páralecsapódás jelenlétére tervezték, és nem reagál azonnal, mert a páratartalom néhány másodperc alatt áll be. A 0x40 cím rögzített, ezért ugyanazon az I2C buszon csak egy ilyen modul lehet.

A 2 másodperces mérési időköz a legtöbb környezeti alkalmazáshoz elegendő. A továbbiakban az értékeket megjelenítheტek egy OLED vagy LCD kijelzőn, rögzíthetitek őket SD-kártyára, vagy a kívánt küszöbértékek szerint relét vezérelhettek párásítóhoz vagy szellőztetéshez, néhány százalékos hiszterézissel, hogy elkerüljétek a gyakori kapcsolgatást.