ESP32 avec SHT41 : obtenez la température et l’humidité (Arduino)

Apprenez à interfacer le capteur de température et d’humidité SHT41 avec l’ESP32 programmé à l’aide de l’IDE Arduino. C’est l’un des capteurs présentant le meilleur rapport qualité-prix du marché. Il fait partie de la série SHT4x de 4e génération de Sensirion, un capteur de haute précision à faible consommation avec une interface I2C.

Nous allons vous montrer une introduction rapide au capteur, comment le connecter à l’ESP32 et le programmer pour obtenir les données du capteur. Ce guide est également compatible avec les capteurs SHT40 et SHT45.

Vous êtes nouveau sur l’ESP32 ? Consultez notre eBook : Apprenez l’ESP32 avec l’IDE Arduino (eBook).

Table des matières

Dans ce guide, nous aborderons les sujets suivants :

Présentation du capteur de température et d’humidité SHT41

Le SHT41 est un capteur de température et d’humidité relative de 4e génération, de haute précision et à très faible puissance, de la série SHT4x (par Sensirion).

Il a une précision de température typique de +/-0,2°C et une précision d’humidité relative de +/-1,8% RH. La fiche technique spécifie une consommation de courant moyenne de 0,4 µA. Cependant, lors de l’utilisation du capteur sur une carte de dérivation comme celle de notre cas, la consommation électrique sera plus élevée. Le capteur est calibré en usine. Voici les spécifications du capteur :

• Précision de la température : +/-0,2°C
• Précision de l’humidité : +/- 1,8 % HR
• Plage de température : -40 à 125°C
• Plage d’humidité : 0 à 100 %HR
• Tension d’alimentation : 1,08 à 3,6 V
• Interface : I2C
• Adresse I2C : 0x44
• Courant moyen : 0,4 µA (puce nue)

Le capteur est également livré avec un chauffage interne à puissance contrôlée qui peut être utilisé à trois niveaux de chauffage pour permettre le fonctionnement du capteur dans des environnements exigeants. Par exemple, cela peut aider à empêcher la condensation sur le capteur dans des conditions d’humidité élevée.

L’interface de ce capteur avec l’ESP32 ou tout autre microcontrôleur est assez simple et utilise le protocole de communication I2C.

Pour nos projets, il est plus simple d’utiliser le SHT41 sur un breakout board. Il existe différentes cartes de dérivation disponibles avec la série de capteurs SHT4x. Nous utilisons celui montré dans l’image suivante.

Dans notre cas, il est livré avec deux connecteurs compatibles STEMMA QT/Qwiic pour I2C. L’un est utilisé pour connecter la carte au microcontrôleur et l’autre peut être utilisé pour connecter des capteurs ou modules I2C supplémentaires si nécessaire pour votre projet. Il existe également la possibilité de souder des broches d’embase et de connecter des câbles de liaison « normaux » ou d’utiliser une planche à pain.

Où acheter ?

Vous pouvez consulter notre page Maker Advisor Tools pour comparer le prix du module de capteur SHT41 dans différents magasins.

Ce guide est également compatible avec :

SHT40 contre SHT41 contre SHT45

Les SHT40, SHT41 et SHT45 appartiennent tous à la même quatrième génération de capteurs de température et d’humidité relative de Sensirion. Ils fonctionnent de la même manière et le code est le même.

Ils diffèrent en termes de précision. Les SHT40 et SHT41 ont une précision typique similaire (le SHT41 maintient mieux cette précision lorsque l’humidité se rapproche des extrêmes), tandis que le SHT45 offre une précision plus élevée.

Brochage SHT4x

Les trois capteurs SHT40, SHT41 et SHT45 communiquent via le protocole I2C. Le brochage est le même pour tous.

• VIN : broches d’alimentation. La plupart des cartes de dérivation sont livrées avec un régulateur de tension. Vous pouvez donc connecter le même niveau logique de puissance que votre microcontrôleur (par exemple, 5V pour l’Arduino et 3,3V pour l’ESP32)
• 3Vo : la sortie du régulateur de tension (3,3 V). Certaines planches de discussion n’ont pas cette broche
• GND : broche GND
• SCL : broche d’horloge I2C
• SDA : broche de données I2C

Câblage du SHT4x à l’ESP32

Vous pouvez connecter le SHT41 à l’ESP32 à l’aide du connecteur si votre carte en est équipée, ou vous pouvez le connecter aux broches I2C par défaut de l’ESP32.

Pièces requises :

Les broches ESP32 I2C peuvent être différentes selon le modèle de carte ESP32. Alors, ajustez en conséquence. Lecture recommandée :

