Vous êtes sur la page 1sur 61

Projet de fin d’année

Filière : Génie Electronique « IE4 »


Département de physique

Réalisation d’une maison


Intelligente

Réalisé par :
FRADI LOUEI MANAA CHIHEB EDDINE

Encadré par :

M. GAMMOUDI CHOKRI
Mme IBTISSEM MALOUCHE

Année universitaire : 2020 /2021


[Réalisation d’une maison intelligente]

Dédicace
A nos chers parents
Pour leur soutien, leur patience, leur sacrifice
Et leur amour, vous méritez tout éloge,
Vous qui avez fait de nous ce que nous sommes maintenant.
Nous espérons être comme vous l'avez souhaité.
Que dieu vous garde et vous bénisse.

Nous dédions aussi ce travail à nos chers frères et sœurs, Pour


leurs affections et leur encouragement
Qui ont toujours été pour nous des Plus précieux.
A ceux qui ont sacrifié, patienté, donné tout pour continuer
leurs études.
À tous mes amis à tous ce qui nous a aidés.
A tous ceux que nous aimons nous dédions ce travail.

1
[Réalisation d’une maison intelligente]

Remerciements
En tout premier lieu, je remercie le bon Dieu, tout
puissant, de m’avoir donné la force et l’audace
pour dépasser les difficultés.

Je souhaite rendre hommage à tous ceux qui ont


contribué à la réalisation de ce travail.

Je tiens, avant tout, à adresser mes plus vifs


remerciements à Madame MALOUCHE IBTISSEME
et Monsieur GAMMOUDI CHOKRI nos encadrants
à la faculté des sciences de Tunis pour
l’encadrement

Ainsi qu’à mes enseignants de l’a FST à qui je dois ma


formation.

Enfin, j’adresse mes remerciements aux membres du jury


pour m’avoir honoré en acceptant d’évaluer ce travail.

2
[Réalisation d’une maison intelligente]

Table des matières


RESUME................................................................................................................................... 5
INTRODUCTION GENERALE .............................................................................................. 6
CHAPITRE 1 : LA DOMOTIQUE .......................................................................................... 7
I. Introduction de la domotique : ......................................................................................... 8
II. Définition de la domotique : ......................................................................................... 8
III. Que peut-on faire grâce à la domotique ? ..................................................................... 9
1. Le confort :...................................................................................................................... 9
2. Les économies d’énergie : .............................................................................................. 9
3. Communication :........................................................................................................... 10
4. La sécurité : ................................................................................................................... 10
IV. Combien coute la domotique ? .................................................................................... 10
V. But du projet : .................................................................................................................. 12
CHAPITRE 2 : ........................................................................................................................ 13
ETUDE Théorique .................................................................................................................. 13
I. Introduction : .................................................................................................................. 14
II. Matériels : ................................................................................................................... 14
1. ESP32 :.......................................................................................................................... 14
2. Servomoteur : ................................................................................................................ 16
3. Capteur humidité & température DHT11 : ................................................................... 18
4. Capteur de gaz MQ2 : ................................................................................................... 20
5. Ecran LCD avec un I2C :.............................................................................................. 21
6. Buzzer : ......................................................................................................................... 22
III. Logiciels : ....................................................................................................................... 23
1.IDE de l’ARDUINO : .................................................................................................... 23
2.Android Studio :............................................................................................................. 27
3.FireBase : ....................................................................................................................... 28
CHAPITRE 3 : CONCEPTION ET REALISATION DU PROJET ...................................... 27
I. Introduction : .................................................................................................................. 28
II. Réalisation de la maquette : ........................................................................................ 28

3
[Réalisation d’une maison intelligente]

1. Structure de la maquette : ............................................................................................. 28


2. Périphériques utilisées et leurs positions : .................................................................... 29
III. Automatisation de la maison : ..................................................................................... 29
1. Capteur d’humidité : ..................................................................................................... 29
2. Capteur de flamme / de gaz : ........................................................................................ 30
3. Servomoteur: ................................................................................................................. 30
IV. Centralisation des commandes : .................................................................................... 31
Conclusion Générale : ............................................................................................................. 35
Annexes et Programmes.......................................................................................................... 36

4
[Réalisation d’une maison intelligente]

RESUME

La domotique est l’ensemble des objets connectés qui rendant la maison elle-
même connectée, ou communicante. On parle même parfois de maison
intelligente, les différents objets connectés permettant à la maison de réagir
automatiquement en fonction d’événements (Ouvrir/fermer les portes,
allumée/éteindre la lumière à distance lors d’une absence imprévue...).
Dans le cadre de notre projet de fin d’année en Electronique nous avons choisi
de travailler sur la création d’un système domotique sans fil.

L’objectif est de créer ce système à l’aide d’ESP32 et de petits systèmes


embarqués à base de microprocesseur pour permettre une production low-cost,
reproductible chez soi et modifiable à souhait, tout ça avec un budget
convenable.

Ce projet ce découpe en deux parties faisant appel à nos compétences en


Informatique et en Electronique. La première se focalise sur la construction
d’une maquette avec les modules utilisés (Capteur, Module WIFI intégré...) et la
deuxième sur la création et l’implémentation du système et le rendre
commandable via un smartphone.

Dans un premier temps, nous expliquerons la domotique brièvement. Dans un


second temps, nous préciserons tous les modules utilisés ainsi les logiciels
nécessaires. Enfin, nous terminerons sur la création d'une maquette de maison
connectée et le déplacement des modules en commandent tout ça grâce à
application mobile.

5
[Réalisation d’une maison intelligente]

INTRODUCTION GENERALE

La pensée à la technologie de télécommunication, nous ramène immédiatement


à l’esprit les techniques de la communication vocale, l’envoi et la réception des
SMS, l’internet, et tout ce qui fonctionne en utilisant cette technologie moderne
introduite dans notre vie quotidienne.

Cette technologie bouleverse notre mode de vie, pourtant nos maisons


continuent d’être conçues comme il y a trente ans, sans tenir compte de ces
évolutions, comme si l’endroit où nous passons plus de la moitié de notre temps
n’en valait pas la peine, l’électronique n’y a pas sa place.

Qui accepterait d’acheter une voiture neuve qui obligerait à fermer à clé une à
une toutes les portières ou à actionner les vitres manuellement ? Qui voudrait
d’un véhicule dépourvu de système de sécurisation des passagers ? Ce que nous
refusons pour nos voitures, nous semblons l’accepter pour nos maisons.

Nos maisons sont dépourvues de système de sécurité, le taux de cambriolage des


habitants est élevé. Le nombre de victime de gaz est important, c’est là où la
Dominique fait surface pour trouver des solutions à ces problèmes.

Notre but à Travers ce projet de la Maison Intelligente est de permettre d’évaluer


l’apport de la domotique dans la gestion d’énergie et l’optimisation du confort
dans l’habitat.

Le but principal séide dans la possibilité de réaliser une pièce domotique avec des
modules simples, modifiable à souhait et à la portée de tout le monde.

6
[Réalisation d’une maison intelligente]

CHAPITRE 1 : LA DOMOTIQUE

7
[Réalisation d’une maison intelligente]

I. Introduction de la domotique :

La gestion centralisée des équipements techniques et multimédia d’un logement

La Domotique désigne la gestion centralisée des équipements techniques


(chauffage, sécurité, éclairage, volet roulant, etc.) et du multimédia dans le
résidentiel. Elle vise à apporter des fonctions de confort, de sécurité, d’économie
d’énergie et de communication aux maisons ou appartements équipés.
Le terme Smart Home est de plus en plus utilisé. Il a deux définitions. Il peut
s’agir simplement de la traduction anglophone de la domotique. D’autres lui
donne une portée supplémentaire, le logement devient intelligent. Cette
intelligence se caractérise par des objets et des services connectés qui viennent
s’ajouter aux équipements techniques gérés par la domotique.
Les scénarios envisagés peuvent ainsi dépasser la mise en relation de capteurs et
d’actionneurs du logement. Ils s’ouvrent d’avantage au monde de l’Internet des
Objets, de l’informatique ubiquitaire ou à l’Intelligence ambiante. Ils permettent
de mettre en relation des services extérieurs avec les objets du logement et ses
occupants.

II. Définition de la domotique :

La domotique est l’ensemble des techniques de l’électronique, de physique du


bâtiment, d’automatisme, de l’informatique et des télécommunications utilisées
dans les bâtiments et permettant de centraliser le contrôle des différents systèmes
et sous-systèmes de la maison et de l’entreprise (chauffage, volets roulants, porte
de garage, portail d’entrée, prises électriques, etc.). La domotique vise à apporter
des solutions techniques pour répondre aux besoins de confort (gestion d’énergie,
optimisation de l’éclairage et du chauffage), de sécurité (alarme) et de
communication (commandes à distance, signaux visuels ou sonores, etc.) que l’on
peut retrouver dans les maisons, les hôtels, les lieux publics, etc.

