Sensore di temperatura e umidità SHT21 GY-21, di precisione, interfaccia I2C, 3-5V, 0-100%RH

Questo tutorial utilizza la scheda Arduino Uno, perché il modulo GY-21 è un sensore I2C che necessita obbligatoriamente di un microcontrollore che lo interroghi. Il modulo integra il sensore SHT21 e misura la temperatura e l'umidità relativa dell'aria, con un'uscita digitale già calibrata. Lo utilizzerete in stazioni meteo da interno, per il monitoraggio di una serra, di un magazzino o di un locale con umidificatore, in termostati e igrostati costruiti da soli.

A differenza di un sensore analogico, l'SHT21 non richiede calibrazione e non ha bisogno di un convertitore analogico-digitale esterno. Il microcontrollore invia un comando su due fili e riceve in risposta il valore misurato, accompagnato da una somma di controllo. Nei passaggi seguenti collegherete il modulo, leggerete i valori con una libreria minima (solo Wire) e vedrete come i numeri grezzi si trasformano in gradi Celsius e percentuali di umidità.

Come funziona:

All'interno dell'SHT21 si trova un elemento capacitivo a polimero per l'umidità e un sensore di temperatura di tipo bandgap. Un convertitore analogico-digitale integrato trasforma entrambe le grandezze in numeri, mentre il circuito di elaborazione applica la calibrazione di fabbrica. Il risultato esce sul bus I2C, all'indirizzo fisso 0x40, con una frequenza di clock di al massimo 400 kHz.

Una misurazione ha quattro fasi. Il microcontrollore invia l'indirizzo 0x40 e un comando: 0xF3 avvia la misurazione della temperatura e 0xF5 avvia la misurazione dell'umidità, entrambe in modalità senza blocco del clock (no hold master). Poi attende il tempo della conversione, al massimo 85 ms per la temperatura a 14 bit e al massimo 29 ms per l'umidità a 12 bit. Successivamente legge tre byte: due byte di dati e un byte CRC. Infine calcola il valore reale a partire dal numero grezzo.

Gli ultimi due bit del secondo byte sono bit di stato e devono essere azzerati prima del calcolo. Con il numero grezzo S, le formule sono: temperatura in °C = -46.85 + 175.72 x S / 65536 e umidità relativa in %RH = -6 + 125 x S / 65536. Il numero 65536 è 2 alla potenza 16, cioè il numero di valori che può assumere una parola di 16 bit. Esempio: per S = 26000 la temperatura risulta -46.85 + 175.72 x 26000 / 65536 = 22.86 °C, mentre per S = 31000 l'umidità risulta -6 + 125 x 31000 / 65536 = 53.13 %RH.

La somma di controllo CRC-8 usa il polinomio x all'8 + x al 5 + x al 4 + 1 (nel codice, la costante 0x31) e parte dal valore 0. Se il CRC calcolato differisce da quello ricevuto, la lettura è stata alterata dal rumore e deve essere ignorata.

Collegamento:

Il chip SHT21 funziona a 2.1 - 3.6 V, ma il modulo GY-21 ha sulla scheda uno stabilizzatore a 3.3 V (marcato 662K) e adattatori di livello con transistor sulle linee I2C. Per questo lo alimentate direttamente dal pin 5V della scheda Arduino Uno, mentre le linee SDA e SCL si collegano direttamente, senza convertitore esterno di livello logico. Il modulo ha anche resistenze di pull-up proprie, quindi per un singolo modulo non servono resistenze esterne. Saldate prima il connettore a 4 pin incluso sulla scheda del modulo. I pin del modulo sono, in ordine, VIN, GND, SCL e SDA.

Sulla Arduino Uno, i pin A4 e A5 sono le stesse linee dei pin SDA e SCL dell'intestazione superiore di destra, quindi potete usarne uno qualsiasi dei due. La scheda si alimenta tramite il cavo USB dal computer. Su alcune versioni del modulo il pin di alimentazione è marcato VCC invece di VIN, ma il ruolo è lo stesso. Verificate la serigrafia sulla scheda prima di saldare e collegare.

Scheda e librerie:

In Arduino IDE selezionate in Strumenti > Scheda la scheda Arduino Uno, dal pacchetto Arduino AVR Boards, che è installato insieme ad Arduino IDE. Se non compare nell'elenco, installatelo da Strumenti > Scheda > Gestore schede, cercando Arduino AVR Boards. In Strumenti > Porta scegliete la porta seriale della scheda.

Il programma usa solo la libreria Wire, che è inclusa in Arduino IDE, quindi non va installata nessuna libreria. La comunicazione con il sensore è scritta direttamente, il che permette di vedere ogni passaggio del protocollo.

