Thermomètre Arduino : exemple de projet utilisant un capteur DHT22 + afficheur OLED i2c + Arduino Nano

Fabriquer thermomètre arduino avec affichage température et hygrométrie sur écran OLED, avec mesures faites pas capteur DHT22 monté sur PCB

Aujourd’hui, je vous propose de réaliser un petit thermomètre d’intérieur, piloté par arduino, et mettant en œuvre un capteur de température et d’hygrométrie DHT22, ainsi qu’un écran OLED i2c bicolore. Ainsi, vous pourrez découvrir une application simple, ludique, et concrète de ce capteur DHT et de cet afficheur, à travers un projet pratique et didactique, à portée de tout bon débutant en électronique !

Bien évidemment, il ne s’agit pas ici de réinventer la roue, ni même d’essayer de concevoir un thermomètre arduino qui puisse être moins cher que ceux que l’on trouve dans le commerce, ou sur internet ! Mais il s’agit plutôt d’apprendre à réaliser soi-même un objet concret, utile, et abouti (avec son « beau » boitier de finition, si je puis dire, imprimé en 3D !), et de voir étape par étape toute la partie conception électronique et mise en boitier.

Ce contenu vous plaît ? Alors abonnez-vous à la Newsletter pour ne rien louper !

Comme vous l’aurez compris, cet article se veut simple et didactique avant tout, afin que tous ceux qui débutent en électronique puissent découvrir, apprendre, et s’inspirer d’un tel montage. Mais cela étant dit, cela n’enlève rien au caractère utile de ce thermomètre arduino, qui pour ma part, a pris place dans le salon 😉

Intro : le projet dans son ensemble !

Pour faire court, on pourrait dire que ce projet est un simple thermomètre / hygromètre arduino, prenant la forme d’un cube avec des ouïes ! Mais pour être plus précis, voici ce qu’il permettra de faire :

  • L’affichage de la température ambiante (précision d’environ ± 0,5 °C)
  • Et l’affichage du taux d’humidité ambiant (précision d’environ ± 2 %)

Ce projet, à but essentiellement didactique, montre comment mettre en œuvre :

  • Un écran OLED 0,96″ i2c pour l’affichage des mesures (monochrome à deux parties colorées : jaune en haut, et bleu en milieu/bas)
  • Un capteur DHT22 pour effectuer ces mesures de température et hygrométrie
  • Et un Arduino Nano, pour gérer le tout !

Au niveau fonctionnement, c’est comme qui dirait du « plug-and-play » ! C’est-à-dire que vous branchez l’alimentation, … et tout fonctionne ! Il n’y a donc aucun paramétrage à faire, ni bouton à appuyer. En bref, c’est un produit autonome 😉

Au niveau des branchements extérieurs, il n’y en a qu’un seul : l’alimentation, qui sera fournie par un bloc secteur (7,5 volts, 1 ampère). Le branchement se fera d’ailleurs en toute simplicité, via un connecteur DC Ø5,5 mm extérieur, et Ø2,1 mm intérieur.

Enfin, toute la partie électronique prendra place dans un « élégant » boîtier imprimé en 3D, afin d’avoir un objet fini, et convivial. Vous retrouverez d’ailleurs en bas d’article tous les schémas et autres supports servant à la réalisation de ce projet, aussi bien pour la partie électronique, que la fabrication du boitier en lui même.

Schéma fonctionnel de ce « thermomètre arduino »

Avant de vous montrer le schéma électronique, voici un petit schéma fonctionnel, représentant les blocs fonctionnels de ce thermomètre arduino, et les traitements qui vont être faits en interne :

Schéma fonctionnel thermomètre hygromètre arduino avec capteur DHT22 et afficheur OLED, communiquant sur Arduino Nano, via alim externe

Comme vous le voyez, on trouve principalement 3 blocs principaux, au sein de ce projet, à savoir :

  • 1 capteur DHT22 : qui va mesurer, à la demande, la température et le taux d’humidité de l’air ambiant
  • 1 arduino nano : qui va interroger ce capteur à intervalles réguliers, et envoyer des informations à l’écran, après mise en forme « graphique »
  • Et 1 afficheur OLED : qui va simplement afficher les données, textes, et autres éléments graphiques, que l’Arduino Nano lui aura demandé d’afficher

À noter qu’il y a un 4ème bloc sur ce schéma fonctionnel, qui est seulement là pour mettre en évidence que ce projet nécessitera l’usage d’une alimentation externe, pour alimenter l’ensemble des sous-systèmes.

Comme vous pouvez le constater, ce projet est vraiment simple à appréhender, lorsque présenté en blocs fonctionnels. D’ailleurs, le schéma électronique qui suit l’est tout autant. Par contre, comme vous verrez plus loin, le code de programmation arduino sera quant à lui bien plus fourni ! Mais pour l’heure, voyons la partie « matérielle » 😉

Schéma électronique du projet

Au niveau schéma électronique, on retrouve nos 4 blocs fonctionnels, présentés avant, comme vous pouvez en juger par vous-même ici :

Schéma électronique thermomètre arduino dht22, avec affichage sur écran oled I2C, et traitement par Arduino Nano des données, y compris hygrométrie

Par ailleurs, vous remarquerez qu’il n’y a que très peu de composants mis en œuvre dans ce projet (ce qui est idéal pour les débutants en électronique !). En fait, tout cela est permis grâce au fait que chacun des composants utilisés ici est déjà une forme « intégrée » en soi, avec tout plein de « sous-composants » déjà intégrés à leur niveau. Du coup, au final, on obtient quelque chose d’assez simple et rudimentaire, au niveau matériel. Bien sûr, la partie logicielle sera quant à elle bien plus conséquente ! Mais pour l’instant, restons quelque peu sur ce schéma, et voyons plus en détail chacun des blocs figurant sur celui-ci !

