Département : STIC

Référence : RST

Licence Appliquée en Sciences et technologies de l’Information

et de la Communication
Option RST

Projet Tutoré

Adaptation automatique de
climatisation
Réalisé par : Sirine HANAFI

Nesrine CHAOUANI

Classe : L3 RST-A

Encadré par : M. Moez BALTI

Année Universitaire : 2021-2022

 Remerciements

Nous remercions le bon Dieu de nous avoir accordé toute la patience, le courage, la
volonté et la motivation qui nous ont permis de mener à bien ce travail jusqu’à sa fin.

Nous tenons à exprimer notre profonde gratitude et nos sincères remerciements à notre
encadrant M. Moez BALTI, pour sa précieuse aide, ces encouragements constants, ces bons
conseils et pour nous avoir guidés durant toute la période d’exécution de ce travail malgré ses
nombreuses préoccupations.

Nos remerciements sont adressés de même pour les membres du jury pour le grand
honneur qu’ils nous rendent de juger ce travail.

En conclusion, Nous exprimons nos sincères reconnaissances aux personnes qui ont
participé à notre formation, spécialement les professeurs de département Science et
Technologie de l’information et de communication (STIC) de l’Institut Supérieur des
études technologiques en Communications de Tunis (ISET’COM)

i
 Table des matières
Introduction générale ......................................................................................................... 1
Chapitre 1 : Revue de littérature .......................................................................................... 2
Introduction .................................................................................................................. 2
1. Etude et concepts théoriques .................................................................................... 2
1.1 Internet des objets ........................................................................................... 2
1.1.1 Champs d’application d'Internet des objets ..................................................... 3
1.1.2 Les avantages d’emploi de l’Internet des Objets .............................................. 3
1.1.3 Les composants d’une application IoT............................................................ 4
1.1.3.1. Objets.................................................................................................. 4
1.1.3.2. Capteurs .............................................................................................. 4
1.1.3.3. Actuateurs............................................................................................ 4
1.1.3.4. Les composants de stockage ................................................................... 5
1.1.4 Domaine d’application d’objet connecté ......................................................... 5
1.2 Système embarquée ......................................................................................... 6
1.2.1 Description du système embarquée ................................................................ 6
1.2.2. Caractéristiques .......................................................................................... 6
1.2.3. Composition du système embarquée .............................................................. 7
1.2.4. Comparaison aux systèmes informatiques standards ........................................ 7
1.2.5. Contraintes ................................................................................................. 8
1.2.6. Systèmes embarqués temps réel .................................................................... 8
2. But de la commande automatique de climatisation ..................................................... 9
3. Méthodologie de travail .........................................................................................10
Conclusion ..................................................................................................................11
Chapitre 2 : Choix du matériel ...........................................................................................12
Introduction .................................................................................................................12
1. Choix de la carte programmable ..............................................................................12
1.1. Carte Raspberry Pi .........................................................................................12
1.2. Carte FPGA...................................................................................................14
1.3. Carte Arduino ................................................................................................14
1.4. Différence entre les cartes programmables ........................................................16
2. Capteur de température ..........................................................................................16
Conclusion ..................................................................................................................18
Chapitre 3 : Conception ....................................................................................................19
Introduction .................................................................................................................19
ii
 1. Langage de conception ..........................................................................................19
1.1. Langage UML ...............................................................................................19
1.2. StarUML.......................................................................................................20
1.3. Utilisation de l’UML ......................................................................................20
2. Spécification des besoins........................................................................................20
2.1. Besoins fonctionnels .......................................................................................20
2.1.1. Perspective du système ...............................................................................21
2.1.2. Besoins opérationnels .................................................................................21
2.2. Besoins non fonctionnels ................................................................................21
3. Analyse des besoins...............................................................................................22
3.1. Diagramme des cas d’utilisation global .............................................................22
3.1.1. Description textuelle des principaux cas d’utilisation......................................23
3.1.2. Cas d’utilisation « traiter l’information » ......................................................23
3.2. Diagramme de séquence .................................................................................24
3.3. Diagramme de classes.....................................................................................25
Conclusion ..................................................................................................................26
Chapitre 4 : Réalisation.....................................................................................................27
Introduction .................................................................................................................27
1. Environnement de travail .......................................................................................27
1.1. Environnement matériel ..................................................................................27
1.2. Environnement logiciel ...................................................................................27
1.2.1. Plateformes logicielles ................................................................................27
1.2.1.1. Win32 Disk Imager ..............................................................................27
1.2.1.2. Raspbian OS .......................................................................................28
1.2.1.3. PuTTY ...............................................................................................28
1.2.1.4. Isis Proteus .........................................................................................29
1.2.2. Langage de programmation utilisé ...............................................................30
1.2.2.1. Introduction à LINUX ..........................................................................30
1.2.2.3. Programmation des entrées / sorties avec python .....................................30
2. Phase d’implémentation .........................................................................................31
2.1. Configuration matérielle .................................................................................31
2.1.1. Configuration de DHT11 ............................................................................31
2.1.2. Configuration de relais ...............................................................................32
2.2. Configuration logicielle ..................................................................................34
Conclusion ..................................................................................................................36

iii
Conclusion générale .........................................................................................................37
Bibliographie et webographie ............................................................................................38
ANNEXE .......................................................................................................................40

iv
 Liste des figures
Figure 1.1: Prévision de nombre d’objets connectés vers 2020(par Patrick Olivier Kamgueu) ..... 2
Figure 1.2: Le thermostat Ecobee ........................................................................................ 5
Figure 1.3: Mécanisme d’un système embarqué .................................................................... 7
Figure 1.4: Système embarqué temps réel ............................................................................ 8
Figure 1.5: Modèle en V ...................................................................................................10
Figure 2.1 : Carte Raspberry Pi ..........................................................................................12
Figure 2.2: Carte FPGA Spartan 3E....................................................................................14
Figure 2.3: Carte Arduino .................................................................................................15
Figure 2.4: Capteur DHT11 ...............................................................................................16
Figure 2.5: Schéma de brochage de DHT11.........................................................................17
Figure 3.1: StarUML ........................................................................................................20
Figure 3.2: Diagramme des cas d'utilisation global ...............................................................22
Figure 3.3: Diagramme de cas d’utilisation « traiter l’information » .......................................23
Figure 3.4: Diagramme de séquence de cas d'utilisation « traiter l'information » ......................24
Figure 3.5: Diagramme de séquence de cas d'utilisation « gérer le climatiseur » .......................25
Figure 3.6: Diagramme de classe global ..............................................................................26
Figure 4.1:Interface de Win32 Disk Imager .........................................................................28
Figure 4.2: Ouvrir le système d'exploitation de Raspberry Pi .................................................28
Figure 4.3 : Interface de PuTTY.........................................................................................29
Figure 4.4 : Logo de python ..............................................................................................30
Figure 4.5 : Circuit réalisé .................................................................................................31
Figure 4.6 : Branchement du capteur avec la carte Raspberry ................................................31
Figure 4.7 : Relais ............................................................................................................32
Figure 4.8 : circuit de vérification de signal de commande ....................................................33
Figure 4.9 : Relais au repos ...............................................................................................33
Figure 4.10 : Relais allumé ................................................................................................34
Figure 4.11 : Point d'accès utilisé .......................................................................................34
Figure 4.12 : Résultat obtenu du 1er script ..........................................................................35
Figure 4.13 : Résultat obtenu du 2eme script .......................................................................36

v
 Liste des tableaux
Tableau 1.1: Comparaison entre les systèmes informatiques et les systèmes embarqués . 8
Tableau 2.1: Tableau comparatif des cartes programmables....................................... 16
Tableau 3.1: Tableau descriptif du cas d'utilisation " Traiter l'information " ................ 24
Tableau 4.1: Pin de branchement ............................................................................ 31

vi
 Liste d’abréviations
A

AC: Alternate Courant · 32

ARM: Advanced RISC Machines · 12
ASIC: Application Specific Integrated Circuits · 6

CLB: Configurable-Logic-Bloc · 14
CPU: Central Processing Unit · 12

DC: Direct Current · 32

DHT: Digital Humidity and Temperature · 9
DSP: Digital Signal Processor · 7

FPGA: Fild Programmable Gate Array · 6

GHz: Gigahertz · 7
GPIO: General Purpose Input/Output · 30
GPS: Global Positioning System · 5
GSM: Global System for Mobile communications · 5

IoT: Internet of Object · 1

LCD: Liquid Crystal Display · 6

LED: Light Emitter Diode · 6

MHz: Mégahertz · 7

vii
MMU: Memory Management Unit · 7
MySQL: My Structured Query Language · 37

NTC: Negative Temperature Coefficient · 17

OS: Operating System · 7

PC: Personal Computer · 6

RAM: Random Access Memory · 12

RTOS: Real-Time Operating System · 7

SSH: Secure Shell · 28

TCP: Transmission Control Protocol · 28

UML: Unified Modeling Language · 19

USB: Universal Serial Bus · 12