ESP32-S3

Kit de développement ESP32

Préparation de l’IDE Arduino

Avant de continuer, assurez-vous que l’IDE Arduino et les cartes ESP32 sont installés. Suivez le tutoriel suivant si ce n’est pas déjà fait :

Installation de la bibliothèque SHT4x

Il existe plusieurs bibliothèques pour s’interfacer avec le capteur SHT41. Nous utiliserons la bibliothèque Adafruit SHT4x. Il est compatible avec les capteurs SHT40, SHT41 et SHT45. Alternativement, vous pouvez également utiliser la bibliothèque fournie par Sensirion.

Dans votre IDE Arduino, ouvrez le gestionnaire de bibliothèque. Recherchez adafruit sht4x et installez la bibliothèque Adafruit SHT4x d’Adafruit (installez toutes les autres dépendances recommandées)

Code – ESP32 avec SHT41 : obtenez la température et l’humidité relative

La bibliothèque fournit un exemple simple montrant comment obtenir la température et l’humidité relative du capteur. Le code est déjà assez simple et direct, nous utilisons donc ici l’exemple original fourni par la bibliothèque (avec quelques modifications). Il est compatible avec les SHT40, SHT41 et SHT45.

Cet exemple montre comment obtenir la température et l’humidité relative, comment sélectionner différentes précisions (trois options différentes) et comment sélectionner différents paramètres pour utiliser le chauffage interne si nécessaire.

/*
  Rui Santos & Sara Santos - Raspberryme.com
  Complete project details at https://Raspberryme.com/esp32-sht41-temperature-humidity-arduino/
  Based on the example provided by the Adafruit_SHT4x Library
*/
#include "Adafruit_SHT4x.h"

Adafruit_SHT4x sht4 = Adafruit_SHT4x();

void setup() {
  Serial.begin(115200);

  Serial.println("SHT4x test");
  if (!sht4.begin()) {
    Serial.println("Couldn't find SHT4x");
    while (1) delay(1);
  }
  Serial.println("Found SHT4x sensor");
  Serial.print("Serial number 0x");
  Serial.println(sht4.readSerial(), HEX);

  // You can have 3 different precisions, higher precision takes longer
  sht4.setPrecision(SHT4X_HIGH_PRECISION);
  switch (sht4.getPrecision()) {
     case SHT4X_HIGH_PRECISION: 
       Serial.println("High precision");
       break;
     case SHT4X_MED_PRECISION: 
       Serial.println("Med precision");
       break;
     case SHT4X_LOW_PRECISION: 
       Serial.println("Low precision");
       break;
  }

  // You can have 6 different heater settings higher heat and 
  // longer times uses more power and reads will take longer too
  sht4.setHeater(SHT4X_NO_HEATER);
  switch (sht4.getHeater()) {
     case SHT4X_NO_HEATER: 
       Serial.println("No heater");
       break;
     case SHT4X_HIGH_HEATER_1S: 
       Serial.println("High heat for 1 second");
       break;
     case SHT4X_HIGH_HEATER_100MS: 
       Serial.println("High heat for 0.1 second");
       break;
     case SHT4X_MED_HEATER_1S: 
       Serial.println("Medium heat for 1 second");
       break;
     case SHT4X_MED_HEATER_100MS: 
       Serial.println("Medium heat for 0.1 second");
       break;
     case SHT4X_LOW_HEATER_1S: 
       Serial.println("Low heat for 1 second");
       break;
     case SHT4X_LOW_HEATER_100MS: 
       Serial.println("Low heat for 0.1 second");
       break;
  }
}

void loop() {
  sensors_event_t humidity, temp;
  
  uint32_t timestamp = millis();
  // Get the latest temperature and humidity readings
  sht4.getEvent(&humidity, &temp);
  timestamp = millis() - timestamp;

  Serial.print("Temperature: ");
  Serial.print(temp.temperature);
  Serial.println(" degrees C");

  Serial.print("Humidity: "); 
  Serial.print(humidity.relative_humidity);
  Serial.println("% rH");
  
  // Convert temperature to Fahrenheit
  float tempF = 1.8 * temp.temperature + 32;
  Serial.print("Temperature: ");
  Serial.print(tempF);
  Serial.println(" degrees F");

  Serial.print("Read duration (ms): ");
  Serial.println(timestamp);
  Serial.println(" ");

  delay(1000);
}

Afficher le code brut

Comment fonctionne le code ?

Commencez par inclure la bibliothèque Adafruit_SHT4x.

#include "Adafruit_SHT4x.h"