8
[Réalisation d’une maison intelligente]

III. Que peut-on faire grâce à la domotique ?

On peut dire que la domotique trouve sa place dans trois domaines principaux en
particulier.

1. Le confort :
Bien sûr, le fait d’automatiser sa maison a un véritable apport sur le confort
qu’on y trouve. Plus besoin de se prendre une averse pour ouvrir le portail en
rentrant à la maison, plus besoin de prendre froid en ouvrant les volets le matin,
et fini les retours de week-end dans une maison toute froide.
Aujourd’hui, une maison intelligente est capable de savoir quand vous rentrez à
la maison (grâce à votre smartphone par exemple), et donc d’ouvrir le portail avant
même que vous n’arriviez. Les volets peuvent s’ouvrir et se fermer au rythme du
soleil, et peuvent même aller jusqu’à s’adapter à la saison et la température pour
laisser entrer la lumière et la chaleur du soleil l’hiver, ou au contraire conserver le
frais l’été en fermant les volets des fenêtres exposées au soleil. De la même façon,
votre maison sait quand vous êtes présent, et peut ainsi adapter elle-même votre
chauffage pour que la maison soit toujours à la température idéale pour vous. Il
est même possible de diffuser automatiquement votre Play List musicale préférée
à votre réveil, ou quand vous rentrez à la maison. Pendant ce temps, un robot peut
passer l’aspirateur dans la maison à votre place, et le système d’arrosage
automatique arrosera votre jardin, tout en tenant compte des prévisions météo des
prochains jours, histoire de ne pas arroser inutilement.

2. Les économies d’énergie :


En gérant les volets selon la saison, ainsi que le chauffage, le système
domotique vous permet d’économiser de l’énergie, et donc de l’argent, même si
au départ on ne recherchait que le confort en plus. La consommation d’énergie
peut être suivie très finement, qu’il s’agisse de votre consommation d’électricité,
d’eau, ou même de gaz.
Vous partez de la maison ? Le simple fait d’activer l’alarme en partant va passer
le chauffage en mode éco, et éteindre toutes les lampes et les appareils restés en
veille, réduisant ainsi votre consommation d’énergie en votre absence. Et ceci
sans aucune action de votre part. C’est cela la maison intelligente !

9
[Réalisation d’une maison intelligente]

3. Communication :
Un système domotique permet la communication non seulement à l’intérieur de
la maison, mais aussi à l’extérieur. La technologie Internet interviendra de plus en
plus pour la commande à distance par La certains utilisateurs. Vous ne devez
même pas être à la maison pour commander vos appareils. Un simple coup de fil
ou un sms vous permettra par exemple de régler le chauffage à distance, d’activer
une simulation de présence ou de lancer le lave-vaisselle ou le lave-linge.
Pratique, non ?
4. La sécurité :
Les automatismes que nous avons vus plus haut peuvent tout à fait contribuer à
la sécurité de vos biens, en réalisant ce qu’on appelle une simulation de présence
: même en votre absence, les volets continuent de s’ouvrir, de la musique peut être
diffusée dans la maison, et des lumières allumées aléatoirement. Ainsi, de
l’extérieur, il devient très difficile de savoir si la maison est inoccupée, ce qui
dissuade de nombreux cambrioleurs.
Une détection de fuite d’eau peut couper automatiquement l’arrivée d’eau afin
d’éviter de gros dégâts.
Mais la sécurité, c’est également la sécurité des personnes : en cas de détection
d’incendie, par exemple, il est tout à fait possible d’ouvrir automatiquement les
volets, déverrouiller les portes, et éclairer le chemin de la sortie pour faciliter
l’évacuation. Exemple d’une mise en scène d’un « simple » détecteur de fumée,
couplé à un système domotique.
Dans le cas de personnes dépendantes, telles que des seniors ou des personnes
à mobilité réduite, il est également possible par exemple de prévenir un proche ou
les services de secours en cas de chute ou tout évènement anormal.

IV. Combien coute la domotique ?

Pour les marques connus dans le domaine des maisons connectées, l’installation
domotique ça commence par un budget de 10000€ au minimum.
Après une recherche sur internet on a trouvé des chercheurs dans ce domaine qui
font des efforts pour la réalisation des maisons intelligentes avec un budget moins
cher.

10
[Réalisation d’une maison intelligente]

Exemple :<< Extrait d’un ouvrage >>


Pour commencer il faudra un box domotique pour piloter la maison. On trouve
des box allant de 150 à 600€ environ, en restant dans le « grand public », car il y
a beaucoup plus cher. Disons que pour 200€ on trouve des box très corrects, le
prix n’étant pas spécialement un gage de qualité.

Fig.1 : La Vera Edge, de Vera Control LTD, bien que petite, est très complète et ne coute que
190€.

Ensuite, le budget va surtout dépendre du nombre de périphériques qu’on va


mettre en place, et de la technologie utilisée, certaines étant plus couteuses que
d’autres.

Pour récapituler:

• Box domotique: 200€


• Gestion des volets: 200€
• Gestion du chauffage: 200€
• Gestion de l’éclairage: 500€
• Gestion des appareils: 250€
• Sécurité: 550€

Soit un total de 1900€


Remarque :
Enfin, le prix des périphériques cité ici est une moyenne, il est possible de
trouver moins cher. Bref, tout ça pour vous dire que même 1900€, dans le type
d’installation domotique dont nous parlons dans notre projet, est aussi un budget
qui est chère quand même, mais il est tout à fait possible de commencer avec
budget moins chère tout en ayant des fonctions déjà intéressantes, qu’on pourra
faire évoluer plus tard, et c’est le gros avantage des solutions sans fil.

11
[Réalisation d’une maison intelligente]

V. But du projet :

Notre projet a pour but de créer un système à l’aide d’ESP32 pour réaliser une
maison connecté grâce à des modules moins chère par rapport à ce qu’on a vu au-
dessus aussi par rapport au prix que l’on peut voir présenter à la TV par exemple
(publication des marques de la domotique [Home Auto, Samsung, IAM et
Orange…]), et plus simple qui sont disponible partout avec des prix convenables.
Partie financière :
Pour notre projet le budget dépendre du nombre de périphériques qu’on a utilisés.

Modules Nombres Prix


Unitaire
Capteur de Moisture X1 15 DT
Capteur de gaz MQ2 X1 9DT
Capteur de flamme X1 9DT
Capteur d’humidité X1 15DT
ESP32 X1 35DT
Servomoteur 9g X2 10DT
LCD 16*2 I2C X1 15 DT
LED X4 0.2DT
Buzzer X1 1.5 DT
Tableau 1 : Les périphériques utilisés et leurs prix

Soit un total un peu prés de : 120 DT

12
[Réalisation d’une maison intelligente]

CHAPITRE 2 :
ETUDE Théorique

13
[Réalisation d’une maison intelligente]

I. Introduction :

Comment faire des montages électroniques, simplement, en utilisant un langage de


programmation ? La réponse, c’est le projet.

ESP32 qui l’apporte, celui-ci a été conçu pour être accessible à tous par sa simplicité. Mais il
peut également être d’usage professionnel, tant les possibilités d’application sont nombreuses.
Ces cartes polyvalentes sont donc parfaites pour nous, débutants, qui ne demandent
qu’apprendre et progresser. Grace a cette carte Ces fonctions sont réalisées par des capteurs,
des actionneurs, des automates et plus généralement par des équipements électriques et/ou
électroniques. Elle permet de contrôler son logement en local ou à distance depuis un ordinateur,
un téléphone, une tablette tactile ou une télévision.

II. Matériels :
1. ESP32 :

Fig.2 : ESP32

L'ESP32 est un SOC développé par la société Espressif dédié à l'internet des objets (IoT) et plus
particulièrement les communications sans fil Wifi et Bluetooth pour un coût réduit. Il a été décliné
en version module l'ESP-WROOM-32 qui a lui-même été intégré par différents fabricants
(Essentiellement Chinois) sur des cartes de développement.

Il présente plusieurs intérêts :

▪ Prix faible ~5€ pour le module ~8€ pour une petite carte de développement
▪ Intègre du Wi-Fi 802.11 b/g/n/e/i (WPA)/WPA2/WPA2-Enterprise/Wi-Fi Protected Setup (WPS)
▪ Intègre Bluetooth 4.2 - BLE Bluetooth low Energy
▪ Compatible avec l'environnement de développement ARDUINO
▪ Intègre un microcontrôleur 32 bits performants et de nombreux périphériques (ADC 12bit, DAC,
3xUART, PWM, I2C, SPI, etc. …)
▪ S'alimente directement en USB
▪ etc.