V.L.S.I: Very-Large-Scale-Integration-Circuits · 14
VHDL: Verilog Hardware Description Language · 16

viii
 Introduction générale

Quel que soit l’endroit où nous pouvons être et le confort qui peut nous être procuré, la
maison est notre coin du monde, notre seul havre de paix et c’est là que nous souhaitons avoir
le plus de confort possible. Si l’on est bien chez-soi, on est bien dans notre vie et avec notre
entourage. D’un point de vue scientifique, ce bien-être ne peut être assuré que par le
développement technologique. Ceci se traduit par la création et l’installation de matériels
connectés et programmés selon nos besoins assurant notre confort. De nos jours, la maison
intelligente est devenue le modèle parfait, un paradigme assurant une vie d’extrême confort et
de modernisme. Ainsi avec le développement que l’électronique et la nanotechnologie ont
connu, tout est devenu miniature et accessible. De plus, grâce à l’informatique et la
programmation, les systèmes embarqués ont pris de l’ampleur et se sont attaqués à tous les
domaines notamment la Smart house.

L'internet des Objets (IoT) s'annonce comme une évolution sans précédent. Les objets
sont désormais capables de communiquer entre eux, d'échanger, de réagir et de s'adapter à
leur environnement à un niveau beaucoup plus large. Souvent qualifié de 3ème vague de la
révolution des nouvelles technologies de l'information, succédant à l'avènement de 'Internet
dans les années 1990, puis celui du Web 2.0 dans les années 2000, l'Internet des Objets
marque une nouvelle étape dans l'évolution du cyberespace. Cette révolution facilite la
création d'objets intelligents permettant des avancées dans de multiples domaines, l’un des
domaines les plus affectés par l’émergence de l’IoT est la domotique.

Le rapport est organisé de la manière suivante :

 Le premier chapitre introduit l’internet des objets, les systèmes embarqués ainsi que
notre projet;
 Le deuxième chapitre explique le choix des matériaux utilisés pour réaliser notre
prototype (la carte programmable et le capteur de température);
 Le troisième chapitre présente les différentes étapes de la conception détaillée ;
 Quant au quatrième et dernier chapitre, qui est pratique, il présente la partie software
et hardware de notre projet.

1
 Chapitre 1 : Revue de littérature
Introduction
Avant d'entrer dans le vif du sujet, il convient de comprendre d’une façon générale de
quoi il s'agit. Bien que les objets connectés soient à la mode, pour beaucoup de gens cela reste
encore une idée très vague, tout comme la commande automatique de climatiseur, qui
véhicule avec elle depuis très longtemps la mauvaise réputation d'être chère et compliquée à
mettre en place.

Tout d'abord, nous commençons par définir les concepts Internet des objets. Nous
présentons ensuite le concept du système embarqué. Nous présentons aussi notre projet.

1. Etude et concepts théoriques

1.1 Internet des objets
L’internet des objets représente l’extension d’internet à des choses et à des lieux du
monde physique. Cela a permet à toute l’humanité de plonger dans les profondeurs de
l’internet et des recherches ses mystères pour devenir l’un des outils indispensables dans notre
vie quotidienne. Ainsi, son utilisation a touché tous les aspects de la vie quotidienne. [1]

L’internet des objets est définit par l’union international des télécommunications comme
une infrastructure mondiale pour la société de l’information, qui permet de disposer de
services évolués en interconnectant des objets (physiques ou virtuels ) grâce aux technologies
de l’informations et de la communications interopérables existantes ou en évolution et cela
veut dire que l’internet des objets est apparu dans le cadre d’une direction issue de la
mécanisation et standardisation , appliquée à l’automatisation du traitement du document et
de l’information .[1]

Figure 1.1: Prévision de nombre d’objets connectés vers 2020(par Patrick Olivier Kamgueu)

2
Chapitre 1 Revue de littérature

1.1.1 Champs d’application d'Internet des objets

Aujourd’hui, environ 7 milliards d’objets connectés fonctionnent à travers le monde et, à
court terme, presque tous les objets de notre quotidien seront reliés au Web. L’IoT permet de
véritables avancées dans de nombreux domaines. [1]

A. La santé
Ces objets connectés pour la santé aident, par exemple, les personnes à prendre leurs
constantes comme le diabète, et permettent le maintien à domicile des personnes malades et
dépendantes par l'aménagement du logement, par exemple en géo localisent des personnes
fragiles ;[1]

B. La smart city
À l'échelle d'une ville et non plus seulement d'une maison, l'IoT offre une mutualisation
des énergies par bâtiments et quartiers, des voitures connectées et partagées dans un
immeuble, du mobilier urbain et des institutions connectés pour fournir des services ;[1]

C. Le commerce et les loisirs

Les objets connectés relient le consommateur aux boutiques et aux sites d’e-commerce.
Ils mesurent également les performances personnelles (quantified self). Les vêtements
deviennent interactifs, les montres et bracelets connectés donnent des indications, les lunettes
affichent des données ; [1]

D. Les transports
De plus en plus utilisés par les communes, les objets servent à informer en temps réel
d’une place qui se libère dans une rue, à piloter une voiture autonome, à recharger un forfait
sur Smartphone, et vont jusqu'à contrôler le trafic avec des drones ;[1]

E. L’industrie
Les utilisations dans l'industrie sont très importantes : appareils pour améliorer la qualité
et l'efficacité, réduire les coûts, localiser des marchandises, alerter sur des dangers, etc.… [1]

1.1.2 Les avantages d’emploi de l’Internet des Objets

Les avantages de l’usage de l’Internet des objets pour l’amélioration de l’expérience
client sont multiples :

A. Prédiction et anticipation
Les pannes que l’utilisateur pourra rencontrer (panne, avarie) peuvent être anticipées. Par
exemple, une maintenance préventive pourra être effectuée sur un appareil dont l’activité est
suivie si une anomalie est constatée ; [2]

3
Chapitre 1 Revue de littérature

B. Humanisation
La collection de données permet aux entreprises d’avoir une meilleure compréhension du
consommateur et de mieux interagir avec ce dernier. Grâce à ces données, le produit est rendu
plus intelligent, mais aussi plus responsif ; [2]

C. Adaptation
Un cycle de satisfaction du client est enclenché dans la mesure où les informations
collectées sur le fonctionnement et l’usage du produit vont permettre d’améliorer les produits
de manière proactive en cernant la manière dont sont utilisés les produits et en intégrant les
préférences ; [2]

D. Fidélisation
Grâce à l’IoT, les services proposés au client s’adaptent de manière poussée au
consommateur, par la pertinence des informations recueillies. Les services proposés sont
personnalisés. Plus les consommateurs ont le sentiment d’être compris, plus ils sont loyaux. [2]

1.1.3 Les composants d’une application IoT

Selon (Matta et al., 2017) l’IoT se compose de quatre composants qui sont les suivants :

1.1.3.1. Objets
Ce sont les objets équipés en électronique, ayant une capacité de calcul et une interface
de communication. On peut découvrir, gérer, interagir avec et contrôler ces objets via internet.
Le terme objet peut englober les appareils, les êtres humains, ou toute autre entité à laquelle
on peut associer des attributs ;

1.1.3.2. Capteurs
C’est une interface essentielle pour l’implémentation en IoT, considérée comme le
"frontend" de l’environnement IoT. La collecte de données des capteurs est considérée
comme l’évènement stimulant toutes les activités en IoT. La nature des capteurs utilisés
dépend intrinsèquement de la nature de l’application elle-même. Certains capteurs sont
spécifiques à un domaine d’application bien déterminé, alors que d’autres sont adaptés à
différentes applications IoT. Les capteurs sont classifiés essentiellement selon la taille des
données, la fréquence d’échantillonnage, le nombre d’appareils connectés et les types de
signaux associés au capteur. On peut aussi identifier les capteurs comme capteur de
proximité, capteur tactile, capteur d’humidité, capteur de température, capteur de pression,
accéléromètre et gyroscope ;

1.1.3.3. Actuateurs
Les données collectées par les capteurs sont analysées pour prendre des décisions et
déclencher les actions appropriées. Cette étape est assurée généralement par les actuateurs.
L’actuateur est donc un objet qui transforme les signaux électriques qu’il a reçu des capteurs
(ceux-là transforment au paravent l’énergie fonctionnelle (informations/actions) en signaux
électriques) en une énergie fonctionnelle (par exemple une énergie mécanique, une énergie
4
Chapitre 1 Revue de littérature

dynamique). L’ensemble des capteurs-actuateurs forme la colonne vertébrale des applications

IoT. Il est à noter que contrairement aux capteurs, le nombre d’actuateurs offerts sur le
marché ne répond toujours pas à la demande. Ceci peut être une bonne piste d’amélioration
aux chercheurs voulant travailler sur cet aspect. Les actuateurs sont classés en fonction de la
source d’énergie dont ils ont besoin et qu’ils utilisent pour provoquer le mouvement. Les
actuateurs IoT sont également identifiés comme étant pneumatiques, hydrauliques, électriques
et thermiques ;