L’alimentation

Ce projet sera alimenté via un bloc secteur, lui fournissant du 7,5 volts. Du coup, la partie alimentation de ce projet se limitera à :

  • Une diode de protection anti-retour, prévenant toute inversion de polarité. J’ai utilisé ici une diode schottky, afin de limiter la chute de tension à ses bornes, et par conséquent, le dégagement de chaleur qu’elle pourrait produire à l’intérieur du boitier (qui fausserait la mesure de température, en interne). Pour ceux que ça intéresse, voici la documentation technique de la diode utilisée dans ce montage : https://www.vishay.com/docs/88525/1n5817.pdf
  • Un condensateur de filtrage, permettant de lisser la tension d’entrée. Car le bloc secteur que j’ai utilisé est ni plus ni moins qu’une alimentation à découpage, et qui par conséquent, comporte bon nombre de parasites hautes fréquences

Si on considère le fait que l’alimentation externe fournira du 7,5 volts, et que la chute de tension aux bornes de la diode sera d’environ 0,3 volts, alors la tension qui sortira de cette alim sera d’environ 7,2 volts. Ce qui est d’ailleurs idéal pour alimenter notre arduino via sa broche Vin, qui requiert une tension allant de 7 à 12 volts pour bien fonctionner.

À noter, qu’en interne, l’Arduino convertira cette tension d’alimentation en +5V et +3,3V, grâce à ses régulateurs de tension intégrés. Et comme vous l’aurez compris, cette tension 5 volts alimentera le reste de notre montage.

Le capteur DHT22 (température / hygrométrie)

La mesure de température et taux d’humidité est confiée à un capteur DHT22. Et au niveau câblage, on peut difficilement faire plus simple ! Car ce capteur n’a au final besoin que de :

  • une alimentation (+5V / GND)
  • et d’une ligne de données digitale (ici branchée sur l’entrée/sortie A1 de notre Arduino Nano, mais les pins D2 à D12 auraient également pu convenir)

À noter que s’il n’y a besoin d’aucun composant additionnel ici, c’est parce que le DHT22 utilisé dans ce projet est un modèle « tout équipé ». C’est-à-dire qu’il intègre déjà sur son PCB :

  • Une résistance de pull-up, pour la ligne de données
  • Et un condensateur de filtrage à proximité du capteur, pour une parfaite stabilité de fonctionnement

Au passage, si vous souhaitez plus d’infos sur ces composants additionnels, ou sur le DHT22 en lui-même, je vous renvoie à ce tutorial sur le DHT22, que j’avais fait il y a peu.

L’afficheur OLED i2c

Pour ce projet, j’ai choisi de confier l’affichage des données à un écran OLED « monochrome bicolore », c’est-à-dire disposant de 2 parties d’écrans de couleurs différentes. En fait, la surface d’affichage est scindée en 2 parties :

  • 1 partie haute (16 pixels de hauteur), de couleur jaune
  • Et 1 partie médiane/basse (48 pixels de hauteur), de couleur bleue

Côté dimensions, cet afficheur OLED fera 0,96″ de diagonale, pour une résolution de 128×64 pixels affichables (largeur x hauteur).

La communication entre l’Arduino et cet écran OLED se fera via le bus I2C, c’est-à-dire via leurs broches SCL et SDA respectives. Pour en savoir plus sur cette partie, je vous renvoie tout simplement à ce tutorial sur les écrans OLED i2c (chipset SSD1306), que j’ai récemment publié, et qui présente tout cela en détail.

Remarque : il n’y a besoin d’aucun composant additionnel ici non plus, car cet afficheur OLED intègre tous les composants « secondaires » nécessaires, permettant de s’interfacer en toute simplicité avec un Arduino. Ce qui simplifie donc notre schéma électronique, pour notre plus grand bonheur 😉

Le cœur du montage : un Arduino Nano

Du reste, un Arduino Nano vient orchestrer le tout. Il aura pour rôle :

  • D’interroger le capteur DHT22, pour récolter des mesures de température et hygrométrie
  • D’envoyer des instructions d’affichage à l’afficheur OLED i2c, pour faire afficher toutes ces données de manière « sympa » et présentable, à l’écran !

Concernant le capteur de température et d’hygrométrie DHT22, j’ai branché sa ligne de données sur l’entrée/sortie A1 de l’Arduino Nano, afin que toutes les pistes soient routées du même côté, lors de la réalisation du PCB. Bien entendu, toute autre entrée/sortie digitale, D0 à D12, aurait convenu (même si au passage, je vous déconseille l’utilisation des pins D0 et D1, car cela pourrait perturber les signaux RX/TX de l’arduino).

Concernant l’afficheur OLED i2c, celui-ci sera piloté via les broches SDA et SCL, depuis l’Arduino Nano. À noter ici que comme l’écran oled sera déporté du PCB, un connecteur à 4 broches figure sur le schéma électronique à la place de l’écran, afin de formaliser le déport de celui-ci (le raccordement entre cet écran et notre circuit imprimé se fera via une nappe électrique).