14
[Réalisation d’une maison intelligente]

Caractéristiques techniques de l’Esp32 :

Les ESP32 comprennent notamment les caractéristiques techniques suivantes :


• Processeurs :
o CPU : Xtensa double-cœur (ou simple-cœur), microprocesseur LX 32 bits,
fonctionnant à 160 ou 240 MHz et fournissant jusqu’à 600 DMIPS ;
o coprocesseur ultra basse consommation (ULP) ;
• Mémoire : 520 KiO SRAM ;
• Connectivité sans-fil :
o Wi-Fi : 802.11 b/g/n ;
o Bluetooth: v 4.2 BR/EDR and BLE jusqu’à v 5.0 et v 5.1.
• Interfaces de périphériques :
o 12-bit Segmentation sur les DAC (SAR ADC) jusqu’à 18 canaux ;
o 2 × 8 bit DAC ;
o 10 × capteurs de touché (GPIO de capteur capacitif (en)) ;
o 4 × SPI ;
o 2 × interfaces I²S ;
o 2 × interfaces I²C ;
o 3 × UART ;
o contrôleur hôte SD/SDIO/CE-ATA (en)/MMC/eMMC ;
o contrôleur esclave SDIO/SPI ;
o interface MAC Ethernet avec DMA dédié et support du protocole de temps précis
IEEE 1588 ;
o Bus de données CAN 2.0 ;
o contrôleur infrarouge distant (TX/RX, jusqu’à 8 canaux) ;
o Moteur PWM ;
o LED PWM (jusqu’à 16 canaux) ;
o Capteur à effet Hall ;
o Préamplificateur analogique ultra-basse consommation ;
• Sécurité :
o Standard de sécurité supportant complétement IEEE 802.11, incluant WPA/WPA2
et WAPI de WFA ;
o Secure boot (démarrage sécurisé) ;
o Chiffrement de la Flash ;
o 1024-bit OTP, jusqu’à 768 bit pour les clients ;
o Accélération matérielle du chiffrement : AES, SHA-2, RSA, elliptic curve
cryptography (ECC), générateur de nombre aléatoire (en) (RNG) ;
• Gestion de l’énergie :
o low-dropout regulator (en) interne.
o Domaines d’alimentation individuels pour le RTC
o Alimentation en sommeil profond de 5 μA ;
o Réveil depuis des interruption GPIO, timer, mesure ADC, interruption du capteur de
touché capacitif.

15
[Réalisation d’une maison intelligente]

Schémas fonctionnels de l’esp32 :

2. Servomoteur :

Fig.3 : Servomoteur 9g

16
[Réalisation d’une maison intelligente]

Description :
Servomoteur miniature économique. Livré avec palonniers, visserie et connecteur JR.

• Alimentation: 4,8 à 6 Vcc


• Course: 2 x 60°
• Couple: 1,6 kg.cm à 4,8 Vcc
• Vitesse: 0,12 s/60°
• Dimensions: 24 x 13 x 29 mm

Présentation:

Le moteur produit un déplacement angulaire qui s’étend de -45° à +45°. Le servomoteur est
utilisé en modélisme afin de produire les mouvements nécessaires aux déplacements des
oranges de direction. Il est commandé par l’intermédiaire d’un récepteur radio. Cette
particularité justifie les principes de commande dont nous allons parler ci-dessous.

Nous allons nous intéresser au principe de commande puis au principe de production de


déplacement angulaire.

Fig.4 : déplacement angulaire allant de -45° à +45°

Le corps contient un moteur à courant continu, un réducteur et une électronique de


commande.

La roue possède une série de trous, elle permet la transmission du mouvement par une
tringlerie.

Principe de commande :

Il s'agit de commander un déplacement angulaire allant de –45° à +45°.

Le moteur doit donc être capable de tourner dans les deux sens de rotation et de suivre les
consignes de position avec la contrainte supplémentaire d'avoir un déplacement proportionnel
à la commande. La capacité de suivre une consigne est obtenue par des techniques regroupées
sous le terme d'asservissement.

Un des moyens possibles est d'utiliser une tension variant de –9V à +9V ce qui permet de
déterminer le sens et l'angle de rotation. Cette technique est possible avec une commande filaire
mais trop compliquée pour une transmission des informations par radio.

17
[Réalisation d’une maison intelligente]

L'architecture interne :

Un servomoteur contient un moteur à courant continu, un réducteur à roues dentées à axes


parallèles et une électronique de commande.

L'alimentation et la commande se font par un câble de trois fils, un commun, un fil


d'alimentation et un fil de commande. Les couleurs sont conventionnelles pour un constructeur.

Inversion du sens de rotation du moteur :

La tension d'alimentation étant unipolaire, il faut une utiliser une disposition classique
modélisée ci-contre.

En fermant H1 et H3, on obtient un sens de rotation, la fermeture de H2 et de H4 donne


l'autre sens. Les interrupteurs sont réalisés par des transistors.

Fig.5 : Inversion du sens de rotation du moteur

3. Capteur humidité & température DHT11 :

Fig.6 : Capteur d’humidité DHT11/ application typique

Ne pas oublier le condensateur de 100nF entre VCC et GND (il n’est pas sur le schéma mais
il est nécessaire).

18
[Réalisation d’une maison intelligente]

Caractéristiques:

• Alimentation +5V (3.5 - 5.5V)


• Température : de 0 à 50°C, précision : +/- 2°C
• Humidité : de 20 à 96% RH, précision +/- 5% RH

Le protocole de communication :

Le DHT11 a la particularité d’utiliser une seule broche pour communiquer avec son maitre.
La communication se fait donc au moyen d’un protocole propriétaire demandant des timings
bien précis.

Explication des bases pour communiquer avec un DHT11

Fig.7 : les bases pour communiquer avec un DHT11

Une trame « type » se compose de trois grandes parties :

➢ Le maitre réveil le capteur au moyen d’un signal de « Start ».


➢ Le capteur sort de son sommeil et envoie une réponse pour dire qu’il est vivant.
➢ Le capteur envoie 40 bits de données (5 octets) contenant la température, le taux
d’humidité et un checksum.

Ce qu’il faut noter c’est que le capteur a une sortie dite à « collecteur ouvert », cela signifie
que le capteur ne sort pas des niveaux logiques 0v/5v mais utilise un transistor en sortie. Si le
capteur veut envoyer un « 0 » il force le signal à 0v en rendant son transistor (entre DATA et
GND) passant.

Si le capteur veut envoyer un « 1 » il laisse le signal tel-quel en rendant son transistor


bloquant.
D’où l’important de la résistance de tirage que l’on peut voir sur le schéma, pas de résistance=
pas de signal

19
[Réalisation d’une maison intelligente]

Réveil du capteur :

Le DHT11 est une grosse déniasse, il passe son temps à dormir. Si vous voulez qu’il vous
envoie ses données il faut le secouer en lui envoyant un signal de Start.
Le signal de Start consiste en un état bas (0v) de 18 millisecondes et d’un état haut (5v) de
40 microsecondes. Jusque-là rien de bien compliqué !

Ensuite le DHT11 va répondre pour dire qu’il est bien réveillé. Pour ce faire il va placer le
signal à l’état bas pendant 80 microsecondes puis à l’état haut pendant 80 autres microsecondes.
A ce moment précis le capteur est prêt, les mesures de la température et de l’humidité sont faites
et le capteur va pouvoir commencer à envoyer les données.

4. Capteur de gaz MQ2 :

Fig.7 : Capteur de gaz MQ6

Description produit :

• Alimentation électrique: 5 V
• Capteur de gaz (GPL) simple à utiliser
• Peut être utilisé dans les équipements de détection de fuites de gaz dans les applications
grand-public et industrielles
• Type d’interface: analogique
• Haute sensibilité au GPL, isobutane, propane
• Faible sensibilité à l’alcool, la fumée
• Réponse rapide
• Stable et durable
• Circuit de pilotage simple

Le MQ-6 Capteur de Gaz GPL, Isobutane et de Propane est un semi-conducteur capteur de


gaz qui détecte la présence du gaz GPL, Isobutane et de Propane à des concentrations de 300
ppm à 10000 ppm, une gamme appropriée de détection des fuites de gaz. La simple interface
de tension analogique du capteur ne nécessite qu'une seule broche d'entrée analogique de votre
microcontrôleur.

