Institut supérieur du Génie Appliqué

4ème année Génie Électrique : Système à microprocesseur

Rapport Atelier 2 : Mesure de la température et de l’humidité

Réalisé par : Encadré par :

LECKOSSO Emery Pr. ARSALANE
EL AIMANI Soumia Pr. GHOMARI

3 Novembre 2023
Table des matières
1) Introduction ..................................................................................................................... 3
2) Carte à microprocesseur Rapsberry Pi ..................................................................... 3
3) Capteur Température/Humidité (DHT11) ............................................................... 4
4) Afficheur I2C .................................................................................................................... 5
5) Application ....................................................................................................................... 7
6) Conclusion ...................................................................................................................... 11

2
 1) Introduction
Bienvenue dans notre atelier système à microprocesseur, où nous explorerons l'utilisation
du capteur DHT11 en tandem avec un Raspberry Pi. Notre objectif est de créer un système
intelligent capable de mesurer la température et l'humidité de l'environnement. Dans cette
première étape, nous afficherons les données sur la console, plongeant ainsi dans les bases
de la communication entre le capteur et le Raspberry Pi. Préparez-vous à plonger dans le
monde fascinant de l'électronique et de l'informatique embarquée.

2) Carte à microprocesseur Rapsberry Pi

Le Raspberry Pi est une série de petits ordinateurs monocartes développée par la Fondation
Raspberry Pi. Ces ordinateurs, de la taille d'une carte de crédit et abordables, ont gagné en
popularité en raison de leur polyvalence et de leur facilité d'utilisation. Voici quelques
aspects clés du Raspberry Pi :

Matériel - Carte mère avec processeur, GPU, mémoire, ports HDMI, USB, GPIO,
audio, et emplacement pour carte microSD.

Système - Principalement basé sur Raspbian (maintenant appelé Raspberry Pi

d'exploitation OS), une distribution Linux.

Utilisations - Projets de bricolage, éducation, prototypage.

- Applications possibles : centre multimédia, serveur, console de jeux
rétro, etc.

Programmation - Prend en charge divers langages dont Python, Scratch, Java, C++.
Communauté - Communauté active, forums, ressources en ligne sur le site officiel
et Ressources (https://www.raspberrypi.org/).

Accessoires - Modules caméra, écrans, HATs (Hardware Attached on Top)

disponibles.

Mises à jour - Nouveaux modèles publiés périodiquement par la Fondation

Raspberry Pi.

Le Raspberry Pi est accessible, polyvalent, et adapté à l'apprentissage de la programmation

et de l'électronique.

3
 3) Capteur Température/Humidité (DHT11)
Ce composant regroupe à la fois une sonde de température et un capteur d’humidité. Il
existe une autre version, le DHT22 qui est plus précise et possède une plus large plage de
fonctionnement, mais qui coûte environ le double du prix. Il existe également un capteur
portant la référence AM2302, qui est en fait un DHT22 avec des fils au lieu de broches, et
une résistance pull-up.

Le module capteur de température et d'humidité comporte un DHT11 dans lequel est

intégrée une thermistance pour capter la température et un capteur capacitif pour capter
l'humidité.
Détails techniques Pour résumer, voici les caractéristiques des deux capteurs sous forme de
tableau comparatif:

DHT22 / AM2302 DHT11

Humidité (relative %) 0 ~ 100 % 20 ~ 80%
Précision (humidité) +/- 2% (+/- 5% aux extrêmes) +/- 5%
Température -40 ~ +150°C 0 ~ +50°C
Précision (température) +/- 0.5°C +/- 2°C
Fréquence mesure max 2Hz (2 mesures par seconde) 1Hz (1 mesure par seconde)
Tension d'alimentation 3 ~ 5 volts 3 ~ 5 volts
Stabilité à long terme +/- 0.5% par an +/- 1% par an

4
Le DHT22 est clairement beaucoup plus précis et stable que le DHT11. Mais il est aussi deux
fois plus cher. Le choix se résume donc à une question de balance entre budget, précision et
rapidité de mesure.
En toute franchise, si vous voulez des mesures à peu près correctes, utilisez un DHT22, ou
mieux, des capteurs d'humidité et de température spécialisés. Les capteurs DHTxx sont assez
imprécis en général et tout particulièrement les DHT11 qui sont pour ainsi dire inutilisables
en capteur d'humidité tellement la mesure est imprécise.
Attention : Le DHT11 ne peut pas mesurer (et supporter) des températures négatives ou des
températures supérieures à 50°C. Attention donc en cas d'utilisation en extérieur !

4) Afficheur I2C
Un afficheur LCD I2C, également connu sous le nom d'écran LCD avec interface I2C, est un
type d'afficheur à cristaux liquides qui utilise le protocole de communication I2C (Inter-
Integrated Circuit) pour être connecté à d'autres dispositifs, tels que des microcontrôleurs
ou des cartes de développement comme le Raspberry Pi. Voici les principaux aspects liés à
ces afficheurs :