Enfin, concernant l’alimentation de l’Arduino Nano en lui-même, celle-ci s’opère comme vu précédemment, c’est à dire via le +7,2V environ, fourni par l’alimentation externe sécurisée. Cette tension pénètre l’Arduino Nano via l’entrée Vin, requérant une tension de 7 à 12 volts pour bien fonctionner.

Nota : l’Arduino Nano dispose d’un régulateur de tension intégré, permettant de « créer » du +5V à partir de cette tension Vin. Et c’est cette tension +5V qui servira à alimenter les composants externes à l’arduino, à savoir le capteur DHT22, et l’écran oled i2C.

Diagramme fonctionnel (processus logiciel)

Maintenant que nous avons vu ensemble la partie matérielle (hardware), nous allons nous intéresser à la partie logicielle (software). Et comme vous verrez, cette partie sera bien plus fournie que la précédente, car il s’agit là du cœur même du projet.

Mais avant de vous présenter les lignes de codes à proprement parler, je tenais à vous présenter ce diagramme, qui résume dans les grandes lignes tout ce que fera le programme arduino. Donc, le voici !

Logigramme thermomètre hygromètre arduino, avec mesures de température et taux d'humidité par sonde DHT22, et affichage sur écran OLED i2c

En fait, en synthèse, il faut retenir ici qu’il y a essentiellement 3 choses qui se répètent à l’infini :

  • L’interrogation du capteur DHT22 par l’Arduino
  • L’affichage de la température sur l’écran OLED (avec pause de 7 secondes)
  • Et l’affichage du taux d’humidité sur l’écran OLED (avec pause de 7 secondes à nouveau, avant rebouclage)

Tout le reste n’étant là que pour sécuriser ou agrémenter le tout, à l’image de la remontée d’information à l’écran en cas d’erreur de mesure au niveau du capteur de température / hygrométrie. C’est pourquoi ce diagramme se révèle assez simple, au final, si vous regardez d’un peu plus près.

Ceci étant vu, passons à présent à la transcription de ce diagramme fonctionnel en code de programmation arduino ! Ainsi, vous verrez comment se formalise chacun des blocs ci-dessus !

Programme arduino (code)

Vous trouverez ci-après l’intégralité du code servant dans ce projet. Mais avant d’aller plus loin, il y a plusieurs choses qu’il faut que je vous précise.

Tout d’abord, ce programme est prévu pour interagir avec deux composants « majeurs » :

  • Un capteur DHT22, permettant la mesure de température et taux d’humidité dans l’air
  • Et un écran monochrome « bicolore » OLED i2c, faisant 128×64 pixels (0,96 pouces de diagonale / chipset SSD1306)

À noter ici que j’ai exceptionnellement câblé la ligne de données du DHT22 sur l’entrée/sortie A1 de l’Arduino Nano, pour des raisons pratiques, au niveau du routage PCB de ce projet. Bien sûr, toute autre E/S digitale aurait convenu, comme celles allant de D2 à D12, sur cet arduino.

Ensuite, pour égayer le tout, j’ai importé une police de caractère spéciale, pour afficher le message de bienvenue. J’ai également importé une seconde police de caractères (font), pour l’affichage des titres « TEMPERATURE » et « HYGROMETRIE », en haut de l’écran OLED. Si vous êtes intéressé par l’utilisation de polices de caractères différentes de celles proposées par défaut dans les librairies arduino, je vous renvoie vers cet article en lien.

Enfin, il faut savoir que j’ai également inséré 2 blocs de données dans le code, représentant les 2 images que j’ai utilisé pour l’occasion, à savoir :

  • Un symbole représentant un thermomètre, pour illustrer l’affichage de la température
  • Un symbole représentant une goutte d’eau, pour illustrer l’affichage du taux d’humidité

Là encore, si vous souhaitez savoir comment insérer des images directement dans le code arduino pour les faire afficher sur un écran OLED i2c, je vous renvoie à cet article en lien.

Voilà pour ce qui était des choses importantes à souligner, avant de vous présenter le code ! À présent, voyons ce dernier sans plus attendre 😉

/*
   ______               _                  _///_ _           _                   _
  /   _  \             (_)                |  ___| |         | |                 (_)
  |  [_|  |__  ___  ___ _  ___  _ __      | |__ | | ___  ___| |_ _ __ ___  _ __  _  ___  _   _  ___
  |   ___/ _ \| __|| __| |/ _ \| '_ \_____|  __|| |/ _ \/  _|  _| '__/   \| '_ \| |/   \| | | |/ _ \
  |  |  | ( ) |__ ||__ | | ( ) | | | |____| |__ | |  __/| (_| |_| | | (_) | | | | | (_) | |_| |  __/
  \__|   \__,_|___||___|_|\___/|_| [_|    \____/|_|\___|\____\__\_|  \___/|_| |_|_|\__  |\__,_|\___|
                                                                                      | |
                                                                                      \_|
  Fichier :       thermometre_hygrometre.ino
  
  Description :   Programme support au projet "Thermomètre d'intérieur Arduino"
                  (avec exemple de mise en oeuvre : capteur DHT22 + écran OLED i2c + mise en boitier impression 3D)

  Auteur :        Jérôme TOMSKI (https://passionelectronique.fr/)
  Créé le :       01.08.2021

  Librairie Adafruit SSD1306 utilisée :           https://github.com/adafruit/Adafruit_SSD1306 (importable depuis le Gestionnaire de bibliothèques de l'IDE Arduino)
  Librairie Adafruit GFX incluse (dépendance) :   https://github.com/adafruit/Adafruit-GFX-Library (nécessairement incluse, avec l'import de la librairie ci-dessus)

  Police de caractère "Tahu" :                    https://www.dafont.com/fr/tahu.font
  Police de caractère "Bebas Neue" :              https://www.dafont.com/fr/bebas-neue.font
  
  Convertisseur TTF vers GFX FONTS utilisé :      https://rop.nl/truetype2gfx/ (pour intégrer des fonts sympa dans votre programme arduino)
  Convertisseur PNG vers GFX PICTURE utilisé :    https://javl.github.io/image2cpp/ (pour intégrer des images à votre code arduino, pour les faire afficher ensuite sur l'écran OLED)

*/