20
[Réalisation d’une maison intelligente]

Le capteur de gaz GPL, Isobutane et de Propane MQ-6 détecte la concentration de gaz dans
l'air et sorties le résultat comme une tension analogique. La concentration de détection gamme
de 300 ppm à 10000 ppm est appropriée pour la détection des fuites. Le capteur peut fonctionner
à des températures allant de -10 à 50 ° C et consomme moins de 150 mA à 5 V.
Connexions
Raccordement de 5 volts à travers le chauffage (H) broches conserve le capteur assez chaud
pour fonctionner correctement. Raccordement de 5 volts, soit aux broches A ou B provoque le
capteur d'émettre une tension analogique sur les autres broches. Une charge ohmique entre les
broches de sortie et la terre, définit la sensibilité du détecteur. La charge résistive doit être
calibrée pour votre application particulière en utilisant les équations de la fiche technique, mais
une bonne valeur de départ pour la résistance est de 20 k Ω.

5. Ecran LCD avec un I2C :

Fig.8 : Ecran LCD avec un I2c en arrière

Ces 16 caractères par 2 lignes d'affichage a un contraste texte blanc très clair et très haut sur
un fond bleu / rétro-éclairage. Il comprend également une série I2C / IIC carte adaptateur pré
soudé à l'arrière de l'écran LCD. Cela signifie qu'il peut être contrôlé avec seulement 2 I2C
broches de données série (SDA et SCL) et nécessite donc beaucoup moins broches
numériques IO lorsqu'il est commandé à partir d'un microcontrôleur. Au total, le module ne
nécessite 4 fils dont la puissance 5V et GND. Le réglage du contraste est également fourni par
la carte fille par l'intermédiaire d'un potentiomètre. Si vous prévoyez d'utiliser avec une carte
Arduino.

Note : Ces modules sont actuellement fournis avec une adresse I2C par défaut soit 0x27 ou
0x3F. Pour déterminer quelle version vous avez vérifié l'adaptateur I2C tableau noir sur la
face inférieure du module. S'il y a 3 jeux de patins étiquetés A0, A1, A2 et puis l'adresse par
défaut sera 0x3F. S'il n'y a pas pads l'adresse par défaut sera 0x27.
Le module est équipé d'un potentiomètre de réglage de contraste sur la face inférieure de
l'écran. Cela peut nécessiter de réglage pour l'écran pour afficher le texte correctement. Si la
pression est appliquée à la carte fille I2C il est possible de se plier et de venir en contact
avec le module LCD. S'il vous plaît assurer lorsque l'écran LCD est installé dans votre
application qu'aucun objet externe n’applique une pression sur le dos du module.

Les pins de LCD (I2C) sont : GND, VCC (+5V), SDA et SCL

21
[Réalisation d’une maison intelligente]

6. Buzzer :

Fig.9 : Buzzer passive

Description

Type : Buzzer passive


Tension de travail: 3.5-5.5v
Courant de travail: < 25mA
Dimension PCB : 18.5mm x 15mm (L x P)
Fonction de Buzzer : buzz
Fonctionnalité :

Aucune source d'oscillation, besoin onde carrée (fréquence 2k-5k) à conduire.


Le contrôle de la fréquence du son, vous pouvez faire une " Do Re Mi Fa Sol La SI " effet.
Buzzer est une structure intégrée de transducteurs électroniques, alimentation en courant
continu, largement utilisé dans les ordinateurs, les imprimantes, les photocopieurs, les
alarmes, jouets électroniques, matériel électronique automobile et d’autres produits
électroniques pour les appareils sonores. Buzzer passif module d’alarme utilisé pour
l’Arduino
Le Buzzer interne active avec la source de choc, de sorte sue sera appelé à une tension. Les
sources internes passives sans chocs, donc si un signal continu ne peut pas faire tweet. Doit
2K ~ 5K ave place pour le conduire. Buzzer souvent coûteux passif, car il circuit oscillateur
multiple. Avantages Buzzer passifs sont les suivants:

1. Bon Marché,
2. Contrôle de la fréquence sonore, vous pouvez faire un "plus que l'efficacité d'un cheveu
mètre Suola Xi 'Fruit.
3. Dans certains cas particuliers, vous pouvez réutiliser un contrôle et un port LED Buzzer
actif

22
[Réalisation d’une maison intelligente]

III. Logiciels :

1.IDE de l’ARDUINO :

L'open-source Arduino Software (IDE), il est facile d'écrire du code et de le transférer à la


carte. Il fonctionne sur Windows, Mac OS X et Linux. L'environnement est écrit en Java et basé
sur le traitement et d'autres logiciels open-source.
Ce logiciel peut être utilisé avec toute carte Arduino.
Présentation de logiciel Arduino :

Fig.10 : Présentation de l’interface initiale du logiciel

Correspondence:
• Le cadre numéro 1 : ce sont les options de configuration du logiciel
• Le cadre numéro 2 : il contient les boutons qui vont nous servir lorsque l’on va
programmer nos cartes
• Le cadre numéro 3 : ce bloc va contenir le programme que nous allons créer

Le cadre numéro 4 : celui-ci est important, car il va nous aider à corriger les fautes dans notre
programme. C’est le débogueur.

23
[Réalisation d’une maison intelligente]

2.Android Studio :
Définition :
Android Studio est un environnement de développement pour développer des applications
mobiles Android. Il est basé sur IntelliJ IDEA et utilise le moteur de production Gradle. Il peut
être téléchargé sous les systèmes d'exploitation Windows, macOS, Chrome OS et Linux.

Fonctionnalité :
Android Studio permet principalement d'éditer les fichiers Java/Kotlin et les fichiers de
configuration XML d'une application Android.
Il propose entre autres des outils pour gérer le développement d'applications multilingues et permet de
visualiser rapidement la mise en page des écrans sur des écrans de résolutions variées simultanément. Il
intègre par ailleurs un émulateur permettant de faire tourner un système Android virtuel sur un ordinateur.
Partie Java :

Fig11 : code java de l’application mobile

24
[Réalisation d’une maison intelligente]

Partie XML :

Fig12 : code XML de l’application mobile

3.FireBase
Définition :
Firebase est un ensemble de services d'hébergement pour n'importe quel type d'application
(Android, iOS, Javascript, Node.js, Java, Unity, PHP, C++ ...). Il propose d'héberger
en NoSQL et en temps réel des bases de données, du contenu, de l'authentification
sociale (Google, Facebook, Twitter et Github), et des notifications, ou encore des services, tel
que par exemple un serveur de communication temps réel. Lancé en 2011 sous le nom
d'Envolve, par Andrew Lee et par James Templin, le service est racheté
par Google en octobre 2014. Il appartient aujourd'hui à la maison mère de Google : Alphabet.
Toute l'implémentation et la gestion serveur de Firebase est à la charge exclusive de la
société Alphabet. Les applications qui utilisent Firebase intègrent une bibliothèque qui
permet les diverses interactions possibles.

25
[Réalisation d’une maison intelligente]

Interface :

Fig13 : interface de la plateforme FireBase

Base de données en temps réel :

Fig14 : interface de la base de données en temps réel

26
[Réalisation d’une maison intelligente]

CHAPITRE 3 : CONCEPTION ET
REALISATION DU PROJET

27
[Réalisation d’une maison intelligente]

I. Introduction :

L'ordinateur est relié au microcontrôleur par un port USB qui sert à transmettre le
code ainsi qu’à alimenter en électricité la carte ESP32. Les données extérieures des
capteurs sont envoyées au microcontrôleur, qui envoi à son tour les données reçus à
la carte ESP32. De plus, les données relevées par les capteurs peuvent être visibles
sur une application mobile.
Pour pouvoir faire tout cela, il faut créer un programme permettant de contrôler les
appareils électriques en fonction des données reçues. Pour cela plusieurs langages
de programmation sont utilisables tels que : Python, Java, C++, etc. Dans le cadre
du projet nous avons utilisé l'environnement de développement Arduino. En effet,
nous avons choisis ce langage suite à l'achat des différents composants dont le
principal est une carte esp32 nous permettant d'agir au niveau des appareils
électriques.

II. Réalisation de la maquette :

1. Structure de la maquette :
La première étape consiste à créer une maison. Pour cela, nous avons dessiné la structure
principale. La maquette est de taille de 54cm sur 46cm constitue d’une chambre, une cuisine,
un garage, salle de bains, un salon.

Fig.15 : illustration de la maquette utilisée dans le projet

28
[Réalisation d’une maison intelligente]

2. Périphériques utilisées et leurs positions :