1.1.3.4. Les composants de stockage

Étant un ensemble constitué d’un grand nombre d’objets, d’applications et de services qui
communiquent entre eux, la quantité d’information manipulée en IoT est énorme. Selon le
type d’application, l’information peut devoir être stockée. Le stockage des données peut se
faire à l’interne (dans un fichier ou dans une base de données), ou sur le cloud.

1.1.4 Domaine d’application d’objet connecté

Les usages de l’IoT ont su se développer et, aujourd'hui, les objets connectés sont partout.
Ils sont particulièrement appropriés dans certains domaines

A. La sécurité
Un domaine dans lequel les objets connectés sont très présents est la sécurité.
Aujourd'hui, la miniaturisation des GPS, la connexion GSM et les progrès réalisés dans
l'autonomie des batteries permettent de fabriquer des balises de géo localisation utiles pour les
enfants (vérifier qu'ils soient bien rentrés à la maison, secours en cas d'enlèvement les seniors,
cas des personnes atteintes d'Alzheimer par exemple) ;[5]

B. Les économies d'énergie

Nous aborderons un peu plus loin le domaine des économies d'énergie, qui fera d'ailleurs
l'objet de notre première grande partie. Sachez que c'est un domaine très fourni en objets
connectés, notamment en thermostats n’est sans doute l'un des plus connus, Le thermostat
Ecobee peut être piloté depuis le site Internet, une tablette, un Smartphone et même une
montre Apple ;

Figure 1.2: Le thermostat Ecobee

5
Chapitre 1 Revue de littérature

C. Le confort
Même si la gestion de l'énergie, notamment du chauffage, est très importante, de
nombreux autres appareils existent pour améliorer son confort, comme les robots aspirateurs,
les robots tondeuses, mais également les ampoules connectées, permettant de créer des
ambiances lumineuses et parfois même de diffuser la musique de votre mobile.

1.2 Système embarquée

1.2.1 Description du système embarquée
Un système embarqué est un système complexe qui intègre du logiciel et du matériel
conçus ensemble afin de fournir des fonctionnalités données. Il contient généralement un ou
plusieurs microprocesseurs destinés à exécuter un ensemble de programmes définis lors de la
conception et stockés dans des mémoires. Le système matériel et l'application (logiciel) sont
intimement liés et immergés dans le matériel et ne sont pas aussi facilement discernables
comme dans un environnement de travail classique de type ordinateur de bureau PC
(Personal Computer).
Un système embarqué est autonome et ne possède pas des entrées/sorties standards tels
qu'un clavier ou un écran d'ordinateur. Contrairement à un PC, l'interface IHM (Interface
Homme machine) d’un système embarqué peut être aussi simple qu'une diode
électroluminescente LED (Light Emitter Diode) qui clignote ou aussi complexe qu'un système
de vision de nuit en temps réel ; les afficheurs à cristaux liquides LCD (Liquid Crystal
Display) de structure généralement simple sont couramment utilisés.
Afin d'optimiser les performances et la fiabilité de ces systèmes, des circuits numériques
programmables FPGA (Fild Programmable Gate Array), des circuits dédiés à des
applications spécifiques ASIC (Application Specific Integrated Circuits) ou des modules
analogiques sont en plus utilisés.
Les systèmes embarqués sont désormais utilisés dans des applications diverses tels que le
transport (avionique, espace, automobile, ferroviaire), dans les appareils électriques et
électroniques (appareils photo, jouets, postes de télévision, électroménager, systèmes audio,
téléphones portables), dans la distribution d'énergie, dans l'automatisation.

1.2.2. Caractéristiques
Les caractéristiques principales d'un système électronique embarqué sont :

 Autonome : Une fois enfouis dans l'application ils ne sont (le plus souvent) plus
accessibles ;
 Temps réel : Les temps de réponses de ces systèmes sont aussi importants que l'exactitude
des résultats ;
 Réactif : Il doit réagir à l'arrivée d'informations extérieures non prévues.

6
 Chapitre 1 Revue de littérature

1.2.3. Composition du système embarquée

Quelle que soit la nature et la complexité du système, on décompose un système
embarqué en :

 Système contrôlé ;
 Système de contrôle.
Le système contrôlé : environnement (procédé) équipé d'une instrumentation qui réalise
l'interface avec le système de contrôle. [3]

Le système de contrôle : il est composé des éléments matériels (microprocesseurs) et

logiciels dont la mission est d'agir sur le procédé via les actionneurs en fonction de l'état de ce
procédé indiqué par les capteurs de manière maintenir ou conduire le procédé dans un état
donné. [3]

Figure 1.3: Mécanisme d’un système embarqué

Un système électronique embarqué ou enfoui est un élément constitutif d'un système plus
complexe pour lequel il rend des services bien précis (contrôle, surveillance, communication).
Il est constitué de parties matérielles et logicielles qui sont conçues spécifiquement pour
réaliser une fonction dédiée.

Système embarqué = Système électronique/informatique conçu pour réaliser une ou

plusieurs tâches précises. [3]

1.2.4. Comparaison aux systèmes informatiques standards

Informatique : Embarqué :

 Processeur standard  Processeur dédié (contrôleur)

o Multiples unités fonctionnelles o Architecture adaptée
(flottant) o Vitesse faible (~200 MHz)
o Vitesse élevée (> GHz) o 8-32bits : mémoire limitée
o Consommation électrique élevée o Basse consommation
o Chaleur o Petite taille, grand volume => faible
o Taille coût
7
Chapitre 1 Revue de littérature

 MMU (mémoire virtuelle)  Processeur DSP (traitements)

 OS o Très puissants
 Cache  Quelques Mo de mémoire
 Grand nombre de périphériques  RTOS

Tableau 1.1: Comparaison entre les systèmes informatiques et les systèmes embarqués

1.2.5. Contraintes
Les systèmes embarqués exécutent des tâches prédéfinies et ont un cahier des
charges contraignant à remplir, qui peut être d'ordre :

 De coût : le prix de revient doit être le plus faible possible surtout s'il est produit en grande
série ;
 D'espace compté, ayant un espace mémoire limité de l'ordre de quelques Mo maximum. Il
convient de concevoir des systèmes embarqués qui répondent au besoin au plus juste pour
éviter un surcoût ;
 De puissance de calcul, il convient d'avoir la puissance de calcul juste nécessaire pour
répondre aux besoins et aux contraintes temporelles de la tâche prédéfinie. Ceci en
vue d'éviter un surcoût de l'appareil et une consommation excédentaire d'énergie (courant
électrique) ;
 De consommation énergétique la plus faible possible, due à l'utilisation de batteries et/ou,
de panneaux solaires voir de pile à combustible pour certains prototypes ;
 Temporel, dont les temps d'exécution et l'échéance temporelle d’une tâche sont déterminés
(les délais sont connus ou bornés a priori). Cette dernière contrainte fait que généralement
de tels systèmes ont des propriétés temps réel.[4]
1.2.6. Systèmes embarqués temps réel
Peut être qualifiée de "temps-réel" (ou "temps contraint", ou encore "réactif") toute
application mettant en œuvre un système informatique dont le fonctionnement est assujetti à
l'évolution dynamique de l'environnement qui lui est connecté et dont il doit contrôler le
comportement. [3]

Figure 1.4: Système embarqué temps réel

8
Chapitre 1 Revue de littérature

Ce sont des systèmes liés au contrôle de procédés l'exécution de programmes dans ces
systèmes doit terminer avant une date appelée échéance au-delà de laquelle les résultats ne
sont plus valides. On distingue deux types de systèmes embarqués temps-réel :

Exemple critique : le contrôleur de frein d'une voiture

A. Système temps-réel dur/stricte (hard real-time)

Le non-respect des échéances peut entraîner des conséquences graves sur le
fonctionnement du système ou sur son environnement (autopilotage, freinage, assistance
médicalisée). Les échéances ne doivent jamais être dépassées ;

B. Système temps-réel mou (soft real-time)

Le non-respect des échéances ralentit le système sans conséquences graves (billetterie
automatique). Le système doit répondre au mieux, le plus rapidement possible. La plupart des
systèmes embarqués sont dit mutlirate ou multi-période

 Les données sont capturées à un certain rythme ;

 Les traitements sur ces données ne sont pas forcément à la même granularité ;
 Différents traitements peuvent intervenir de manière indépendante ;
 Les actionneurs fonctionnent à une fréquence différente. [3]
2. But de la commande automatique de climatisation
Le but de notre projet était de réaliser un réseau de capteurs, c’est-à-dire un ensemble de
capteurs interconnectés par un réseau de communication. Les capteurs utilisés étaient des
capteurs de température et d’humidité de type (DHT11), et les diverses données étaient
traitées à l’aide de cartes Raspberry Pi.

 La précision
Le contrôle à distance est doté d’un capteur qui ressent la température ambiante et
communique avec l’appareil afin de régler la température et le débit d’air avec efficacité et
précision ;

 L’économie d’Energie