Créez un objet Adafruit_SHT4x appelé sht4 pour faire référence au capteur.

Adafruit_SHT4x sht4 = Adafruit_SHT4x();

Dans setup(), initialisez le moniteur série.

void setup() {
  Serial.begin(115200);

Les lignes suivantes initialisent le capteur.

Serial.println("SHT4x test");
if (!sht4.begin()) {
  Serial.println("Couldn't find SHT4x");
  while (1) delay(1);
}
Serial.println("Found SHT4x sensor");

Chaque capteur SHT4x est livré avec un numéro de série unique. Vous pouvez l’obtenir en utilisant la fonction readSerial() sur l’objet sht4 comme indiqué dans les lignes suivantes.

Serial.print("Serial number 0x");
Serial.println(sht4.readSerial(), HEX);

Comme nous l’avons mentionné précédemment, vous pouvez sélectionner différentes précisions pour obtenir les données du capteur. Tenez compte du fait qu’une plus grande précision prend plus de temps. Choisissez en fonction des besoins de votre projet.

Vous pouvez choisir parmi ces options :

• SHT4X_HIGH_PRECISION
• SHT4X_MED_PRECISION
• SHT4X_LOW_PRECISION

Nous sélectionnons la haute précision.

sht4.setPrecision(SHT4X_HIGH_PRECISION);

Le code montre ensuite comment définir les paramètres du chauffage. Il y a six options possibles :

• SHT4X_NO_HEATER
• SHT4X_HIGH_HEATER_1S
• SHT4X_HIGH_HEATER_100MS
• SHT4X_MED_HEATER_1S
• SHT4X_MED_HEATER_100MS
• SHT4X_LOW_HEATER_1S
• SHT4X_LOW_HEATER_100MS

Dans l’exemple, nous n’utilisons pas le radiateur.

sht4.setHeater(SHT4X_NO_HEATER);

C’est dans la boucle() que nous obtiendrons les relevés de température.

Nous devons créer des objets de type sensor_event_t dans lesquels nous enregistrerons les lectures de température et d’humidité.

sensors_event_t humidity, temp;

Le code calcule également le temps nécessaire pour obtenir les lectures. Il est enregistré dans la variable d’horodatage.

uint32_t timestamp = millis();
(...)
timestamp = millis() - timestamp;

Pour remplir les objets de température et d’humidité avec les nouvelles données du capteur, nous devons procéder comme suit :

sht4.getEvent(&humidity, &temp);

Enfin, après avoir obtenu la température et l’humidité dans les objets correspondants, nous pouvons les obtenir en appelant temp.temperature et Moisture.relative_humidity comme indiqué ci-dessous (les lectures sont imprimées dans le moniteur série) :

Serial.print("Temperature: ");
Serial.print(temp.temperature);
Serial.println(" degrees C");

Serial.print("Humidity: "); 
Serial.print(humidity.relative_humidity);
Serial.println("% rH");

Nous avons également la possibilité d’imprimer la température en Fahrenheit.

float tempF = 1.8 * temp.temperature + 32;
Serial.print("Temperature: ");
Serial.print(tempF);
Serial.println(" degrees F");

Nous imprimons également le temps nécessaire pour obtenir de nouvelles lectures. Si vous modifiez les définitions de précision et de chauffage, vous verrez que cela change.

Serial.print("Read duration (ms): ");
Serial.println(timestamp);

Démonstration

Téléchargez le code précédent sur votre carte ESP32. Assurez-vous de sélectionner la bonne carte et le bon port COM.

Après le téléchargement, ouvrez le moniteur série à une vitesse de transmission de 115 200 bauds et appuyez sur le bouton RST.

Après quelques secondes, il devrait commencer à afficher la température et l’humidité relative actuelles, ainsi que le temps nécessaire pour obtenir les lectures.

ESP32 avec SHT41 : affichage de la température et de l’humidité relative sur l’écran OLED

La bibliothèque est également livrée avec un autre exemple pour afficher les lectures du capteur sur l’écran OLED.

Pièces requises :

Vous pouvez utiliser les liens précédents ou vous rendre directement sur MakerAdvisor.com/tools pour trouver toutes les pièces pour vos projets au meilleur prix !

Schémas de câblage

L’écran OLED utilise également le protocole de communication I2C. Vous pouvez le connecter aux mêmes broches I2C.

ESP32-S3

Kit de développement ESP32

Installer les bibliothèques requises

Pour ce projet, vous devez également installer les bibliothèques suivantes si ce n’est pas déjà fait :

Vous pouvez les installer en recherchant leurs noms dans le gestionnaire de bibliothèque Arduino IDE et vous devez également installer toutes les autres dépendances suggérées.

Code – Afficher les lectures SHT41 sur l’écran OLED

Le code suivant affiche les lectures de température et d’humidité relative sur l’écran OLED. Le code a été légèrement modifié par rapport à l’exemple fourni par la bibliothèque.

/*
  Rui Santos & Sara Santos - Raspberryme.com
  Complete project details at https://Raspberryme.com/esp32-sht41-temperature-humidity-arduino/
  Based on the example provided by the Adafruit_SHT4x Library
*/
#include 
#include 
#include "Adafruit_SHT4x.h"
#include 

#define SCREEN_WIDTH 128    // OLED display width (pixels)
#define SCREEN_HEIGHT 64    // OLED display height (pixels)

// Declaration for an SSD1306 display connected to I2C (SDA, SCL pins)
#define OLED_RESET -1   // Reset pin (or -1 if sharing Arduino reset pin)
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);