Principe de Fonctionnement :

Écran LCD Il utilise la technologie des cristaux liquides pour afficher du

I2C (Inter-Integrated Circuit)
Contrôleur I2C
Caractéristiques :
texte, des chiffres ou des graphiques.
C'est un protocole de communication série bidirectionnel
qui permet la communication entre plusieurs périphériques
avec seulement deux fils, SDA (Serial Data Line) et SCL
(Serial Clock Line). L'utilisation de l'I2C simplifie le câblage,
car de nombreux périphériques peuvent partager le même
bus I2C.
:** L'afficheur LCD est généralement équipé d'un
contrôleur qui prend en charge la communication I2C. Ce
contrôleur peut recevoir des commandes et des données
via le bus I2C pour contrôler l'affichage.

Adresse I2C Chaque périphérique I2C a une adresse unique sur le bus. Cela
permet à plusieurs périphériques de coexister sur le même bus sans
conflits.
Taille de l'écran Les afficheurs LCD I2C sont disponibles dans différentes tailles,
allant de petites configurations (comme 16x2, indiquant 16
caractères par 2 lignes) à des écrans plus grands.
Rétro-éclairage Certains modèles d'afficheurs LCD I2C incluent un rétro-éclairage, ce
qui facilite la lisibilité dans des conditions de faible luminosité.
5
 Facilité d'utilisation En utilisant le protocole I2C, ces afficheurs nécessitent moins de fils
pour la connexion par rapport aux configurations traditionnelles, ce
qui simplifie le câblage et rend leur utilisation plus conviviale.
Compatibilité Ils sont souvent utilisés avec une variété de microcontrôleurs et de
cartes de développement, tels que le Raspberry Pi, l'Arduino, etc.

Avantage :

Simplicité de Câblage
Compatibilité Universelle
Contrôle Facile
La connexion via I2C nécessite moins de fils que les méthodes
traditionnelles, ce qui simplifie les projets électroniques.
En raison de la popularité du protocole I2C, ces afficheurs sont
compatibles avec de nombreux dispositifs.
Les bibliothèques logicielles disponibles facilitent le contrôle
de ces afficheurs avec des langages de programmation
courants comme Python.

En résumé, un afficheur LCD I2C est un composant d'affichage pratique qui simplifie le
câblage grâce à l'utilisation du protocole I2C. Ces afficheurs sont couramment utilisés dans
une variété de projets électroniques pour afficher des informations de manière claire et
lisible.

6
 5) Application
Objectifs de l’atelier

L'objectif de l'atelier est de récupérer les valeurs de la température et l'humidité dans un

local. La démarche suivie sera la suivante:
 Afficher sur la console la température et l'humidité mesurée par le capteur.
 Afficher sur l'afficheur LCD 12C les deux valeurs.
 Animer le module trois LED's selon les valeurs de la température

Dans le cadre de notre atelier, nous avons utilisé Raspberry Model 4.

Nous utiliserons la bibliothèque Python Adafruit DHT11. Vous pouvez télécharger la

bibliothèque en utilisant Git, donc si Git n'est pas déjà installé sur votre Pi, saisissez ceci à
l'invite de commande:

Console Raspberry Pi
sudo apt-get install git-core

Remarque : Si vous obtenez une erreur lors de l'installation de Git, exécutez-le sudo apt-
get update et réessayez.
Pour installer la bibliothèque Adafruit DHT11 :

7
 1. Saisissez ceci à l'invite de commande pour télécharger la bibliothèque

Console Raspberry Pi
git clone https://github.com/adafruit/Adafruit_Python_DHT.git

2. Changez de répertoire avec

Console Raspberry Pi
cd Adafruit_Python_DHT

3. Entrez maintenant ceci