Codice:

Il programma seguente legge temperatura e umidità ogni 2 secondi, verifica la somma di controllo e visualizza il risultato sul monitor seriale.

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

Come funziona il codice:

All'inizio sono definiti l'indirizzo del sensore (SHT21_ADDRESS, 0x40), i comandi di misurazione (CMD_TRIGGER_TEMP_NO_HOLD e CMD_TRIGGER_HUM_NO_HOLD) e il comando di reset (CMD_SOFT_RESET). Le costanti TEMP_WAIT_MS e HUM_WAIT_MS stabiliscono quanto attende il programma dopo il comando, poco oltre i tempi massimi di conversione del sensore.

La funzione crc8 calcola la somma di controllo con il polinomio 0x31, partendo dal valore 0, sui due byte di dati ricevuti. La funzione readRaw invia il comando, attende la conversione, richiede tre byte con Wire.requestFrom, confronta il CRC calcolato con quello ricevuto e, se tutto è corretto, forma il numero grezzo dai due byte di dati e azzera con la maschera 0xFFFC i due bit di stato. La funzione restituisce false se il sensore non risponde, se arrivano meno di 3 byte o se la somma di controllo non corrisponde.

In setup si avvia la porta seriale a 9600 baud e il bus I2C con Wire.begin. Il programma verifica poi se il sensore risponde all'indirizzo 0x40 e, in caso contrario, si ferma con un messaggio che invita a controllare i collegamenti. In caso di successo, invia il comando di reset software e attende 20 ms, il tempo necessario al sensore per riavviarsi.

In loop vengono richieste in sequenza la temperatura (rawTemperature) e l'umidità (rawHumidity). I valori grezzi sono convertiti in temperatureC e humidityRH con le formule della sezione sul funzionamento, e l'umidità è limitata all'intervallo 0 - 100 %RH. Il risultato viene visualizzato sul monitor seriale e, in caso di lettura errata, compare un messaggio di errore. La pausa di 2 secondi tra le misurazioni è ottenuta con delay(2000).

Risultato:

Aprite il monitor seriale di Arduino IDE (Strumenti > Monitor seriale) e impostate la velocità a 9600 baud. Ogni 2 secondi compare una riga con la temperatura e l'umidità misurate, come nell'esempio seguente.

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

Problemi frequenti:

Compare il messaggio che il sensore non è stato trovato all'indirizzo 0x40. La causa più frequente è un collegamento sbagliato oppure la mancanza della massa comune. Verificate che SDA vada ad A4 e SCL ad A5, che non siano invertiti, che GND sia collegato e che i pin del connettore siano saldati correttamente sulla scheda del modulo.

Compare il messaggio di errore di lettura (nessuna risposta o CRC errato). La causa è di solito il rumore sui fili lunghi o contatti deboli. Accorciate i fili SDA e SCL, allontanateli dai cavi di potenza o dai motori e controllate le saldature.

La temperatura visualizzata è più alta di quella reale. Il sensore assorbe calore dalle schede vicine, ad esempio dallo stabilizzatore della scheda Arduino. Montate il modulo a distanza, preferibilmente su fili più lunghi, e lasciatelo stabilizzare per alcuni minuti.

L'umidità resta al 100 %RH oppure aumenta bruscamente. Il sensore è stato esposto a condensa o acqua. Lasciatelo asciugare in un luogo ventilato e, al montaggio, proteggetelo da spruzzi e dal contatto diretto con i liquidi.

Non compare nulla sul monitor seriale. Verificate di aver scelto la porta corretta in Strumenti > Porta, che la scheda selezionata sia Arduino Uno e che la velocità del monitor seriale sia 9600 baud.

Limiti e consigli:

La precisione tipica è di ±2 %RH per l'umidità e di ±0.3 °C per la temperatura, nei campi 0 - 100 %RH e -40 - 125 °C. Il sensore non è destinato alla misurazione nei liquidi o in presenza di condensa e non reagisce istantaneamente, perché l'umidità si stabilizza in pochi secondi. L'indirizzo 0x40 è fisso, quindi sullo stesso bus I2C può essere presente un solo modulo di questo tipo.

Una lettura ogni 2 secondi è sufficiente per la maggior parte delle applicazioni ambientali. In seguito potete visualizzare i valori su un display OLED o LCD, registrarli su una scheda SD oppure comandare un relè per un umidificatore o per una ventilazione in base alle soglie desiderate, con un'isteresi di alcuni punti percentuali per evitare commutazioni frequenti.