Cette maquette, permettrait de présenter certaines fonctionnalités de la domotique à travers 4
Capteurs (Gaz, Humidité et Température.) 2
Servomoteur et autres périphériques. Ces scénarios seront automatisés via la carte « esp32 »
Exécutant des programmes informatiques.

LOCALISATION PERIPHERIQUES
La chambre -LED
- Capteur d’humidité
-LCD 1602 I2C
Salle de bains
-LED
La cuisine -Capteur de gaz MQ2
-LED
-Buzzer

La porte -servomoteur
-LED
Tableau 2 : Localisation des périphériques utilisés dans la maquette
III. Automatisation de la maison :

1. Capteur d’humidité :
Ce dispositif permet d’améliorer la gestion d’énergie de la maison. En effet nous avons utilisé
un dispositif prenant en charge la détection de la température et de l’humidité dans
l’entourage de la maison.
Nous avons utilisé comme matériel :
- Un capteur DHT 11
- Ecran LCD 1602 avec I2C
- Une carte ESP32

Fig.16 : branchement du capteur d’humidité et ESP32

29
[Réalisation d’une maison intelligente]

2. Capteur de gaz :
La sécurité est devenue un élément primordial dans le choix d’une maison. Et l’une des plus
grande crainte d’accident reste l’incendie. Ainsi nous avons associé différents composants
afin d’utilisé un détecteur de flamme et de gaz dans la cuisine pour une bonne sécurité. Ces
deux détecteurs déclenchent une alarme.

Le matériel utilisé pour le gaz est le suivant :


- Un détecteur de gaz
- Un Buzzer
- Une carte Esp32

Fig.17 : branchement du capteur de gaz et ESP32

3. Servomoteur:
Le confort est placé au premier plan pour cela pour éviter les actes répétitifs et pour une
bonne sécurité de la maison nous avons pensé à ce dispositif. On va commander à distance la
fermeture et l'ouvrir de la porte initiale de la maison.
Le matériel que nous avons utilisé est le suivant :
- servomoteurs 9g
- Une Carte esp32

Fig.18 : branchement du servomoteur et ESP32

Le programme et le schéma global sont situés en Annexe.

30
[Réalisation d’une maison intelligente]

IV. Centralisation des commandes :


La domotique peut également permettre à des fonctions d'être contrôlés à distance de partout
dans le monde en utilisant un smartphone.

Pour rendre la maison connectée et commandable à distance nous avons le choix de travailler
soit avec une carte esp32 soit une carte esp8266 car ils intègrent un (WI-FI), dont on va la
connecter avec une base de données ou cloud

Fig. 19 : L’organigramme représente le chemin des requêtes

Cette figure représente le fonctionnement des capteurs liés à la carte esp32, et l’envoi des données mesurés
par les capteurs et réceptions des ordres d’action pour allumer ou éteindre les lampes ouvrir ou fermer les
portes et les moteurs.

31
[Réalisation d’une maison intelligente]

Fig. 19 : L’organigramme représente le chemin de la connexion entre le microcontrôleur et la


base de données

32
[Réalisation d’une maison intelligente]

Application Mobile Android :

L’interface d’accueil :
Dans cette interface vous trouvez les capteurs qu’on a utilisés chacun à ses états.

L’interface de commande :

La deuxième interface pour les modules qu’on souhaite contrôler (LEDS, Servomoteur)

33
[Réalisation d’une maison intelligente]

A propos :

34
[Réalisation d’une maison intelligente]

Conclusion Générale :

Nous avons réalisé une maison dite « intelligente ». Effectivement, dans le cadre du thème de
la domotique, nous avons conçu une maison automatisée. Elle est capable de gérer l'éclairage
des chambres et les portes, de prévenir dans le cas de fuite de gaz aussi surveillé l'état de la
température et l'humidité. Cependant, les fonctionnalités ne se restreignent pas à celles-ci et
d'autres peuvent être ajoutées grâce à un système de centralisation.

Nous sommes unanimes pour dire que ce projet nous a permis de nous amuser grâce à la
manipulation du matériel, tout en acquérant de meilleures connaissances des applications de la
domotique, ce qui pourrait nous être fortement utile pour notre vie professionnelle future.
Bien sûr tout ce travail s’est déroulé dans les meilleures conditions possible, en effet une bonne
cohésion et une bonne entente ont permis l’obtention d’un travail abouti et satisfaisant.

Ce projet nous a fait découvrir un secteur que nous ne connaissions pas vraiment et qui nous a
intéressés de plus en plus au fur et à mesure que nous approfondissions nos recherches. En
plus de l’expérience humaine, la rencontre avec des professionnels travaillant dans la
domotique nous a permis de recueillir des informations techniques et des explications
nécessaires à la compréhension du principe de fonctionnement de certaine technologie.

Le seul point « négatif », serait sûrement le manque de temps pour pouvoir encore
approfondir ce travail, car ce dernier ne s'arrête pas ici il a encore plusieurs tâches qui peut
être amélioré. En effet, beaucoup de possibilités s’offrent aux passionnés de domotique, tant
sur le matériel disponible que sur les actions à réaliser. Cependant rien ne nous empêche de
continuer sur cette voie de notre propre côté …

Ce projet a été vivant, entraînant et motivant pour la suite de nos études. Nous pensons avoir
entraperçu une partie de notre future vie active.

35
[Réalisation d’une maison intelligente]

Annexes et Programmes

36
[Réalisation d’une maison intelligente]

Découvrir Arduino IDE :

Dans un premier temps on va Télécharger le logiciel Arduino gratuitement depuis le site


arduico.cc, ensuite on va installer le driver pour la carte Arduino Choisir le type de carte :

Serial Port / COM Port :

37
[Réalisation d’une maison intelligente]

Charger un programme dans la carte :

• Bouton 1 : Ce bouton permet de vérifier le programme, il actionne un module qui


cherche les erreurs dans votre programme.
• Bouton 2 : Charge (téléverser) le programme dans la carte Arduino.
• Bouton 3 : Crée un nouveau fichier.
• Bouton 4: Ouvre un fichier.
• Bouton 5 : Enregistre le fichier.
• Bouton 6 : Ouvre le moniteur série.

Parties Principales d’un code:

38
[Réalisation d’une maison intelligente]

Les CODES dans l’IDE :


 Le code de l’esp32:

#include "DHT.h"
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <Servo.h>

#include <WiFi.h>
#include <FirebaseESP32.h>

#define DHT11PIN 15
#define FIREBASE_HOST "https://esp32firbase-default-rtdb.europe-west1.firebasedatabase.app/"
#define FIREBASE_AUTH "firebase authentification"
#define WIFI_SSID "************"
#define WIFI_PASSWORD "*************"
//#define WIFI_SSID "***********"
//#define WIFI_PASSWORD "*********"
DHT dht(DHT11PIN, DHT11);
LiquidCrystal_I2C lcd(0x27, 16, 2);
Servo servo1,servo2;

byte degree_symbol[8] =
{
0b00111,
0b00101,
0b00111,
0b00000,
0b00000,
0b00000,
0b00000,
0b00000
};

//Define FirebaseESP32 data object


FirebaseData firebaseData;
FirebaseJson json,json1,json2;
String message="";
String message1="";
String message2="";
String message3="";
String message4="";
String message5="";