Mettre en veille les dispositifs de chauffage quand les habitants sont absents ou adapter
automatiquement l’utilisation des ressources électriques en fonction des besoins des résidents
afin de diminuer les gaspillages de ressources énergétiques suivi des consommations et
optimisation des tarifs ;

 L’intelligence
Adaptation du climatiseur et commande automatique selon les mesures de température et
de l’humidité d’où le confort par l’activation de l’appareil avant d’arriver chez vous.

9
Chapitre 1 Revue de littérature

3. Méthodologie de travail
Le modèle du cycle de vie adopté pour la conception du programme est le modèle en V,
la figure ci-suite constitue ce modèle sous ses différentes phases : Le principe de celui-ci est
qu’avec les autres décompositions doit être décrite la recomposition et que toute présentation
d'un composant soit accompagnée de tests qui permettront d'assurer qu'il correspond à sa
présentation.

Ceci rend explicite l'organisation des dernières échelons (validation- contrôle) par les
premières (construction du programme), et permet en fin de compte d'éviter un écueil bien
connu de la spécification du programme : énoncer une propriété que nous ne sommes pas
capable de contrôler de manière objective après la conception.

Le modèle en V tient compte du monde réel, le procès de programmation n'est pas

diminué à une suite d’actions séquentielles. Elle prouve que :

 C'est en étape de spécification des besoins que l'on s'inquiète des procédures de
désignation.
 C'est en étape de conception que l'on s'inquiète des procédures d’inclusion ;
 C'est en étape de conception précise que l'on prépare les essais unitaires.

Le modèle V permet de prévoir sur les étapes ultérieures de développement de produit.

Notamment Le modèle dernier offre un moyen de débuter plus tôt :

 Plan d'essais de qualification ;

 Plan de vérification des résultats.

Pourtant, ce modèle endure encore de difficulté de contrôle trop tardive du bon

fonctionnement du système.

Figure 1.5: Modèle en V

10
Chapitre 1 Revue de littérature

Conclusion
Dans ce chapitre, nous avons dégagé et mis en évidence les concepts clés de notre projet
"Adaptation automatique de climatisation" et le modèle du cycle de vie adopté pour la
conception du projet.

L'analyse a été très bénéfique pour pouvoir débuter la suite de la mise au point du projet,
cette analyse se dirige dorénavant vers l’étape de choix de matériels qui sera traitée dans la
partie suivante.

11
 Chapitre 2 : Choix du matériel
Introduction
Arduino et Raspberry Pi sont tous les deux des circuits de la taille d’une carte de crédit,
ils diffèrent par de nombreux aspects. Raspberry Pi est un micro-ordinateur qui fonctionne
sous Linux et qui peut être interfacé avec des composants électronique externes, tandis que
Arduino est une carte à microcontrôleur rudimentaire qui n’est pas dotée d’un quelconque
système d’exploitation.

Dans ce chapitre, nous devons entamer les différentes cartes programmables et distinguer
les différences entre eux, aussi connaître les autres matériaux nécessaires pour la réalisation
du projet.

1. Choix de la carte programmable

Dans cette partie nous avons évoqués plusieurs modèles de cartes programmables et leurs
spécifications techniques dont l'objectif de faire le choix de la plus optimisée pour notre
projet.

1.1. Carte Raspberry Pi

La carte Raspberry Pi est un circuit imprimé dont les maquettes sont publiées sous une
licence open source sur lequel on trouve un microcontrôleur paramétrable et un élément
fétiche des utilisateurs du matériel libre (open-Hardware). Physiquement, sa forme est une
carte-mère seule avec un CPU ARM11 à 700 MHz de fréquence. Elle comprend 1 ou 4 prises
USB, une prise RJ45 et 256 Mo de RAM pour la version d'origine (2 Gb de RAM Mo sur les
versions les plus récentes).

Figure 2.1 : Carte Raspberry Pi

12
Chapitre 2 Choix du matériel

Spécifications techniques

Physiquement, il s’agit d’une seule carte-mère avec un CPU ARM, de petite dimension
(environ la dimension d'une carte d’identité nationale ou d'un paquet de panadol), Il existe
trois types de carte : la version Zéro, la version A et la version B.

Voici leurs spécifications :

 Taille: 85.60 * 53.98 millimètres ;

 Poids: 45 grammes ;
 Processeur: ARM11 avec 700 MHz de fréquence ;
 System On Chip: BCM2835 ;
 GPU décodeur_Broadcom VideoCore4, OpenGL.ES2.0, MPEG2 et VC1, décodage vidéo
1080p30h.264/MPEG4-AVC ;
 SDRAM: 256Mo [Version A] ou 512 Mo [Version B] partagée avec le GPU ;
 USB2.0: 2 [Version B] ;
 S. Vidéo: RCA (PAL, NTSC) et HDMI (1.3&1.4) ;
 S. Audio: HDMI, 3.5mm jack ;
 Carte mémoire: SDHC/MMC/SD ;
 Réseau: Fast Ethernet ;
 Périphériques bas niveau: 8*GPIO, UART, I2C, SPI ;
 Alimentation: 5 V via Micro-USB ou GPIO; 300mA (1.5W) [Version A] ou 700mA
(3.5W) [Version B].[1]

Ce qu'on peut y ajouter

 La carte Raspberry Pi est vendue sans boîtier, clavier, souris, alimentation, ni écran. Pour
le but de minimiser le prix et pour pouvoir recycler d'autres composants ;
 Des boîtiers qui sont adaptés à la forme de sa carte mère sont disponibles sur le marché du
Raspberry Pi ;
 Un chargeur standard de Smartphone (µUSB/USB) convient parfaitement pour
l’alimentation de la carte ;
 En utilisant l’USB, on peut connecter de plusieurs périphériques : disques-durs externes,
lecteur Blue Ray, clé Wifi, Web Cam, imprimante, Scanner... ;
 Pour les programmeurs, les ports E/S Série peuvent servir l'interfaçage avec d'autres
circuits électroniques (des robots...).

13
Chapitre 2 Choix du matériel

1.2. Carte FPGA

Les cartes FPGA (Field-Programmable-Gate-Arrays ou Réseaux-Logiques-
Programmables) sont des composants V.L.S.I 100% reconfigurables ce qui offre la possibilité
de les reprogrammer autant de fois qu'on le veut pour booster notablement plusieurs étapes de
calculs.

Spécifications techniques
Les cartes FPGA sont des circuits programmables et qui sont constitués de trois parties :

 Une CLB « Configurable-Logic-Bloc » ou matrice de blocs logiques configurables ;

 Des blocs d’entrées/Sorties reconfigurables ;
 Un réseau d’interconnections programmables.

Il existe plusieurs constructeurs de cartes FPGA tels que Actel, Xilinx et Altera.[2]

.
Figure 2.2: Carte FPGA Spartan 3E

1.3. Carte Arduino

La carte Arduino est un circuit imprimé en matériel Open Source (dont l’architecture de
la carte est publié en licence-libre par contre des composants comme le µ-contrôleur par
exemple, ne sont pas en licence-libre) sur lequel se trouve un µ-contrôleur qui peut être
programmé pour la production et l’analyser des signaux électriques, de manière à effectuer
des diverses tâches comme pour notre sujet du projet la domotique (contrôle des appareils de
la maison, chauffage, éclairage, climatisation…), dans le domaine de robotique...etc.

Arduino Méga 2560

La carte Arduino-Méga-2560 est une carte électronique programmable et qui est basée
sur le µ-contrôleur ATmega-2560. Elle fournit 54 broches numériques d'Entrée/Sortie (dont

14
Chapitre 2 Choix du matériel

15 disposent d'une sortie P.W.M), 16 entrées analogiques, un résonateur-céramique (Quartz) à

16MHz de fréquence, une prise d’alimentation, un connecteur USB, un connecteur I.C.S.P et
un bouton de RESET.
Il contient le nécessaire pour que le µ-contrôleur fonctionne parfaitement, tout
simplement avec une batterie, un adaptateur ou le connecter directement à un microordinateur
avec un câble USB pour commencer.

Caractéristiques

La carte Arduino-Méga-2560 est caractérisée par :

 µ-contrôleur: ATmega-1280 ;
 Tension de Fonctionnement: 5 V ;
 Tension d'entrée: 7à12 V ;
 Tension d'entrée (Max) : 6à20 V ;
 Bornes E/S Numérique: 54 (dont 15 fournissent sortie P.W.M) ;
 Bornes d'entrées analogiques: 16 ;
 D.C Courant par I/O Pin: 40mA ;
 Courant pour Pin 3,3 V: 50mA ;
 Mémoire flash: 128Ko dont 4 Ko utilisés par boot-loader ;
 S.RAM: 8Ko ;
 EEPROM: 4Ko ;
 Fréquence d'horloge: 16MHz [3].

Figure 2.3: Carte Arduino

15
Chapitre 2 Choix du matériel