#include <Adafruit_SSD1306.h>
#include "Tahu16pt7b.h"                     // Police de caractère : Tahu, en taille 16 points
#include "BebasNeue11pt7b.h"                // Police de caractère : Bebas Neue, en taille 11 points
#include <DHT.h>

// =======================================================
// Paramètrages du capteur température/hygrométrie (DHT22)
// =======================================================
#define brocheDeBranchementDHT A1   // La ligne de communication du capteur DHT est branchée sur la pin A1 de l'Arduino Nano
#define typeDeDHT DHT22             // Le type de DHT utilisé est un DHT22 (que vous pouvez changer en DHT11, DHT21, ou autre, le cas échéant)
DHT dht(brocheDeBranchementDHT, typeDeDHT);
int valeurHumidite;                         // Variable qui contiendra la valeur du taux d'humidité ambiant (en %)
int valeurTemperatureEnDegreCelsius;        // Variable qui contiendra la valeur de la température ambiante (exprimée en degrés Celsius)
boolean mesureCorrectementEffectuee;        // Variable qui indiquera si oui ou non la lecture des mesures effectuées par le DHT22 s'est bien passée ou non

// =========================================
// Paramètrages écran OLED 128x64 pixels I2C
// =========================================
#define nombreDePixelsEnLargeur 128         // Taille de l'écran OLED, en pixel, au niveau de sa largeur
#define nombreDePixelsEnHauteur 64          // Taille de l'écran OLED, en pixel, au niveau de sa hauteur
#define brocheResetOLED         -1          // Reset de l'OLED partagé avec l'Arduino (d'où la valeur à -1, et non un numéro de pin)
#define adresseI2CecranOLED     0x3C        // Adresse de "mon" écran OLED sur le bus i2c (généralement égal à 0x3C, ou 0x3D)
#define delaiAlternanceAffichageTemperaturePuisHygrometrie   7000    // Tous les 7000 ms (soit 7 secondes), on alternera l'affichage de la t°, et de l'hygrométrie

Adafruit_SSD1306 ecranOLED(nombreDePixelsEnLargeur, nombreDePixelsEnHauteur, &Wire, brocheResetOLED);   // Le "Wire" indique qu'on travaille en I2C, au niveau de l'écran OLED


// ====================================
// Spécifications des images à afficher
// ====================================
#define largeurImageAafficher   27          // Largeur des images à afficher (symbole thermomètre et symbole goutte d'eau), en pixels
#define hauteurImageAafficher   40          // Hauteur des images à afficher (symbole thermomètre et symbole goutte d'eau), en pixels