void setup()
{

39
[Réalisation d’une maison intelligente]

Serial.begin(115200);
dht.begin();
lcd.init();
lcd.backlight();
lcd.createChar(0, degree_symbol);
lcd.setCursor(0,0);
lcd.print(" DHT11 with ");
lcd.setCursor(0,1);
lcd.print(" ESP32 DevKit ");
delay(2000);
lcd.clear();

pinMode(2,OUTPUT);
pinMode(4,OUTPUT);
pinMode(5,OUTPUT);
pinMode(12,OUTPUT);
servo1.attach(13);
servo2.attach(27);

WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
Serial.print("Connecting to Wi-Fi");
while (WiFi.status() != WL_CONNECTED)
{
Serial.print(".");
delay(300);
}
Serial.println();
Serial.print("Connected with IP: ");
Serial.println(WiFi.localIP());
Serial.println();

Firebase.begin(FIREBASE_HOST, FIREBASE_AUTH);
Firebase.setString(firebaseData, "/leds/led1status", "off");
Firebase.setString(firebaseData, "/doors/door1", "close");
Firebase.reconnectWiFi(true);

//Set database read timeout to 1 minute (max 15 minutes)


Firebase.setReadTimeout(firebaseData, 1000 * 60);
//tiny, small, medium, large and unlimited.
//Size and its write timeout e.g. tiny (1s), small (10s), medium (30s) and large (60s).
Firebase.setwriteSizeLimit(firebaseData, "tiny");

/*
This option allows get and delete functions (PUT and DELETE HTTP requests) works for device connected
behind the
Firewall that allows only GET and POST requests.

40
[Réalisation d’une maison intelligente]

Firebase.enableClassicRequest(firebaseData, true);
*/

//String path = "/data";

Serial.println("------------------------------------");
Serial.println("Connected...");

void loop()
{
int sensorValue = analogRead(A0);
int mq2sensor = analogRead(A3);
Serial.println(mq2sensor);
if (mq2sensor<2000){digitalWrite(19,LOW);}
if (mq2sensor>=2000){digitalWrite(19,HIGH);}
int temp = (int) dht.readTemperature();
int humi = dht.readHumidity();
lcd.setCursor(0,0);
lcd.print("Temp = ");
lcd.print(temp);
lcd.write(0);
lcd.print("C");
lcd.setCursor(0,1);
lcd.print("Humidity = ");
lcd.print(humi);
lcd.print("%");
Serial.println(temp);
Serial.println(humi);
delay(100);
json.set("/temperature", temp);
json1.set("/humidity", humi);
json1.set("/moisture", sensorValue);
Firebase.updateNode(firebaseData,"/Sensor",json);
Firebase.updateNode(firebaseData,"/Sensor",json1);
Firebase.updateNode(firebaseData,"/Sensor",json2);
if (Firebase.getString(firebaseData, "/leds/led1status")) {
String messagefb = firebaseData.stringData();
if (messagefb != message) {
message = messagefb;
Serial.println(message);
if(message=="on"){digitalWrite(2,HIGH);}
if(message=="off"){digitalWrite(2,LOW);}

41
[Réalisation d’une maison intelligente]

}
if (Firebase.getString(firebaseData, "/leds/led2status")) {
String messagefb1 = firebaseData.stringData();
if (messagefb1 != message1) {
message1 = messagefb1;
Serial.println(message1);
if(message1=="on"){digitalWrite(4,HIGH);}
if(message1=="off"){digitalWrite(4,LOW);}

}
}
if (Firebase.getString(firebaseData, "/leds/led3status")) {
String messagefb2 = firebaseData.stringData();
if (messagefb2 != message2) {
message2 = messagefb2;
Serial.println(message2);
if(message2=="on"){digitalWrite(5,HIGH);}
if(message2=="off"){digitalWrite(5,LOW);}

}
}
if (Firebase.getString(firebaseData, "/leds/led4status")) {
String messagefb3 = firebaseData.stringData();
if (messagefb3 != message3) {
message3 = messagefb3;
Serial.println(message3);
if(message3=="on"){digitalWrite(12,HIGH);}
if(message3=="off"){digitalWrite(12,LOW);}

}
}
if (Firebase.getString(firebaseData, "/doors/door1")) {
String messagefb4 = firebaseData.stringData();
if (messagefb4 != message4) {
message4 = messagefb4;
Serial.println(message4);
if(message4=="close"){servo1.write(180);}
if(message4=="open"){servo1.write(90);}

}
}
if (Firebase.getString(firebaseData, "/doors/garagedoor")) {
String messagefb5 = firebaseData.stringData();
if (messagefb5 != message5) {
message5 = messagefb5;
Serial.println(message5);
if(message5=="close"){servo2.write(20);}
if(message5=="open"){servo2.write(110);}

42
[Réalisation d’une maison intelligente]

}
}

delay(250);

43
[Réalisation d’une maison intelligente]

Les Codes de l’application mobile :


Home page:
Code java:

package com.example.projetfin;

import android.content.Intent;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.TextView;
import android.widget.Toast;

import androidx.annotation.NonNull;
import androidx.appcompat.app.AppCompatActivity;

import com.google.firebase.database.DataSnapshot;
import com.google.firebase.database.DatabaseError;
import com.google.firebase.database.DatabaseReference;
import com.google.firebase.database.FirebaseDatabase;
import com.google.firebase.database.ValueEventListener;

public class MainActivity extends AppCompatActivity {


TextView homeView ;
TextView controlView ;
TextView aboutView ;
DatabaseReference tempRef,humidRef,moistRef;
private static final String TAG = "MyActivity";

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
homeView = findViewById(R.id.home_view);
controlView = findViewById(R.id.control_view);
aboutView = findViewById(R.id.about_view);
homeView.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
Toast.makeText(MainActivity.this, "Stay In Home Page",
Toast.LENGTH_SHORT).show();
Intent intent = new Intent(MainActivity.this, MainActivity.class);
startActivity(intent);
}
});
aboutView.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
Toast.makeText(MainActivity.this, "Open About Page",
Toast.LENGTH_SHORT).show();
Intent intent = new Intent(MainActivity.this, AboutActivity.class);
startActivity(intent);
}
});
controlView.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {

44
[Réalisation d’une maison intelligente]

Toast.makeText(MainActivity.this, "Open Control Page",


Toast.LENGTH_SHORT).show();
Intent intent = new Intent(MainActivity.this, ControlActivity.class);
startActivity(intent);
}
});
tempRef =
FirebaseDatabase.getInstance().getReference("Sensor").child("temperature");
tempRef.addValueEventListener(new ValueEventListener() {
@Override
public void onDataChange(@NonNull DataSnapshot dataSnapshot) {
// This method is called once with the initial value and again
// whenever data at this location is updated.
int value = dataSnapshot.getValue(int.class);
displayTemperature(value);

@Override
public void onCancelled(@NonNull DatabaseError error) {
// Failed to read value

Log.w(TAG, "Failed to read value.", error.toException());

}
});
humidRef =
FirebaseDatabase.getInstance().getReference("Sensor").child("humidity");
humidRef.addValueEventListener(new ValueEventListener() {
@Override
public void onDataChange(@NonNull DataSnapshot dataSnapshot) {
// This method is called once with the initial value and again
// whenever data at this location is updated.
int value = dataSnapshot.getValue(int.class);
displayHumidity(value);

@Override
public void onCancelled(@NonNull DatabaseError error) {
// Failed to read value

Log.w(TAG, "Failed to read value.", error.toException());

}
});
moistRef =
FirebaseDatabase.getInstance().getReference("Sensor").child("moisture");
moistRef.addValueEventListener(new ValueEventListener() {
@Override
public void onDataChange(@NonNull DataSnapshot dataSnapshot) {
// This method is called once with the initial value and again
// whenever data at this location is updated.
int value = dataSnapshot.getValue(int.class);
if (value <= 1300){
displayMoistureStatus("WET");
displayWaterPumpStatus("CLOSED");
}

45
[Réalisation d’une maison intelligente]

else if (value <= 2600){


displayMoistureStatus("SEMI-DRY");
displayWaterPumpStatus("CLOSED");

}
else{
displayMoistureStatus("DRY");
displayWaterPumpStatus("OPENED");
}

@Override
public void onCancelled(@NonNull DatabaseError error) {
// Failed to read value

Log.w(TAG, "Failed to read value.", error.toException());

}
});

}
public void displayTemperature(int data){
TextView temperatureValue = (TextView) findViewById(R.id.temperature_value);
temperatureValue.setText(data + "°C");

}
public void displayHumidity(int data){
TextView humidityValue = (TextView) findViewById(R.id.humidity_value);
humidityValue.setText(data + "%");

}
public void displayMoistureStatus(String data){
TextView temperatureValue = (TextView) findViewById(R.id.moisture_value);
temperatureValue.setText(data);

}
public void displayWaterPumpStatus(String data){
TextView temperatureValue = (TextView) findViewById(R.id.water_pump_value);
temperatureValue.setText(data);

}
}

46
[Réalisation d’une maison intelligente]

Code XML:
<?xml version="1.0" encoding="utf-8"?>

<androidx.constraintlayout.widget.ConstraintLayout
xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
tools:context=".MainActivity"
android:background="@drawable/images">

<TextView
android:id="@+id/home_view"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:padding="16dp"
android:textColor="#F2BC94"
android:text="HOME"
android:textAppearance="@style/TextAppearance.AppCompat.Large"
app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintHorizontal_bias="0.05"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="parent"
app:layout_constraintVertical_bias="0.198" />

<TextView
android:id="@+id/about_view"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:padding="16dp"
android:textColor="#F2BC94"

android:text="ABOUT"
android:textAppearance="@style/TextAppearance.AppCompat.Large"
app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintHorizontal_bias="0.925"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="parent"
app:layout_constraintVertical_bias="0.198" />

<TextView
android:id="@+id/Home_Title"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:padding="16dp"
android:text="Smart Home"
android:textColor="@color/white"

android:textAppearance="@style/TextAppearance.AppCompat.Display1"
android:visibility="visible"
app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintHorizontal_bias="0.287"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="parent"
app:layout_constraintVertical_bias="0.042"
tools:visibility="visible" />

<TextView

47
[Réalisation d’une maison intelligente]

android:id="@+id/control_view"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:padding="16dp"
android:text="CONTROL"
android:textColor="#F2BC94"

android:textAppearance="@style/TextAppearance.AppCompat.Large"
app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintEnd_toStartOf="@+id/about_view"
app:layout_constraintHorizontal_bias="0.549"
app:layout_constraintStart_toEndOf="@+id/home_view"
app:layout_constraintTop_toTopOf="parent"
app:layout_constraintVertical_bias="0.198" />

<TextView
android:id="@+id/sensor_view"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="SENSORS"
android:textAppearance="@style/TextAppearance.AppCompat.Large"
android:textColor="#F4AF1B"
app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintHorizontal_bias="0.05"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="parent"
app:layout_constraintVertical_bias="0.318" />

<LinearLayout
android:id="@+id/linearLayout"
android:layout_width="350dp"
android:layout_height="wrap_content"
android:orientation="vertical"
android:padding="16dp"
app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintHorizontal_bias="0.262"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="parent"
app:layout_constraintVertical_bias="0.471"
android:background="@drawable/white_card_background">

<LinearLayout
android:id="@+id/humidity_view_Group"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:orientation="horizontal"
android:padding="16dp">

<TextView
android:id="@+id/humidity_text"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Humidity :"
android:textAppearance="@style/TextAppearance.AppCompat.Large"
tools:layout_editor_absoluteX="70dp"
tools:layout_editor_absoluteY="622dp"
/>

<TextView

48
[Réalisation d’une maison intelligente]

android:id="@+id/humidity_value"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_marginLeft="8dp"
android:text="0%"
android:textAppearance="@style/TextAppearance.AppCompat.Large"
tools:layout_editor_absoluteX="354dp"
tools:layout_editor_absoluteY="633dp" />

</LinearLayout>

<LinearLayout
android:id="@+id/temperature_view_Group"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:orientation="horizontal"
android:padding="16dp">

<TextView
android:id="@+id/temperature_text"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Temperature :"
android:textAppearance="@style/TextAppearance.AppCompat.Large"
tools:layout_editor_absoluteX="70dp"
tools:layout_editor_absoluteY="622dp" />

<TextView
android:id="@+id/temperature_value"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_marginLeft="8dp"
android:text="0°C"
android:textAppearance="@style/TextAppearance.AppCompat.Large"
tools:layout_editor_absoluteX="354dp"
tools:layout_editor_absoluteY="633dp" />

</LinearLayout>

</LinearLayout>

<LinearLayout
android:layout_width="350dp"
android:layout_height="wrap_content"
android:orientation="vertical"
android:padding="16dp"
app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintHorizontal_bias="0.262"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="parent"
app:layout_constraintVertical_bias="0.773"
android:background="@drawable/white_card_background">

<LinearLayout
android:id="@+id/moisture_view_Group"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:orientation="horizontal"
android:padding="16dp">

49
[Réalisation d’une maison intelligente]

<TextView
android:id="@+id/moisture_text"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Moisture :"
android:textAppearance="@style/TextAppearance.AppCompat.Large"
tools:layout_editor_absoluteX="70dp"
tools:layout_editor_absoluteY="622dp" />

<TextView
android:id="@+id/moisture_value"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_marginLeft="8dp"
android:text="Wet"
android:textAppearance="@style/TextAppearance.AppCompat.Large"
tools:layout_editor_absoluteX="354dp"
tools:layout_editor_absoluteY="633dp" />

</LinearLayout>

<LinearLayout
android:id="@+id/water_pump_view_Group"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:orientation="horizontal"
android:padding="16dp">

<TextView
android:id="@+id/water_pump_text"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Water pump :"
android:textAppearance="@style/TextAppearance.AppCompat.Large"
tools:layout_editor_absoluteX="70dp"
tools:layout_editor_absoluteY="622dp" />

<TextView
android:id="@+id/water_pump_value"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_marginLeft="8dp"
android:text="Closed"
android:textAppearance="@style/TextAppearance.AppCompat.Large"
tools:layout_editor_absoluteX="354dp"
tools:layout_editor_absoluteY="633dp" />

</LinearLayout>
</LinearLayout>

<ImageView
android:id="@+id/smart_home_image"
android:layout_width="80dp"
android:layout_height="66dp"
app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintHorizontal_bias="0.934"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="parent"

50
[Réalisation d’une maison intelligente]

app:layout_constraintVertical_bias="0.051"
app:srcCompat="@mipmap/smart_home_icon" />

</androidx.constraintlayout.widget.ConstraintLayout>
Page de control:
Java code:
package com.example.projetfin;

import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.Toast;

import androidx.appcompat.app.AppCompatActivity;

import com.google.firebase.database.DatabaseReference;
import com.google.firebase.database.FirebaseDatabase;

public class ControlActivity extends AppCompatActivity {


DatabaseReference myRef;
Button onButtonLamp1;
Button offButtonLamp1;
Button onButtonLamp2;
Button offButtonLamp2;
Button onButtonLamp3;
Button offButtonLamp3;
Button onButtonLamp4;
Button offButtonLamp4;
Button openHomeDoor;
Button closeHomeDoor;
Button openGarageDoor;
Button closeGarageDoor;

private static final String TAG = "MyActivity";

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_control);
onButtonLamp1 = findViewById(R.id.lamp1_on_button);
offButtonLamp1 = findViewById(R.id.lamp1_off_button);
onButtonLamp2= findViewById(R.id.lamp2_on_button);
offButtonLamp2 = findViewById(R.id.lamp2_off_button);
onButtonLamp3 = findViewById(R.id.lamp3_on_button);
offButtonLamp3 = findViewById(R.id.lamp3_off_button);
onButtonLamp4 = findViewById(R.id.lamp4_on_button);
offButtonLamp4 = findViewById(R.id.lamp4_off_button);
openHomeDoor = findViewById(R.id.home_door_open);
closeHomeDoor = findViewById(R.id.home_door_close);
openGarageDoor = findViewById(R.id.garage_door_open);
closeGarageDoor = findViewById(R.id.garage_door_close);

onButtonLamp1.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
myRef = FirebaseDatabase.getInstance().getReference("leds");
myRef.child("led1status").setValue("on");
Toast.makeText(ControlActivity.this,"Light 1 is
opened",Toast.LENGTH_SHORT).show();
}

51
[Réalisation d’une maison intelligente]

});
offButtonLamp1.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
myRef = FirebaseDatabase.getInstance().getReference("leds");
myRef.child("led1status").setValue("off");
Toast.makeText(ControlActivity.this,"Light 1 is
closed",Toast.LENGTH_SHORT).show();

}
});
onButtonLamp2.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
myRef = FirebaseDatabase.getInstance().getReference("leds");
myRef.child("led2status").setValue("on");
Toast.makeText(ControlActivity.this,"Light 2 is
opened",Toast.LENGTH_SHORT).show();

}
});
offButtonLamp2.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
myRef = FirebaseDatabase.getInstance().getReference("leds");
myRef.child("led2status").setValue("off");
Toast.makeText(ControlActivity.this,"Light 2 is
closed",Toast.LENGTH_SHORT).show();

}
});
onButtonLamp3.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
myRef = FirebaseDatabase.getInstance().getReference("leds");
myRef.child("led3status").setValue("on");
Toast.makeText(ControlActivity.this,"Light 3 is
opened",Toast.LENGTH_SHORT).show();

}
});
offButtonLamp3.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
myRef = FirebaseDatabase.getInstance().getReference("leds");
myRef.child("led3status").setValue("off");
Toast.makeText(ControlActivity.this,"Light 3 is
closed",Toast.LENGTH_SHORT).show();

}
});
onButtonLamp4.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
myRef = FirebaseDatabase.getInstance().getReference("leds");
myRef.child("led4status").setValue("on");
Toast.makeText(ControlActivity.this,"Light 4 is
opened",Toast.LENGTH_SHORT).show();

52
[Réalisation d’une maison intelligente]

}
});
offButtonLamp4.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
myRef = FirebaseDatabase.getInstance().getReference("leds");
myRef.child("led4status").setValue("off");
Toast.makeText(ControlActivity.this,"Light 4 is
closed",Toast.LENGTH_SHORT).show();

}
});
openGarageDoor.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
myRef = FirebaseDatabase.getInstance().getReference("doors");
myRef.child("garagedoor").setValue("open");
Toast.makeText(ControlActivity.this,"Garage Door is
opened",Toast.LENGTH_SHORT).show();

}
});
closeGarageDoor.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
myRef = FirebaseDatabase.getInstance().getReference("doors");
myRef.child("garagedoor").setValue("close");
Toast.makeText(ControlActivity.this,"Garage Door is
closed",Toast.LENGTH_SHORT).show();

}
});
openHomeDoor.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
myRef = FirebaseDatabase.getInstance().getReference("doors");
myRef.child("door1").setValue("open");
Toast.makeText(ControlActivity.this,"Home Door is
opened",Toast.LENGTH_SHORT).show();

}
});
closeHomeDoor.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
myRef = FirebaseDatabase.getInstance().getReference("doors");
myRef.child("door1").setValue("close");
Toast.makeText(ControlActivity.this,"Home Door is
closed",Toast.LENGTH_SHORT).show();

}
});

}
}