1.4. Différence entre les cartes programmables

Nous allons faire un tableau comparatif entre ces 3 types de carte et selon des critères
bien définies (tels que le prix, l’IDE et la programmation) nous allons choisir notre carte selon
le tableau ci-dessous :

Types de Raspberry Pi FPGA Arduino Méga 2560

cartes
Caractéristiques
Coût Couteuses (30€) Couteuses (400€) Moins couteuses (16 €)

Programmation Reprogrammable Reprogrammable Reprogrammable

Rapidité Rapide Très rapide Normal

Sécurité Non Oui Non
Séquentiel Non Non Oui
Concurrence Oui Oui Non
Source Open Source - Open Source

Développement Simple Compliqué Simple

Plateforme Linux Multiplateforme Multiplateforme

Langage Multi VHDL Semblable à C++
Tableau 2.1: Tableau comparatif des cartes programmables

 On trouve que la carte Raspberry Pi est du coût acceptable et sa rapidité et son

langage de programmation simplifie la manière de travailler facilement avec-elle, tout en
proposant quelques atouts pour les professeurs, les universitaires et les passionnés intrigué par
les autres systèmes :
Pour ces raisons on a conclu par notre décision sur la Raspberry Pi exactement sur la
Raspberry Pi 3 modèle B+.

2. Capteur de température
Pour conserver de la fraîcheur dans l’habitat, nous avons utilisé dans notre projet un sous-
système d’acquisition de température basé sur le capteur d’humidité et de température
DHT11. Le capteur DHT11 fournit une information numérique proportionnelle à la
température et l'humidité mesurée. Cette température acquise sera traitée par la carte
programmable d'une façon automatisée.

Figure 2.4: Capteur DHT11

16
Chapitre 2 Choix du matériel

Ce capteur d'humidité et de température est très rependu dans le contrôle d’aération, il est
constitué d’un capteur de température à base de thermistances NTC, d’un capteur d’humidité
résistif et un microcontrôleur qui s’occupe de faire les mesures, de les convertir et de les
transmettre.

Il s’interface grâce au protocole 1-Wire qui permet de transmettre et de recevoir des

données sur un seul fil [4], cette technologie utilisée par le capteur DHT11 garantie une grande
fiabilité, une excellente stabilité à long terme et un temps de réponse très rapide.

L'avantage de ce capteur est la combinaison de la mesure de la température et de

l'humidité dans un boîtier compact. Cependant, l'inconvénient est le faible taux
d'échantillonnage de la mesure, de sorte qu'un nouveau résultat de mesure est disponible
seulement toutes les 2 secondes. Ce capteur est donc très bon pour les mesures sur la durée. [5]

Caractéristiques techniques du DHT11

Ce capteur présente les caractéristiques suivantes [6]:

 Alimentation : 5V ;
 Consommation : 0.5 mA en nominal / 2.5 mA maximum ;
 Étendue de la mesure de température : 0°C à 50°C ± 2°C ;
 Étendue de la mesure de l’humidité : 20-90%RH ±5%RH ;
 Période de mesure: 2s ;
 Dimensions: 12 x 15.5 x 5.5mm.

Le DHT11 est composé d’un capteur et une petite résistance, il a 3 broches espacées de
2,45mm ce qui offre un moyen d’être connecté facilement sur une plaque d’essai.

Figure 2.5: Schéma de brochage de DHT11

17
Chapitre 2 Choix du matériel

Conclusion
Dans cette section nous avons évoqués plusieurs modèles de cartes programmables et
leurs caractéristiques dont l'objectif est de choisir la plus optimisée pour notre projet. Dans la
partie suivante du rapport nous mettrons en évidence les besoins de l'utilisateur et nous
décrirons l’analyse de ces besoins afin de clarifier plus les buts du projet et les analyser.

18
 Chapitre 3 : Conception

Introduction
Le modèle conceptuel de données est une représentation statique du système
d’information. Il a comme objectif de constituer une représentation claire et cohérente des
données manipulées dans le système d’information.

Cette section sera présentée comme suit : nous commençons par le choix de la
méthodologie de conception. Ensuite nous identifions les acteurs et les besoins fonctionnels et
non fonctionnels. A la fin nous présentons les diagrammes de cas d’utilisation, les
diagrammes de séquence et le diagramme de classe.

1. Langage de conception
Pour élaborer ce projet, nous devons établir une conception modeste pour atteindre le but
de notre projet pour cela nous devons choisir un langage de conception adéquat avec nos
besoins.

1.1. Langage UML

« UML » (en anglais Unified Modeling Language ou langage de modélisation unifié) est
un langage de modélisation graphique à base de pictogrammes. Il est apparu dans le monde de
génie logiciel, dans le cadre de la « conception orientée objet ». [1]

Couramment utilisé dans les projets logiciels, il peut être appliqué à toutes sortes de
systèmes ne se limitant pas au domaine informatique. [1]

Les 14 diagrammes UML sont indépendants hiérarchiquement et se complètent, de façon

à permettre la modélisation tout au long de cycle de vie de projet. Ces diagrammes sont :

 Diagrammes structurels ou statiques :

o Diagramme de classe ;
o Diagramme d’objets ;
o Diagramme de composants ;
o Diagramme de déploiement ;
o Diagramme de paquetages ;
o Diagramme de structure composite ;
o Diagramme de profils ;

 Digrammes comportementaux :
o Diagramme de cas d’utilisation ;
o Diagramme états-transitions ;
o Diagramme d’activité ;

 Diagrammes d’interaction ou dynamiques :

19
Chapitre 3 Conception

o Diagramme de séquence ;
o Diagramme de communication ;
o Diagramme global d’interaction ;
o Diagramme de temps. [1]

Pour se faire, il faut utiliser un outil de modélisation parmi ceux qui sont disponibles sur
le marché, nous avons choisi de travailler avec « StarUML ».

1.2. StarUML
StarUML est un logiciel de modélisation UML disponible en open source. Grâce à ce
logiciel, il sera possible de concevoir plusieurs types de diagrammes. Il est notamment
possible de créer des diagrammes de classes, d’objets, d’activités ou bien des séquences
compatibles avec le standard 2.0. StarUML est écrit en technologies web (HTML5, CSS,
JavaScript).[2]

Figure 3.1: StarUML

1.3. Utilisation de l’UML

L’UML est un langage formel et normalisé en matière de modélisation objet. Son
indépendance par rapport aux langages de programmation, son caractère polyvalent et sa
souplesse ont fait de lui un langage universel. En plus UML est essentiellement un support de
communication, il facilite la représentation et la compréhension de solution objet. Sa notation
graphique permet d’exprimer visuellement une solution objet, ce qui facilite la comparaison et
l’évaluation des solutions. L’aspect de la notation, limite l’ambiguïté et les incompréhensions.

2. Spécification des besoins

Cette étape sert à définir les besoins fonctionnels et non fonctionnels du système
d’adaptation automatique de climatisation.

2.1. Besoins fonctionnels

Les besoins fonctionnels sont des fonctionnalités ou des fonctions du produit que les
développeurs doivent implémenter pour permettre aux utilisateurs d’accomplir leurs tâches.
En général, ils décrivent le comportement du système dans des conditions spécifiques.[3]

20
Chapitre 3 Conception

Le système est principalement basé sur le suivi actuel en temps réel de la température et
de l’humidité à l’intérieur de l’habitat, répondant ainsi aux besoins de l’utilisateur afin de
conserver de la fraîcheur donc les principales fonctions du système sont décrites comme suit :

 Détecter le niveau de température et d’humidité de l’environnement : le capteur DHT11

aura la possibilité de prélever le niveau de l'humidité et de la température ;
 Traiter l’information : la carte Raspberry Pi aura la possibilité de traiter les informations
provenant du capteur DHT11, puis de procéder à la gestion de climatiseur ;
 Gérer le climatiseur : le disjoncteur aura la possibilité de gérer le climatiseur grâce aux
informations déjà traitées provenant de la carte Raspberry Pi, tel que l'humidité et la
température.
2.1.1. Perspective du système
Le système intégré est un système qui fournit la fonctionnalité de lecture des données
(température et humidité) de capteur. Ce système comprend principalement un capteur
DHT11 et une carte Raspberry Pi de traitement. Il s’interface également à un disjoncteur pour
gérer le climatiseur. L’objectif principal de ce projet est de fournir une structure de suivi des
conditions de l’environnement.

2.1.2. Besoins opérationnels

Pour que le système fonctionne correctement et efficacement, tout d’abord, le capteur
doit être correctement connecté. Ensuite, le code écrit dans le logiciel Raspbian OS doit être
téléversé dans le matériel avant d’exécuter le programme.

2.2. Besoins non fonctionnels

Les besoins non fonctionnels décrivent comment un système doit se comporter et
établissent les contraintes de sa fonctionnalité. Ce type d’exigences est également connu sous
le nom d’attributs de qualité du système. [3]