// Image "goutte-eau-pse_v2", faisant 27x40px
const unsigned char monImageGoutteEauPse [] PROGMEM = {
  0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x1a, 0x00, 0x00, 
  0x00, 0x13, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x00, 0x61, 0x80, 0x00, 0x00, 0x40, 0xc0, 0x00, 
  0x00, 0xc0, 0x60, 0x00, 0x01, 0x80, 0x20, 0x00, 0x01, 0x00, 0x30, 0x00, 0x03, 0x00, 0x10, 0x00, 
  0x06, 0x00, 0x10, 0x00, 0x04, 0x00, 0x18, 0x00, 0x0c, 0x00, 0x0c, 0x00, 0x08, 0x00, 0x04, 0x00, 
  0x18, 0x00, 0x06, 0x00, 0x30, 0x00, 0x03, 0x00, 0x20, 0x00, 0x01, 0x00, 0x20, 0x00, 0x01, 0x80, 
  0x20, 0x00, 0x00, 0x80, 0x60, 0x00, 0x00, 0x80, 0x40, 0x00, 0x00, 0x80, 0x40, 0x00, 0x00, 0x80, 
  0x40, 0x00, 0x00, 0xc0, 0x40, 0x00, 0x00, 0x40, 0x48, 0x00, 0x00, 0x40, 0x4c, 0x00, 0x00, 0x40, 
  0x44, 0x00, 0x00, 0xc0, 0x44, 0x00, 0x00, 0x80, 0x66, 0x00, 0x00, 0x80, 0x23, 0x00, 0x00, 0x80, 
  0x31, 0x80, 0x01, 0x80, 0x10, 0xc0, 0x03, 0x00, 0x18, 0x70, 0x06, 0x00, 0x0c, 0x00, 0x0c, 0x00, 
  0x06, 0x00, 0x18, 0x00, 0x03, 0xe3, 0xf0, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
// Image "thermometre-mercure-pse-27x40", faisant 27x40px
const unsigned char monImageThermometreMercure [] PROGMEM = {
  0x00, 0x00, 0x00, 0x00, 0x01, 0xfc, 0x00, 0x00, 0x03, 0x06, 0x00, 0x00, 0x06, 0x03, 0x3f, 0x00, 
  0x04, 0x01, 0x00, 0x00, 0x04, 0x01, 0x00, 0x00, 0x04, 0x01, 0x38, 0x00, 0x04, 0x01, 0x00, 0x00, 
  0x04, 0x01, 0x00, 0x00, 0x04, 0x01, 0x3f, 0x00, 0x04, 0x01, 0x00, 0x00, 0x04, 0x01, 0x00, 0x00, 
  0x04, 0x71, 0x38, 0x00, 0x04, 0xf9, 0x00, 0x00, 0x04, 0xf9, 0x00, 0x00, 0x04, 0xf9, 0x3f, 0x00, 
  0x04, 0xf9, 0x00, 0x00, 0x04, 0xf9, 0x00, 0x00, 0x04, 0xf9, 0x38, 0x00, 0x04, 0xf9, 0x00, 0x00, 
  0x04, 0xf9, 0x00, 0x00, 0x04, 0xf9, 0x3e, 0x00, 0x04, 0xf9, 0x00, 0x00, 0x04, 0xf9, 0x00, 0x00, 
  0x0c, 0xf9, 0x80, 0x00, 0x18, 0xf8, 0xc0, 0x00, 0x11, 0xfc, 0x40, 0x00, 0x33, 0xfe, 0x60, 0x00, 
  0x23, 0xfe, 0x20, 0x00, 0x67, 0xff, 0x30, 0x00, 0x47, 0xff, 0x10, 0x00, 0x67, 0xff, 0x30, 0x00, 
  0x23, 0xfe, 0x20, 0x00, 0x31, 0xfc, 0x60, 0x00, 0x10, 0xf8, 0x40, 0x00, 0x18, 0x70, 0xc0, 0x00, 
  0x0e, 0x03, 0x80, 0x00, 0x03, 0x8e, 0x00, 0x00, 0x00, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};

// ========================
// Initialisation programme
// ========================
void setup() {

  // Initialisation du DHT22;
  dht.begin();

  // Initialisation de l'écran OLED
  if(!ecranOLED.begin(SSD1306_SWITCHCAPVCC, adresseI2CecranOLED))
    while(1);                               // Arrêt du programme (boucle infinie) si échec d'initialisation de l'écran OLED
  

  // Affichage du texte de démarrage
  ecranOLED.clearDisplay();                 // Vidange du buffer de l'écran OLED
  ecranOLED.setTextSize(1);                 // Sélection de facteur 1:1 pour le facteur de grossissement du texte
  ecranOLED.setTextColor(WHITE);            // Couleur "blanche" (ou colorée, si votre afficheur monochrome est bleu, jaune, ou bleu/jaune)
  ecranOLED.setCursor(15,35);               // Positionnement du "curseur invisible" de l'écran OLED, en position x=15 (axe horizontal), et y=35 (axe vertical)

  ecranOLED.setFont(&Tahu16pt7b);           // Sélection de la police "Tahu"
  ecranOLED.println("Bonjour !");           // …et affichage du message de bienvenue

  ecranOLED.display();
  delay(3000);                              // On laisse le mot "Bonjour !" affiché 3 secondes à l'écran, avant d'attaquer la boucle principale
    
}


// ======================================
// Boucle principale (boucle perpétuelle)
// ======================================
void loop() {
  // Récupération des infos température/hygrométrie, auprès du capteur DHT22
  recupInfosTemperatureEtHygrometrie();

  // Affichage de la température (+ pause de quelques secondes)
  affichageTemperature();
  delay(delaiAlternanceAffichageTemperaturePuisHygrometrie);

  // Affichage de l'hygrométrie (+ pause de quelques secondes)
  affichageHygrometrie();
  delay(delaiAlternanceAffichageTemperaturePuisHygrometrie);

  // ... et répétition à l'infini !
}


// ========================================================
// Section : récupération des infos température/hygrométrie
// ========================================================
void recupInfosTemperatureEtHygrometrie() {
  // Lecture des données (interrogation du capteur DHT22 par l'Arduino)
  float tauxHumidite = dht.readHumidity();                                  // Lecture du taux d'humidité (en %)
  float temperatureEnDegreCelsius = dht.readTemperature();                  // Lecture de la température, exprimée en degrés Celsius

  // Vérification si données bien reçues
  if (isnan(tauxHumidite) || isnan(temperatureEnDegreCelsius)) {            // Si aucune valeur correcte n'est retournée par le capteur DHT22, on met
    mesureCorrectementEffectuee = false;                                    // à "faux" la variable "mesureCorrectementEffectuee", pour ensuite faire afficher
  }                                                                         // le sigle "--" sur l'écran OLED (indiquant qu'aucune valeur n'a pu être relevée)
  else
  {                                                                         // Sauvegarde de ces valeurs mesurées, pour affichage ultérieur
    valeurHumidite = round(tauxHumidite);                                   // Arrondi à la valeur entière la plus proche
    valeurTemperatureEnDegreCelsius = round(temperatureEnDegreCelsius)-1;   // Arrondi à la valeur entière la plus proche (auquel j'ai enlevé 1°C, pour compenser la mise en boitier)  
    mesureCorrectementEffectuee = true;                                     // … et on mémorise le fait que la mesure s'est bien passée
  }
}


// =====================================
// Section : affichage de la température
// =====================================
void affichageTemperature() {
  // Affichage du symbole "thermomètre" à l'écran
  ecranOLED.clearDisplay();                 // Effaçage de la mémoire tampon de l'écran OLED
  ecranOLED.drawBitmap(
    8,                                      // Alignement de la gauche de l'image à 8 pixels du côté gauche de l'écran
    20,                                     // Alignement du haut de l'image à 20 pixels du haut de l'écran (pour être dans la partie bleue, et non la jaune)
    monImageThermometreMercure,             // Chargement de l'image "thermomètre"
    largeurImageAafficher,
    hauteurImageAafficher,
    1);

  // Titre
  ecranOLED.setFont(&BebasNeue11pt7b);      // Sélection de la police "Bebas Neue", taille 11pt
  ecranOLED.setTextSize(1);
  ecranOLED.setTextColor(WHITE);
  ecranOLED.setCursor(15,15);               // Positionnement du texte en x=15, et y=15 pixels
  ecranOLED.print("TEMPERATURE");           // Et affichage du mot "TEMPERATURE"

  // Valeur
  ecranOLED.setFont();                      // Re-sélection de la police de caractère par défaut, de la librairie Adafruit
  ecranOLED.setTextSize(3);
  ecranOLED.setTextColor(WHITE);
  if(valeurTemperatureEnDegreCelsius<0)
    ecranOLED.setCursor(40,30);             // x, y (48,30) si valeur de t° avec 2 chiffres, et (40,30) pour valeur à 3 chiffres (ou t° négative)
  else
    ecranOLED.setCursor(48,30);
  if(mesureCorrectementEffectuee == false)
    ecranOLED.print("--");                                // Si problème de lecture au niveau du DHT22, affichage du symbole "--"
  else
    ecranOLED.print(valeurTemperatureEnDegreCelsius);     // Si aucun pb au niveau du DHT22, affichage de la valeur de température mesurée
  ecranOLED.setTextSize(2);
  ecranOLED.print((char)247);               // Appelle le symbole ressemblant au sigle degré "°", car ce dernier n'existe pas vraiment dans cette police de caractère
  ecranOLED.setTextSize(3);                 // (d'où le changement de tailles de texte (taille 3 -> taille 2 -> taille 3), pour tricher un peu !
  ecranOLED.print("C");
  
  ecranOLED.display();                      // Transfert de la mémoire tampon à l'écran, pour affichage de tout ça !
}


// ======================================
// Section : affichage du taux d'humidité
// ======================================
void affichageHygrometrie() {
  // Affichage du symbole "goutte d'eau" à l'écran
  ecranOLED.clearDisplay();                 // Effaçage de la mémoire tampon de l'écran OLED
  ecranOLED.drawBitmap(
    16,                                     // Alignement de la gauche de l'image à 8 pixels du côté gauche de l'écran
    20,                                     // Alignement du haut de l'image à 20 pixels du haut de l'écran (pour être dans la partie bleue, et non la jaune)
    monImageGoutteEauPse,                   // Chargement de l'image "goutte d'eau"
    largeurImageAafficher,
    hauteurImageAafficher,
    1);

  // Titre
  ecranOLED.setFont(&BebasNeue11pt7b);      // Sélection de la police "Bebas Neue", taille 11pt
  ecranOLED.setTextSize(1);
  ecranOLED.setTextColor(WHITE);
  ecranOLED.setCursor(18,15);               // Positionnement du texte en x=18, et y=15 pixels
  ecranOLED.print("HYGROMETRIE");           // Et affichage du mot "HYGROMETRIE"

  // Valeur
  ecranOLED.setFont();                      // Re-sélection de la police de caractère par défaut, de la librairie Adafruit
  ecranOLED.setTextSize(3);
  ecranOLED.setTextColor(WHITE);
  if(valeurHumidite==100)
    ecranOLED.setCursor(46,30);             // x, y (56,30) si valeur d'hygrométrie sur 2 chiffres, ou (46,30) si valeur sur 3 chiffres (par ex : "100" %)
  else
    ecranOLED.setCursor(56,30);
  if(mesureCorrectementEffectuee == false)
    ecranOLED.print("--");                  // Si problème de lecture au niveau du DHT22, affichage du symbole "--"
  else
    ecranOLED.print(valeurHumidite);        // Si aucun pb au niveau du DHT22, affichage de la valeur du taux d'humidité mesuré
  ecranOLED.print("%");
  
  ecranOLED.display();                      // Transfert de la mémoire tampon de l'ODED à l'écran, pour affichage
}

Nota : j’ai essayé de mettre un maximum de commentaires dans le code, afin que vous puissiez avoir une meilleure compréhension possible de chaque ligne de ce programme. Cela étant dit, n’hésitez pas également à prendre du recul, et analyser toutes ces lignes de code « bloc par bloc », et non ligne par ligne. Ainsi, la compréhension sera facilitée !

Bon… je crois que nous avons fait le tour de ce projet, aussi bien concernant la partie matérielle, que logicielle ! Maintenant, passons à la réalisation physique de ce thermomètre arduino, ainsi que de sa mise en boitier, imprimé en 3D !

Fabrication et montage en boitier

Tout d’abord, un rapide coup d’œil sur le PCB à fabriquer, vu côté composants :

Circuit imprimé thermomètre hygromètre arduino, plaquette PCB pour projet mesure de température et taux d'humidité avec Arduino, DHT22, et écran OLED
Routage des pistes cuivrées du projet thermomètre hygromètre arduino, côté soudures à l'étain, pour composants électroniques traversant, PCB couche arrière

Au passage, vous trouverez en fin d’article le fichier « Gerber » permettant de réaliser ce circuit imprimé (ou plutôt, vous permettant de le faire faire réaliser par un fabricant de PCB). À noter qu’il s’agit là d’un simple PCB monocouche à double face. Côté composant (le « dessus ») vous trouverez un plan de masse. Et côté soudures (à « l’arrière »), vous retrouverez toutes les pistes cuivrées.

Cela étant dit, vous vous demanderez peut-être pourquoi j’ai positionné tel ou tel composant électronique de telle ou telle manière. Du coup, je vous glisse quelques explications ici, à ce sujet. En fait :

  • La place au centre reste volontairement libre afin de laisser passer les fils et connecteur de l’alimentation externe, une fois le boitier refermé ; cet écartement sert également à distancier au possible l’arduino et le capteur de température, pour que ce dernier ne soit pas trop influencé par le dégagement de chaleur du microcontrôleur.
  • Les bornes de connexion de l’écran OLED ont été positionnés en avant du PCB, afin de faciliter le montage en boitier (comme vous le verrez un peu plus loin, en image)
  • Le capteur DHT22 est implanté juste en arrière des ouïes de ventilation du boitier, afin de bien capter la température et humidité ambiante, sans toutefois varier trop rapidement (cela créé un peu d’inertie, afin de stabiliser les mesures). Ce capteur est d’ailleurs mis à l’opposé de l’Arduino Nano, afin que ses mesures ne soient pas « trop » faussées par ce dernier, comme évoqué précédemment.
  • Et l’Arduino Nano a été placé de telle manière que sa prise USB se retrouve à l’arrière du PCB, afin de pouvoir reprogrammer facilement son arduino, au besoin, sans avoir à tout démonter (il suffira juste de déclipser l’arrière du boitier, en fait)

Ceci étant dit, passons maintenant aux soudures et à l’assemblage complet de ce thermomètre arduino !

Soudure des composants

Voici comment ont été soudés et positionnés les composants de ce thermomètre arduino au niveau du PCB, vu sous différents angles :

Comme vous le constaterez, l’Arduino et le DHT22 sont montés sur support débrochable, afin de pouvoir les sortir au besoin. L’alim sera quant à elle branchée sur le connecteur blanc, doté d’un détrompeur, afin d’éviter les risques d’inversion de polarité (même si cela n’est pas vraiment nécessaire, dans l’absolu, puisqu’une diode anti-retour a été mise en œuvre dans ce montage). Enfin, l’écran OLED a lui aussi ses broches de connexion, car déporté du circuit imprimé (connexion via fils dupont, comme visible un peu plus loin).

À noter ici que tous les composants sont « traversants ». Il n’y a donc aucun CMS à souder.

Mise en place du connecteur d’alimentation externe

Avant d’aller plus loin, il sera nécessaire de mettre en place le connecteur d’alimentation DC Ø5,5 de part et d’autre du couvercle du thermomètre arduino. Voici comment cela se présente, en photos :

Si vous refaites ce montage, n’oubliez surtout pas de mettre en place l’écrou de fixation du connecteur DC « autour des fils », avant toute soudure. De même, n’oubliez pas de glisser des bouts de gaine thermorétractable sur chacun des fils, si vous souhaitez faire de belles finitions 😉

Symbole connecteur DC intérieur plus et extérieur moins, polarité positive au centre et négative au contour, conducteur électrique d'alimentation élec

Important : ATTENTION à la polarité du connecteur DC en lui même. Car, tel que présenté sur la 4ème photo ci-dessus, il faut que vous câbliez les éléments de telle manière que :
le fil rouge correspond à la « tige métallique » centrale de l’embase DC
le fil noir correspond à la « bague métallique » externe de l’embase DC
À ce stade, je vous recommande d’ailleurs de bien vérifier vos sens de raccordements avec un multimètre, afin de vous assurer que tout soit bien câblé ! Et ce, AVANT soudure de quoi que ce soit 😉

Raccordement écran OLED, avec mise en boitier

Maintenant, passons à l’afficheur OLED ! Pour commencer, il s’agira de brancher 4 fils dupont (longueur 10cm, type femelle/femelle) sur l’arrière de l’écran oled. Une fois fait, il faudra ensuite insérer cet afficheur dans le boitier imprimé en 3D, « en forçant » légèrement (car j’ai conçu ce boitier 3D afin qu’il n’y ait besoin d’aucune vis, les pièces électroniques étant maintenues serrées, par friction ; cela étant dit, rien ne vous empêche de mettre un point de colle, si avez peur qu’il tombe !). Un aperçu de tout ça, en images :

Nota : faites bien attention de ne pas vous tromper dans le sens de montage de l’écran OLED, et des fils de connexion dupont. Au moindre doute, n’hésitez pas à vous référer aux photos suivantes, pour éviter de commettre la moindre erreur 😉

Montage de l’Arduino Nano, et du capteur DHT22

Histoire de compléter notre montage, nous pouvons à présent ajouter l’Arduino Nano sur son support (en veillant bien à mettre le côté du connecteur USB dans le bon sens), ainsi que le capteur de t° et hygrométrie DHT22. D’ailleurs, voici quelques autres photos prises à la volée, vous montrant leurs implantations respectives, sous divers angles :

Cela étant fait, nous allons pouvoir commencer à finaliser ce thermomètre arduino !

Raccordements finaux, et glissement du circuit imprimé dans le boitier

À présent, nous avons presque fini de monter le tout. Car il ne reste plus qu’à brancher les fils dupont de l’écran OLED sur le PCB, ainsi que le connecteur d’alimentation, et glisser le circuit imprimé dans son logement. Pour ce faire, une glissière a été créée dans le modèle d’impression 3d, afin de pouvoir maintenir le PCB en place, dans le bas du boitier. À noter que le glissement est quelque peu étroit, et va vous obliger à forcer un peu sur le pcb pour le mettre en place (ce qui est parfaitement normal, et nécessaire pour maintenir le circuit imprimé en place, pour ne pas qu’il bouge ensuite). Voici ce que cela donne, en couleur :

Remarque : vous avez là une « superbe » vue d’ensemble des composants. Profitez-en pour vérifier que vous ayez bien respecté leurs sens de branchement respectifs !

Fermeture du boitier, et branchement du bloc d’alimentation externe

Dernière étape : la fermeture du boitier. Ici, il s’agit d’un boitier conçu pour se refermer par simple « clipsage ». Il n’y a donc pas la moindre vis à mettre. Du reste, il ne vous restera plus qu’à brancher le cordon du bloc d’alimentation externe (7,5V/1A, dans ce projet), tel que visible sur les images ci-dessous :

Voilà ! Nous voici arrivé au terme du montage de ce thermomètre arduino. Maintenant, place à la mise sous tension, et aux essais !

Essais et remarques

Les essais sont en fait rapides à faire, car il n’y a, pour ainsi dire, rien à faire ! En somme : on branche, … et ça tourne tout seul !

En fait, une fois mis sous tension, vous devriez voir s’afficher :

  • Un message de bienvenue
  • Et en boucle : tantôt l’affichage de la température mesurée, tantôt l’affichage du taux d’humidité mesuré

À noter qu’en cas de problème de récupération d’infos au niveau de la sonde de température / hygrométrie, la valeur « — » s’affichera à la place des chiffres.

Du reste, voici deux photos de l’écran OLED en gros plan, prises de mon côté :

Affichage température arduino, mesure faite avec capteur DHT22 et afficheur oled i2c, projet de thermomètre électronique idéal pour débutant
Affichage hygrométrie arduino sur écran OLED, via sonde DHT22 pour mesure de température et taux d'humidité ambiant dans l'air, montage DIY électronique

Au passage, je vous prie de bien vouloir m’excuser de ne pas avoir pu vous mettre plus de photos ici, mais la fréquence de rafraîchissement de l’afficheur OLED m’a empêché de prendre des photos correctes (que ce soit via mon téléphone, ou via mon appareil photo, car ils ne sont pas suffisamment paramétrables). Je suis donc désolé de ne pouvoir vous mettre plus de photos ici, faute de mieux !

Par contre, histoire de bien souligner le fait que ce projet n’est pas parfait, j’aurais quelques remarques critiques à vous partager (même si l’intérêt premier de ce thermomètre arduino n’était pas d’être parfait, je vous l’accorde !). En fait, en synthèse, je dirais que :

  • La précision de ce thermomètre arduino est quelque peu relative, du fait que la chaleur dégagée par l’Arduino Nano, au sein même du boitier 3d, va forcément quelque peu fausser les mesures de la sonde DHT22. C’est d’ailleurs pourquoi j’ai retiré un degré à chaque mesure de température, dans le programme arduino, avant affichage.
  • L’impression 3D n’est pas une œuvre d’art en soi, même si elle se révèle simple et fonctionnelle à la fois, sans requérir la moindre vis. Par ailleurs, les parties emboitées risquent de prendre du jeu avec le temps, si manipulées trop souvent.
  • La taille de l’écran OLED est trop petite pour une lecture de loin. En fait, sa taille est adaptée pour une lecture de près, dans le cas où, par exemple, vous poseriez ce thermomètre arduino sur votre bureau de travail, à portée de main. Sinon, l’écriture se révèlera quelque peu petite pour vos yeux, très probablement !
  • L’absence de « trou » permettant de pouvoir programmer l’arduino directement, depuis l’extérieur du boitier, vous obligera à ouvrir ce dernier pour toute modif du programme. Cela étant dit, comme vous n’aurez certainement jamais besoin de retoucher au code de programmation, cela n’est pas vraiment un souci en soi, me direz-vous 😉

Voilà ! Comme ça, tout est dit !

Liens utiles et téléchargements

Si vous êtes intéressé par la reproduction de ce projet chez vous, voici tous les fichiers qui vous seront nécessaires :

Et la liste des composants électroniques nécessaires :

Conclusion

J’espère que ce projet vous aura plu, ou tout du moins, aura su vous inspirer ou vous permettre d’apprendre de nouvelles choses, notamment au niveau de la mise en œuvre pratique des capteurs type DHT22 et écrans OLED i2c à contrôleur SSD1306. Aussi, n’hésitez pas à laisser vos remarques et questions en commentaires, au besoin !

Du reste, si ce genre de réalisation vous plait, n’hésitez pas également à le me dire dans la zone commentaire ! En attendant, je continuerai bien sûr à vous publier un maximum d’articles et tutos, mais dans la limite du temps dont je dispose, bien entendu 😉

Voilà pour aujourd’hui ! Il ne me reste plus qu’à vous dire « à la prochaine » !

Jérôme.

À découvrir aussi : réalisation d’un coupleur d’accus 18650 au lithium-ion

Ce contenu vous plaît ? Alors abonnez-vous à la Newsletter pour ne rien louper !

(*) Mis à jour le 26/09/2021

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Symbole danger point d'exclamation site PSE, triangle jaune avec contour noir, texte noir alerte au milieu Afin de filtrer au maximum les messages de type "spam", chaque commentaire est soumis à modération, et validé manuellement. Du coup, ne vous inquiétez pas si votre message n'apparait pas immédiatement en zone commentaires !