53
[Réalisation d’une maison intelligente]

XML Code:
<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout
xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:background="@drawable/blue_background20">

<Button
android:id="@+id/lamp3_off_button"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Light Off"
android:background="#FF0000"

app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintHorizontal_bias="0.851"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="parent"
app:layout_constraintVertical_bias="0.489" />

<Button
android:id="@+id/lamp4_off_button"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Light Off"
android:background="#FF0000"

app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintHorizontal_bias="0.851"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="parent"
app:layout_constraintVertical_bias="0.623" />

<Button
android:id="@+id/home_door_close"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="close"
android:background="#FF0000"

app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintHorizontal_bias="0.948"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="parent"
app:layout_constraintVertical_bias="0.765" />

<Button
android:id="@+id/garage_door_close"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="close"
android:background="#FF0000"

app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintEnd_toEndOf="parent"

54
[Réalisation d’une maison intelligente]

app:layout_constraintHorizontal_bias="0.952"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="parent"
app:layout_constraintVertical_bias="0.891" />

<Button
android:id="@+id/lamp3_on_button"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Light On"
android:background="#00FF00"

app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintHorizontal_bias="0.434"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="parent"
app:layout_constraintVertical_bias="0.486" />

<Button
android:id="@+id/lamp4_on_button"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Light On"
android:background="#00FF00"