Le projet dévoile diverses obligations dans la phase de réalisation, nous y avons ci-contre
les besoins non fonctionnels :

 Apprentissage facile : Aucun pré requis n'est primordial pour l'usage de ce système parce
qu'elle sera claire dans l’utilisation ;
 Simplicité : Le système doit être facile à utiliser ;
 Maintenance : Le code source du programme sera bien précisé par des commentaires pour
que le suivi soit plus évident et rapide. Il sera même maintenable par des programmeurs
qui ne sont ceux d'origine ;
 Temps d’exécution rapide et efficace : Toute instruction à traiter ne dépassera pas un délai
de 3s.

21
Chapitre 3 Conception

3. Analyse des besoins

L’analyse des besoins vise à identifier les exigences du système et à faire le point sur
les éléments attendus. Il s’agit de contextualiser le projet et d’analyser les attentes pour
fournir un cadre au projet, en utilisant le langage UML afin de représenter les fonctions du
notre système.

3.1. Diagramme des cas d’utilisation global

Cette section a pour objectif de modéliser les besoins des utilisateurs, identifier les
grandes fonctionnalités et les limites du système ainsi représenter les interactions entre les
éléments du système. Nous débutons cette analyse par définir les acteurs qui agissent sur
notre système de climatisation.

Il existe quatre acteurs qui sont comme suit :

 Administrateur : c’est une personne physique, il gère le système de climatisation aussi il

configure le capteur DHT11 du système ;
 Le capteur DHT11 : c’est un objet, il capte et envoie les données telles que la température
et l’humidité à la carte Raspberry Pi ;
 La carte Raspberry Pi : c’est un objet, qui se charge de traitement des données reçus du
capteur ;
 Le disjoncteur : c’est un objet, il reçoit un signal provenant de la carte qui lui permet de
gérer le climatiseur (ON/OFF).

La figure 3.2 représente le diagramme des cas d’utilisation global du système.

Figure 3.2: Diagramme des cas d'utilisation global

22
Chapitre 3 Conception

3.1.1. Description textuelle des principaux cas d’utilisation

Les cas d’utilisation présentent certaines ambiguïtés doivent être complétés par une
description textuelle en présentant les points suivants :

 Titre : nom de cas d’utilisation ;

 Acteur : nom de(s) acteur(s) ;
 Objectif : le but de cas d’utilisation ;
 Pré-condition : condition(s) devant être remplie(s) pour exécuter le cas d’utilisation ;
 Post-condition : condition(s) nécessaire(s) pour que le cas d’utilisation soit considéré
comme achevé ;
 Scénario nominal : c’est le scénario qui indique les étapes pour réaliser les cas d’utilisation
(il n’inclut pas l’alternatives) : il peut également être remplacé par un diagramme de
séquence.

3.1.2. Cas d’utilisation « traiter l’information »

La figure 3.3 illustre le diagramme de cas d’utilisation « traiter l’information ».

Figure 3.3: Diagramme de cas d’utilisation « traiter l’information »

23
Chapitre 3 Conception

Titre Traiter l’information

Acteur La carte Raspberry Pi, le capteur DHT11 et le
disjoncteur.
Objectif La carte Raspberry Pi traite les informations reçus du
capteur DHT11.
Pré-condition Recevoir les données captées par le capteur DHT11.
Post-condition Envoyer un signal vers le disjoncteur pour commander le
climatiseur (ON/OFF).
Scénario nominal 1. La carte Raspberry PI reçoit les données relatives
à la température et à l’humidité.
2. La carte Raspberry Pi traite ces données en
exécutant le code qui est déjà écrit dans le logiciel
Raspbian OS et téléversé dans le processeur de la
carte.
Tableau 3.1: Tableau descriptif de cas d'utilisation " Traiter l'information "

3.2. Diagramme de séquence

Le diagramme de séquence est une représentation graphique des interactions entre les
acteurs du système selon un ordre chronologique. A travers ce diagramme, nous montrons
le déroulement de notre système d’une vue globale.
La figure 3.4 représente le diagramme de séquence de cas d'utilisation « traiter
l'information ».

Figure 3.4: Diagramme de séquence de cas d'utilisation « traiter l'information »

24
Chapitre 3 Conception

Le déroulement normal de « traiter l’information » est le suivant :

 La carte Raspberry Pi demande l’état de l’humidité et la température du capteur DHT11 ;

 Le capteur DHT11 détecte le niveau de l’humidité et la température ;
 Le capteur envoie les données captées à la carte Raspberry ;
 La carte traite l’information reçue et vérifie le temps et la température et envoie un signal
selon l’état de vérification.

La figure 3.5 représente le diagramme de séquence de cas d'utilisation « gérer le

climatiseur ».

Figure 3.5: Diagramme de séquence de cas d'utilisation « gérer le climatiseur »

3.3. Diagramme de classes

Le diagramme de classes est le diagramme le plus répandu dans les spécifications
UML. Il permet de définir quelles sont les composants du système final en mettant en
évidence les différentes classes d’un système et en modélisant les relations qui les
associent, les interactions et les hiérarchisations.

Le diagramme de classes standard est composé de trois sections :

 Section supérieure : contient le nom de la classe ;

 Section intermédiaire : contient les attributs de la classe, utilisée pour décrire les qualités
de la classe. Elle n’est nécessaire que lors de la description d’une instance spécifique d’une
classe ;

25
Chapitre 3 Conception

 Section inférieure : contient les opérations de la classe (méthodes), affichées sous forme de
liste. Chaque opération occupe sa propre ligne. Les opérations décrivent la manière dont
une classe interagit avec les données.

Figure 3.6: Diagramme de classe global

Conclusion
Ce chapitre a été consacré à différentes étapes de la conception détaillée. Du raffinement
du diagramme de cas d’utilisation, vers le diagramme de séquence de plusieurs cas
d’utilisations pour montrer les interactions entre les acteurs du système d’adaptation
automatique de climatisation. Finalement nous avons terminé avec le diagramme de classe
avec lequel nous avons présenté la structure de notre projet.

Le prochain chapitre contiendra des explications et des clarifications de plusieurs

concepts en rapport avec le contexte de notre travail.

26
 Chapitre 4 : Réalisation
Introduction
En détaillant ce chapitre, nous sommes déjà passé par les étapes nécessaires afin
d’entrainer la phase de réalisation. Le problème a été profondément analysé, nous avons
défini une conception complète à notre jugement. Une conception qui comporte et décrit tous
les besoins du projet.

Dans ce chapitre nous commencerons par la description de l’environnement de

développement (matériel et logiciel) ainsi que les différents outils utilisés. Ensuite, nous
présenterons les différents aspects de fonctionnement de notre commande automatique de
climatisation.

1. Environnement de travail
L’idée principale de ce projet était de réaliser un prototype de système puis de le
contrôler automatiquement. En conséquence, ce travail a été divisé en deux parties, une partie
matérielle et une autre logicielle. La réalisation nécessite divers concepts dans plusieurs
domaines : Électronique, informatique et système embarquée.

Dans cette partie nous allons présenter les différents matériels et logiciels que nous avons
utilisés pour réaliser le système de commande automatique de climatisation.

1.1. Environnement matériel

Depuis le début du projet et pendant les différentes phases du travail (documentation,
spécification, conception et réalisation) nous avons élaboré notre projet sur un micro-
ordinateur HP de caractéristiques suivantes :

 Système d’exploitation : Microsoft Windows 10 (64 bits) ;

 Mémoire RAM : 12 Go ;
 Processeur : Intel(R) Core (TM) i7-8565U CPU @ 1.80GHz 1.99 GHz;
 Carte Graphique : NVIDIA GeForce MX130.

1.2. Environnement logiciel

1.2.1. Plateformes logicielles
Les plateformes logicielles utilisées au cours de la réalisation du projet sont :

1.2.1.1. Win32 Disk Imager

Il s'agit d'un programme Windows permettant d'enregistrer et de restaurer des images à
partir de lecteurs amovibles (clés USB, cartes mémoire SD, etc.). Il peut être utilisé pour
écrire des images de démarrage (càd ubuntu-12.04-preinstalled-desktop-armhf+omap4.img)
27
Chapitre 4 Réalisation

sur un périphérique flash SD ou un périphérique flash USB, ce qui le rend amorçable. Les
exemples les plus récents sont les systèmes d'exploitation pour Raspberry Pi.[1]

Figure 4.1:Interface de Win32 Disk Imager

1.2.1.2. Raspbian OS
Raspberry Pi OS est un système d'exploitation libre et gratuit basé sur Debian optimisé
pour fonctionner sur les différents Raspberry Pi ;

De nombreux systèmes d'exploitation sont disponibles pour Raspberry Pi, y compris

Raspberry Pi OS. Raspberry Pi Imager est le moyen rapide et facile d'installer un système
d'exploitation sur une carte micro SD prête à l'emploi avec la Raspberry Pi;

Après le téléchargement de Raspbian os nous remplissons le champ « image file » par ce

système téléchargé dans le Win32 Disk Imager.