// Declaration for the SHT4X connected to the default I2C pins
Adafruit_SHT4x sht4 = Adafruit_SHT4x();

void setup() {
  Serial.begin(115200);

  // Initialize OLED display
  if (!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
    Serial.println("SSD1306 allocation failed");
    for (;;);
  }

  // Clear the display
  display.clearDisplay();
  display.display();
  
  // Initialize SHT4x sensor
  Serial.println("Initializing SHT4x");
  if (! sht4.begin(&Wire)) {
    Serial.println("Couldn't find SHT4x");
    while (1) delay(1);
  }
  Serial.println("Found SHT4x sensor");
  Serial.print("Serial number 0x");
  Serial.println(sht4.readSerial(), HEX);

  sht4.setPrecision(SHT4X_HIGH_PRECISION);
  sht4.setHeater(SHT4X_NO_HEATER);
  
  display.setFont(&FreeSans9pt7b);
  display.setTextColor(SSD1306_WHITE);  
}

void loop() {
  sensors_event_t humidity, temp;
  
  uint32_t timestamp = millis();
  // Get the latest temperature and humidity readings
  sht4.getEvent(&humidity, &temp);
  // Calculate the time it takes to get a new reading
  timestamp = millis() - timestamp;

  Serial.print("Temperature: "); 
  Serial.print(temp.temperature); 
  Serial.println(" degrees C");

  Serial.print("Humidity: "); 
  Serial.print(humidity.relative_humidity); 
  Serial.println("% rH");

  // Convert temperature to Fahrenheit
  float tempF = 1.8 * temp.temperature + 32;
  Serial.print("Temperature: ");
  Serial.print(tempF);
  Serial.println(" degrees F");

  Serial.print("Read duration (ms): ");
  Serial.println(timestamp);

  display.clearDisplay();
  display.setCursor(0, 20);
  display.println("SHT41 Sensor");
  display.setCursor(0, 40);

  display.print("Temp: "); 
  display.print(temp.temperature,1); 
  display.println(" C");

  // Display temperature in Fahrenheit
  //display.print("Temp: "); 
  //display.print(tempF,1);
  //display.println(" F");

  display.print("Hum: "); 
  display.print(humidity.relative_humidity,1); 
  display.println(" %");
  display.display();
  yield();
  delay(100);
}

Afficher le code brut

Si vous avez déjà travaillé avec un écran OLED SSD1306, le code est assez facile à comprendre. Pour en savoir plus sur l’utilisation et la programmation d’un écran OLED avec l’ESP32, consultez notre guide :

Démonstration

Après avoir téléchargé le code, l’OLED affichera la température et l’humidité relative actuelles, comme indiqué dans l’image ci-dessous.

Conclusion

Dans ce guide, vous avez appris à utiliser le capteur de température et d’humidité relative SHT41 avec l’ESP32 programmé avec l’IDE Arduino. Ce tutoriel est également compatible avec SHT40 et SHT45. Le câblage et le code sont exactement les mêmes.

Le SHT41 est l’un des meilleurs capteurs en termes de rapport qualité-prix, c’est donc un excellent choix pour vos projets IoT et de domotique amateurs.

Nous proposons des didacticiels pour d’autres capteurs de température/humidité populaires :

Nous espérons que vous avez trouvé ce guide utile. Quels autres guides/tutoriels aimeriez-vous voir sur les capteurs SHT4x ? Faites-le-nous savoir dans la section commentaires.

Si vous souhaitez en savoir plus sur l’ESP32, consultez nos ressources :

Cette vidéo vous emmène dans l’histoire de Raspberry Pi :