Console Raspberry Pi
sudo apt-get install build-essential python-dev

4. Installez ensuite la bibliothèque avec

Console Raspberry Pi
sudo python setup.py install

Ainsi, le DHT11 est enfin prêt a l’utilisation. Le capteur de température/humidité DHT11

comporte 3 broches qui seront branchés à la carte Raspberry comme illustré sur la figure
suivante :

8
Code :

Python
import Adafruit_DHT
import time

DHT_SENSOR =Adafruit_DHT.DHT11
DHT_PIN = 4

while True:
humidity, temperature = Adafruit_DHT;read(DHT_SENSOR; DHT_PIN)
if humidity is not None and temperature is not None:
print("Temp={0:0.1f}C Humidity={1:0.1f}%".format(temperature,
humidity))
else:
print("Sensor failaire. Chek wring.");
time.sleep(3);

Pour afficher un message sur l'afficheur led i2c, il faut coller le fichier I2C_LCD_driver.py
dans le même répertoire que votre projet.

Afin de connaitre l'adresse de votre afficheur, merci d'exécuter la commande ci joint sur
votre terminal i2cdetect -y 1

Console Raspberry Pi
i2cdetect -y 1

On change l’adresse dans le fichier de la bibliothèque I2C_LCD_driver.py pour que la carte

identifie l’afficheur.

Python => I2C_LCD_driver.py

# i2c bus (0 -- original Pi, 1 -- Rev 2 Pi)
I2CBUS = 1

# LCD Address
ADDRESS = 0x26

Attention : toujours vérifier l’adresse de l’afficheur avant de commencer le programme.

9
Code :

Python
import …
import I2C_LCD_driver

mylcd = I2C_LCD_driver.lcd()
DHT_SENSOR =Adafruit_DHT.DHT11
DHT_PIN = 4

while True:
humidity, temperature = Adafruit_DHT.read(DHT_SENSOR,DHT_PIN)
if humidity is not None and temperature is not None:
mylcd.lcd_display_string("Temp={0:0.1f}C".format(temperature,
humidity),1)
mylcd.lcd_display_string("Humidity={1:0.1f}%".format(temperature,
humidity), 2)
else:
print("Sensor failaire. Chek wring.");
time.sleep(3);
#https://duckduckgo.com/?q=w3school&t=raspberrypi

Ici, notre objectif est d’indiquer en fonction d’un code couleur le niveau de la température
dans une pièce.

Code :

Python
import… #importations des bibliothèques
GPIO.setwarnings(False)
GPIO.setmode(GPIO.BCM)
GPIO.setup(13,GPIO.OUT,initial=GPIO.LOW)
GPIO.setup(19,GPIO.OUT,initial=GPIO.LOW)
GPIO.setup(26,GPIO.OUT,initial=GPIO.LOW)
… # Déclaration du lcd et du DHT11
while True:
humidity, temperature = Adafruit_DHT.read(DHT_SENSOR,DHT_PIN)
if humidity is not None and temperature is not None:
… # affichage de l’humidité et la temperature
if 26<temperature: #or temperature<26 :
GPIO.output(13,GPIO.HIGH) ;GPIO.output(19,GPIO.LOW)
GPIO.output(26,GPIO.LOW) ;print("rouge")
elif temperature==26:
GPIO.output(13,GPIO.LOW) ;GPIO.output(19,GPIO.HIGH)
GPIO.output(26,GPIO.LOW) ;print("jaune")
else:
GPIO.output(13,GPIO.LOW) ;GPIO.output(19,GPIO.LOW)
GPIO.output(26,GPIO.HIGH) ;print("vert")
else:
print("Sensor failaire. Chek wring.");
time.sleep(3);

10
 6) Conclusion
Cette ainsi que nous arrivons à la fin de notre atelier. Nous avons réussi à intégrer avec
succès le capteur DHT11 au Raspberry Pi et à afficher les données sur la console ensuite sur
l’afficheur LCD I2C et enfin à faire une signalisation à l’aide feux tricolore pour indique le
niveau de température correspondant. Nous avons mis en pratique nos connaissances en
programmation et appris d’avantage par rapport l’univers dans capteur avec le python. Que
ce soit en étendant les fonctionnalités, en explorant des afficheurs LCD ou en intégrant
d'autres capteurs, les possibilités sont infinies. Nous continuerons à explorer, à apprendre et
à repousser les limites de la technologie !

11