Figure 4.2: Ouvrir le système d'exploitation de Raspberry Pi

1.2.1.3. PuTTY
PuTTY est un émulateur de terminal doublé d'un client pour les protocoles SSH, Telnet,
rlogin, et TCP brut. Il permet également des connexions directes par liaison série RS-232. À
l'origine disponible uniquement pour Windows, il est à présent porté sur diverses plates-

28
Chapitre 4 Réalisation

formes Unix (et non-officiellement sur d'autres plates-formes). PuTTY est écrit et maintenu
principalement par Simon Tatham.
PuTTY est une application logicielle que vous pouvez exécuter à partir de votre
ordinateur de bureau ou portable pour accéder à l'interface de ligne de commande Raspberry
Pi. Il utilise SSH pour ouvrir une fenêtre de terminal sur votre ordinateur, que vous pouvez
utiliser pour envoyer des commandes au Raspberry Pi et recevoir des données de celui-ci. Il
existe d'autres programmes que vous pouvez utiliser pour accéder au terminal Raspberry Pi,
mais PuTTY est de loin le plus populaire.[2]
Pour pouvoir accéder à la carte Raspberry avec le PuTTY on doit vérifier que le pc et
le Raspberry Pi sont connectés au même réseau Wifi

Figure 4.3 : Interface de PuTTY

1.2.1.4. Isis Proteus

Isis-Proteus est un logiciel de simulation électronique. Il est l’outil idéal pour les
étudiants en électronique ou les entreprises spécialisées dans ce domaine. Il permet de vérifier
simplement le fonctionnement des schémas électroniques depuis notre ordinateur. Isis-Proteus
reste une référence, notamment grâce au grand nombre d’options qu’il propose, et la
possibilité de réaliser des documentations, ce qui en fait un outil particulièrement complet.

Le logiciel ISIS de Proteus est principalement connu pour éditer des schémas électriques.
Par ailleurs, le logiciel permet également de simuler ces schémas ce qui permet de déceler
certaines erreurs dès l'étape de conception. Indirectement, les circuits électriques conçus grâce
à ce logiciel peuvent être utilisé dans des documentations car le logiciel permet de contrôler la
majorité de l'aspect graphique des circuits.

29
Chapitre 4 Réalisation

1.2.2. Langage de programmation utilisé

1.2.2.1. Introduction à LINUX
Raspberry pi est Linux, ce qui signifie qu'il est bâti sur Linux. Le nom « Linux » est
employé pour décrire le noyau du système d'exploitation ainsi que le système d'exploitation
lui-même Le système d'exploitation Linux est composé du noyau et de milliers d'utilitaires et
d'applications émanant de différentes sources. [3]
Le Raspberry Pi n'est pas une station de travail, mais s'apparente plus en termes de
puissance à une tablette d’entrée de gamme ou à un téléphone mobile. Dans ces conditions,
même si vous utilisez le bureau graphique, ne comptez pas abandonner tout de suite votre
ordinateur de bureau ou votre portable. Une puissance minimale combinée à une mémoire
réduite empêche les applications comme LibreOffice et Mozilla Firefox d'être utilisables. [3]
1.2.2.2. Python
Le langage principal pour programmer sur Raspberry Pi est Python. Nous allons voir
comment mettre en place un environnement de programmation en Python sur la Raspberry Pi
dans la phase d’implémentation.

Qu’est-ce que Python ?

Figure 4.4 : Logo de python

Python est un puissant langage de programmation dynamique qui est utilisé dans
différents domaines (application, web, …) Il est souvent comparé à Perl, Ruby ou encore
Java.
Les principaux points forts de Python sont :
 Langage adapté aux débutants;
 Les grandes possibilités du langage. Il va aussi bien être adapté aux petits projets qu’aux
gros projets;
 Peut-être cross-platform;
 Stable, langage qui est assez vieux et qui a fait ses preuves;
 Simple à comprendre.[4]
1.2.2.3. Programmation des entrées / sorties avec python
Les broches marquées GPIO peuvent être utilisées comme broches d’entrée / sortie. En
d’autres termes, n’importe quelle broche peut être programmée comme une entrée ou une
sortie. Dans ce sens on va utiliser plusieurs langages de programmation capable de contrôler
ces broches comme le C, Java, Bash...ect mais dans notre projet on a opté pour le python pour
contrôler ces broches [5].

30
Chapitre 4 Réalisation

2. Phase d’implémentation
Cette phase est devisée en deux parties qui sont la configuration matérielle et puis la
configuration logicielle.

2.1. Configuration matérielle

2.1.1. Configuration de DHT11

Figure 4.5 : Circuit réalisé

Module DHT11 : un dispositif à 4 broches nécessitera une résistance (4,7K-10K) à placer

entre la broche 1 (3,3V) et la broche 2 (données).

Les modules à 3 broches auront généralement cette résistance incluse, ce qui facilite un
peu le câblage. Pour cette raison, nous avons mis la main sur le module que nous pouvions
ensuite attacher au Pi avec un morceau de câble Dupont à 3 voies.

Les 3 broches doivent être connectées au Pi comme indiqué dans le tableau ci-dessous :

DHT Pin Signal Pi Pin

1 3.3V 1
2 Data/Out 11 (GPIO17)
3 not used –
4 Ground 6 or 9
Tableau 4.1 Pin de branchement

Figure 4.6 : Branchement du capteur avec la carte Raspberry

31
Chapitre 4 Réalisation

La carte Raspberry Pi délivre sur ses sorties un signal tout ou rien 0V/3,3VDC. Les
fonctions à commander sont alimenté en 230VAC. Il est nécessaire de produire une interface
pour commuter l'énergie. On utilisera un relais modulaire associé à un circuit de commande
(transistor, relais statique,…).

2.1.2. Configuration de relais

Le relais joue le rôle d’un interrupteur commandé. Un relais électromécanique est doté
d’un bobinage en guise d’organe de commande. La tension appliquée à ce bobinage va créer
un courant, ce courant produisant un champ électromagnétique à l’extrémité de la bobine
(électro-aimant). Ce champ magnétique va être capable de faire déplacer un élément
mécanique métallique monté sur un axe mobile, qui déplacera alors des contacts électriques.

On veillera à adapter la commande du relai modulaire en fonction du type de tension

attendu par sa bobine. Il serait souhaitable d’intégrer l’alimentation de la bobine du relai dans
le tableau électrique (alimentation modulaire).

Le relais utilisé dans notre projet est le suivant :

Figure 4.7 : Relais

Les principales caractéristiques techniques du relais utilisé dans notre projet sont :

 Signal de commande 5V ;
 Maximum AC courant et voltage : 10A 250VAC ;
 Maximum DC courant et voltage: 10A 30VDC ;
 Il existe un contact normalement ouvert et un contact normalement fermé ;
 Pour que la bobine du relais soit excitée, vous devez avoir une entrée de 0 dans la broche
de signal.

32
Chapitre 4 Réalisation

Brochage du relai doit être comme ça :

+ : 5V source ;

- : Masse ;

S : Signale de commande en 3.3V (dans notre cas) ;

NC : normalement fermé ;

NO : normalement ouvert.

Le montage complet pour vérifier le signal de commande délivré par le relais en utilisant
des LED sera le suivant : (le circuit de commande devra-t-être dimensionné, simuler, puis
tester. Le logiciel de simulation à utiliser est Isis Proteus).

Figure 4.8 : circuit de vérification de signal de commande

Lorsque le relais est au repos, la LED D1 est allumée

Figure 4.9 : Relais au repos

Tandis que le LED D2 est allumée lorsque le relais est actif :

33
Chapitre 4 Réalisation

Figure 4.10 : Relais allumé

2.2. Configuration logicielle

Connecter la Raspberry Pi et le PC sur le même point d’accès pour pouvoir utiliser
PuTTY.

Figure 4.11 : Point d'accès utilisé

Après avoir accéder à la carte Raspberry Pi, nous commencons par la mise à jour des
listes de paquets et installation de quelques bibliothèques nécessaires:

Python :

Clonage de la librairie Adafruit depuis leur dépôt :

34
Chapitre 4 Réalisation

Installation des librairies Python 2 et Python 3 :

Installation de la bibliothèque CircuitPython DHT :

Installation de la librairie Adafruit_Python_DHT de la société Adafruit pour faire

fonctionner le capteur, elle est téléchargeable Librairie python sous licence MIT.

Par la suite, nous écrivons un script python qui permet de vérifier certaines conditions tel
que le temps et le degré de température toutes les 2 secondes et de faire envoyer un signal
vers une Pin de sortie de la carte Raspberry Pi.

L’exécution de script en utilisant cette commande :

Avec 11 et 17 sont respectivement le numéro de Pin Out et le numéro de GPIO.

Figure 4.12 : Résultat obtenu du 1er script

35
Chapitre 4 Réalisation

La dernière étape est de connecter la Pin out de la carte programmable au disjoncteur qui
va gérer le climatiseur (ON/OFF). Le problème ici est que le signal délivré par la carte est de
très faible tension 3.3 V, la solution est donc de faire brancher un relais de 8 modules qui peut
émettre un signal qui est capable de commander le climatiseur de tension qui varie entre 120
et 220 V.

Pour tester le signal de commande issu de la carte raspberry Pi et qui est amplifié par un
relais qui permet de délivrer un signal de 5 v, on écrit un script qui permet de vérifier le
fonctionnement de relais en utilisant deux LEDs.

L’exécution de ce script donne le résultat suivant :

Figure 4.13 : Résultat obtenu du 2eme script

Conclusion
Dans ce chapitre nous avons réalisé le circuit et le programme de teste pour notre projet
en décrivant par détails les étapes réalisées pour avoir le résultat désiré.

36
 Conclusion générale

L’objectif de ce travail est de réaliser un prototype hardware d’une commande

automatique de climatisation, et implémenter un algorithme de contrôle ON-OFF de
température, c’est-à-dire un système capable d’atteindre et de maintenir une consigne donnée
par un capteur. Ce projet nous a permis d’une part d’améliorer nos connaissances
scientifiques, que ce soit du côté de programmation et apprentissage de nouveaux langages,
en l’occurrence Python, ou du côté réalisation matérielle autour des systèmes à
microprocesseur, dans notre cas, on a utilisé un Raspberry Pi 3 B+. Le projet final, résulte en
une interface de l’application créée, pour faire le monitoring de la température de la maison et
de l’humidité en temps réel via un capteur DHT11, et ainsi régler le climatiseur pour garder
une consigne de température.

Perspectives :

Un travail pareil reste comme une plateforme, à partir de laquelle on peut développer,
dans plusieurs sens et divers domaines, pour améliorer cette première génération. Quelques
idées sont citées :

- Implémenter sur le Raspberry Pi des algorithmes de commande optimale, tel que la

commande prédictive.

- Développer plus la plateforme en utilisant des outils plus développés comme le

Framework DJANGO, avec la base de données MySQL…etc.

- Une autre extension serait d’entamer la commande d’un réseau de capteurs dans une
application de maison intelligente.

37
 Bibliographie et webographie
Chapitre 1 :

[1]https://www2.stardust-testing.com/blog-fr/linternet-des-objets-au-service-de-
lexp%C3%A9rience-client consulter le 21/12/2021

[2]https://domotique.ooreka.fr/astuce/voir/668935/internet-des-objets consulter le 21/12/2021

[3]https://www.technologuepro.com/cours-systemes-embarques/cours-systemes-embarques-
introduction.htm consulter le 22/12/2021

[4]https://www.techno-science.net/glossaire-definition/Systeme-embarque.html consulter le
22/12/2021

[5] Cédric Locqueneux. le guide de la maison et des objets connectées (Domotique, smart
home et maison connectée) consulter le 24/12/2021

Chapitre 2 :

[1]https://www.generationrobots.com/fr/402366-raspberry-pi-3-modele-b.html consulter le
19/12/2021

[2]http://proxacutor.free.fr/ consulter le 06/01/2022

[3]https://www.gotronic.fr/art-carte-arduino-mega-2560-12421.htm consulter le 18/12/2021

[4]https://github.com/openremote/Documentation/wiki/1-Wire consulter le 07/01/2022

[5]Karvinen, Kimmo Karvinen, Tero_Maniez, Dominique_Valtokari, Ville Les capteurs pour

Arduino et Raspberry Pi tutoriels et projets Dunod consulter le 07/01/2022

[6] https://www.gotronic.fr/artcapteur-de-t-et-d-humidite-dht11-20692.htm consulter le

07/01/2022

Chapitre 3 :

[1]https://fr-academic.com/dic.nsf/frwiki/1679488 consulter le 19/12/2021

[2]https://manurnx.wp.imt.fr/2017/01/23/choix-d-un-outil-de-modelisation-uml/ consulter le
23/12/2021

[3]https://www.altexsoft.com/blog/business/functional-and-non-functional-requirements-
specification-and-types/ consulter le 23/12/2021

Ancien rapport

Chapitre 4 :

[1]https://wiki.ubuntu.com/Win32DiskImager consulter le 25/12/2021

38
[2]https://www.circuitbasics.com/use-putty-to-access-the-raspberry-pi-terminal-from-a-
computer/ consulter le 26/12/2021

[3] Tero karvinen, Kimmo Karvinen, Ville Valtokari , Les Capteurs pour Arduino et
Raspberry Pi Tutoriels et projets consulter le 25/12/2021

[4]https://www.raspberrypi-france.fr/guide/raspian-programmer-python/ consulter le
25/12/2021

[5] Baghdadli Chahrazed et Ferouani Zineb « Développement d’une Application déployée sur
un réseau de capteur sans fil supportant 6LoWPAN », Master, Université Abou Bakr
BelkaidTlemcen, consulter le 25/12/2021

39
 ANNEXE

Annexe 1 : Brochage de la carte Raspberry Pi 3 B+

Annexe 2 : Datasheet DHT11

40
 Annexe 3 : Datasheet d’une LED

Annexe 4 : code de script 1 :

import sys
import time
import datetime
import Adafruit DHT
from signal import signal, SIGINT
sensor_args = { '11': Adafruit DHT. DHT11,
'22': Adafruit_DHT. DHT22,
‘2302’: Adafruit_DHT.AM2302)
if len (sys.argv) == 3 and sys.argv[1] in sensor_args:
sensor = sensor_args [sys.argv[1]]
pin= sys.argv[2]
else:
print ('Usage: sudo/Adafruit_DHT.py [1112212302] <GPIO pin number>')
print("Example: sudo ./Adafruit DHT.py 2302 4 - Read from an AM2302 connected to GPIO
pin #4')
sys.exit (1)
#Try to grab a sensor reading. Use the read_retry method which will retry up
# to 15 times to get a sensor reading (waiting 2 seconds between each retry).
humidity, temperature = Adafruit_DHT.read_retry (sensor, pin)
# Un-comment the line below to convert the temperature to Fahrenheit.
# temperature temperature 9/5.0 + 32 # Note that sometimes you won't get a reading and # the
results will be null (because Linux can't
# guarantee the timing of calls to read the sensor).
# If this happens try again!
now datetime.datetime.now().time()
while temperature > 8
if now.hour > 8: if humidity is not None and temperature is not None:
print('Temp=(0:0.1f)* Humidity=(1:0.1f).format(temperature, humidity))
gpio.output (4, gpio.HIGH)
time.sleep (2.0)
else:
print ('Failed to get reading. Try again!')
time.sleep (2.0)
sys.exit(1)
41
  import board cette bibliothèque sera utilisée pour définir avec quelle broche
GPIO nous avons connecté le capteur DHT11.
 import adafruit_dht bibliothèque spécifique au capteur DHT, repéré à
https://github.com/adafruit/Adafruit_Python _DHT
 time.sleep(2.0) : attendre 2 secondes.

Annexe 5 : code de script 2 :

#!/usr/bin/env python
import RPi.GPIO as GPIO
import time
RelayPin = 17 # pin17
def setup():
GPIO.setmode(GPIO.BCM)
GPIO.setup(RelayPin, GPIO.OUT)
GPIO.output(RelayPin, GPIO.HIGH)
def loop():
while True:
print '...relay on'
GPIO.output(RelayPin, GPIO.LOW)
time.sleep(2)
print 'relay off...'
GPIO.output(RelayPin, GPIO.HIGH)
time.sleep(2)
def destroy():
GPIO.output(RelayPin, GPIO.HIGH)
GPIO.cleanup()
if _name_ == '_main_': # Program start from here
setup()
try:
loop()
except KeyboardInterrupt: # Arret 'Ctrl+C'
destroy()

42
 Résumé
Le sujet de ce mini-projet est la mise en place d’un système de contrôle à distance de
climatisation, qui utilise de la discipline : internet des objets (Internet of Things), pour
automatiser la fonctionnalité d'un climatiseur.

Le cœur de ce système est une carte Raspberry Pi, elle fonctionne comme un élément central
responsable de l’intelligence et la prise de décision pour contrôler le climatiseur. L’autre
nœud est chargé d’acquérir des lectures sur la température et l’humidité.

Ce rapport est une description détaillée des travaux réalisés tout en citant les notions de base
de ce domaine.

Mots clés : Carte Raspberry Pi, Capteur DHT11, contrôle des paramètres
climatiques, IoT, système embarqué.

Abstract
The purpose of this project is to implement a remote control system for an air conditioner
that is going to use Internet of Things (IoT) field, to automate the functionality of an air
conditioner.

The core of this system is a Raspberry Pi board, it works as a central element responsible
for intelligence and decision making to control the air conditioner. The other node is
responsible for acquiring temperature and humidity measurements.

This report is a detailed description of the accomplished work while citing the basic
notions of this field.

Keywords: Raspberry Pi board, DHT11 sensor, control of climate parameters, IoT,

embedded system.