app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintHorizontal_bias="0.434"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="parent"
app:layout_constraintVertical_bias="0.623" />

<Button
android:id="@+id/home_door_open"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="open"
android:background="#00FF00"

app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintHorizontal_bias="0.571"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="parent"
app:layout_constraintVertical_bias="0.765" />

<Button
android:id="@+id/garage_door_open"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="open"
android:background="#00FF00"

app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintHorizontal_bias="0.631"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="parent"
app:layout_constraintVertical_bias="0.891" />

<TextView

55
[Réalisation d’une maison intelligente]

android:id="@+id/lampe1_view4"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:padding="8dp"
android:text="lamp 4"
android:textAllCaps="true"
android:textAppearance="@style/TextAppearance.AppCompat.Large"
android:textColor="@color/white"
app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintHorizontal_bias="0.066"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="parent"
app:layout_constraintVertical_bias="0.624" />

<TextView
android:id="@+id/lampe1_view3"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:padding="8dp"
android:text="lamp 3"
android:textAllCaps="true"
android:textAppearance="@style/TextAppearance.AppCompat.Large"
android:textColor="@color/white"
app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintHorizontal_bias="0.066"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="parent"
app:layout_constraintVertical_bias="0.487" />

<Button
android:id="@+id/lamp2_off_button"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Light Off"
android:background="#FF0000"

app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintHorizontal_bias="0.851"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="parent"
app:layout_constraintVertical_bias="0.351" />

<Button
android:id="@+id/lamp2_on_button"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Light On"
android:background="#00FF00"

app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintHorizontal_bias="0.434"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="parent"
app:layout_constraintVertical_bias="0.351" />

<TextView
android:id="@+id/lampe1_view2"
android:layout_width="wrap_content"

56
[Réalisation d’une maison intelligente]

android:layout_height="wrap_content"
android:padding="8dp"
android:text="lamp 2"
android:textAllCaps="true"
android:textAppearance="@style/TextAppearance.AppCompat.Large"
android:textColor="@color/white"
app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintHorizontal_bias="0.066"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="parent"
app:layout_constraintVertical_bias="0.351" />

<TextView
android:id="@+id/textView"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Control page"
android:textAppearance="@style/TextAppearance.AppCompat.Large"
android:textColor="#F2BC94"
app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintHorizontal_bias="0.073"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="parent"
app:layout_constraintVertical_bias="0.089" />

<TextView
android:id="@+id/lampe1_view"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="lamp 1"
android:padding="8dp"
android:textAllCaps="true"
android:textAppearance="@style/TextAppearance.AppCompat.Large"
android:textColor="@color/white"
app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintHorizontal_bias="0.059"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="parent"
app:layout_constraintVertical_bias="0.21" />

<TextView
android:id="@+id/lampe1_view5"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:padding="8dp"
android:text="Home Door"
android:textAllCaps="true"
android:textAppearance="@style/TextAppearance.AppCompat.Large"
android:textColor="@color/white"
app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintHorizontal_bias="0.066"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="parent"
app:layout_constraintVertical_bias="0.766" />

<TextView
android:id="@+id/lampe1_view6"
android:layout_width="wrap_content"

57
[Réalisation d’une maison intelligente]

android:layout_height="wrap_content"
android:padding="8dp"
android:text="Garage Door"
android:textAllCaps="true"
android:textAppearance="@style/TextAppearance.AppCompat.Large"
android:textColor="@color/white"
app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintHorizontal_bias="0.064"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="parent"
app:layout_constraintVertical_bias="0.889" />

<Button
android:id="@+id/lamp1_on_button"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Light On"
android:background="#00FF00"
app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintHorizontal_bias="0.434"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="parent"
app:layout_constraintVertical_bias="0.21" />

<Button
android:id="@+id/lamp1_off_button"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Light Off"
android:background="#FF0000"

app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintHorizontal_bias="0.851"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="parent"
app:layout_constraintVertical_bias="0.21" />

</androidx.constraintlayout.widget.ConstraintLayout>

Page A propos:
Java Code:
package com.example.projetfin;

import android.os.Bundle;

import androidx.appcompat.app.AppCompatActivity;

public class AboutActivity extends AppCompatActivity {


@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_about);
}
}

58
[Réalisation d’une maison intelligente]

XML CODE:
<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout
xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:background="@drawable/images">

<TextView
android:id="@+id/team_work_view"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text=">> Team Work"
android:textAppearance="@style/TextAppearance.AppCompat.Display1"
android:textColor="#F2BC94"
app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintHorizontal_bias="0.109"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="parent"
app:layout_constraintVertical_bias="0.099" />

<TextView
android:id="@+id/textView2"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Project made by"
android:textAppearance="@style/TextAppearance.AppCompat.Large"
android:textColor="#F4AF1B"
app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintHorizontal_bias="0.078"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="parent"
app:layout_constraintVertical_bias="0.231" />

<TextView
android:id="@+id/textView3"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Fradi Louei"
android:textAllCaps="true"
android:textAppearance="@style/TextAppearance.AppCompat.Medium"
android:textColor="@color/white"
app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintHorizontal_bias="0.161"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="parent"
app:layout_constraintVertical_bias="0.319" />

<TextView
android:id="@+id/textView4"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Manaa Chiheb Eddine"
android:textAllCaps="true"
android:textColor="@color/white"

app:layout_constraintBottom_toBottomOf="parent"

59
[Réalisation d’une maison intelligente]

app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintHorizontal_bias="0.194"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="parent"
app:layout_constraintVertical_bias="0.382" />

<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Supervised by"
android:textAppearance="@style/TextAppearance.AppCompat.Large"
android:textColor="#F4AF1B"
app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintHorizontal_bias="0.076"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="parent"
app:layout_constraintVertical_bias="0.466" />

<TextView
android:id="@+id/textView5"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Gammoudi Chokri"
android:textAllCaps="true"
android:textAppearance="@style/TextAppearance.AppCompat.Medium"
android:textColor="@color/white"
app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintHorizontal_bias="0.182"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="parent"
app:layout_constraintVertical_bias="0.553" />

<TextView
android:id="@+id/textView6"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Malouche Ibtissem"
android:textAllCaps="true"
android:textAppearance="@style/TextAppearance.AppCompat.Medium"
android:textColor="@color/white"
app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintHorizontal_bias="0.193"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="parent"
app:layout_constraintVertical_bias="0.628" />

</androidx.constraintlayout.widget.ConstraintLayout>

60

Vous aimerez peut-être aussi