Chapitre IV
Réalisation de la poubelle intelligente
CHAPITRE IV Réalisation de la poubelle
intelligente
IV.1. Introduction
Une poubelle est dite intelligente lorsqu’elle capable d’effectuer certaines actions qu’une
poubelle classique (poubelle que nous utilisons au quotidien) ne peut pas effectuer. Notre
poubelle intelligente est capable de :
S’ouvrir et se fermer automatiquement sans que vous la toucher,
Parler,
Mesurer son taux de remplissage,
Envoyer et recevoir des SMS,
Passer un appel téléphonique,
Se connecter à un ou plusieurs satellites.
IV.2. Constitution de la poubelle
Cette poubelle est essentiellement constituée de :
Deux capteurs à ultrason placés respectivement à l’extérieur et l’intérieur de la poubelle.
Celui de l’extérieur permet à la poubelle de détecter la présence d’une personne, et celui
qui est placé à l’intérieur mesure en permanence le taux de remplissage de la poubelle ;
Deux servomoteurs qui permettent de soulever et baisser le couvercle de la poubelle ;
Un haut-parleur qui permet à la poubelle de parler ;
Un module GSM qui permet à la poubelle d’envoyer et recevoir des SMS, et de passer
des appels téléphoniques ;
Un module GPS qui permet à la poubelle de se connecter à un satellite ou plusieurs
satellites ;
Un clavier matriciel qui permet d’ouvrir la poubelle lorsqu’elle est pleine ;
Un afficheur LCD qui sert d’interface visuel entre l’utilisateur et la poubelle ;
Trois LED respectivement de couleur verte, bleue et rouge. La LED verte s’allume
lorsque la poubelle n’est pas encore pleine ; bleue lorsque la poubelle est connectée au
satellite ; et enfin rouge lorsque la poubelle est pleine.
CHAPITRE IV Réalisation de la poubelle
intelligente
IV.3. Principe de fonctionnement de la poubelle
Notre poubelle intelligente fonctionne de la manière suivante :
Si le capteur à ultrason qui se trouve à l’extérieur de la poubelle détecte un objet à une
distance de moins de 15 cm (cette valeur peut être modifiée dans le sketch mais, nous
avons choisi de la fixer à 15 cm), la poubelle s’ouvre. Après 15 secondes, elle se ferme ;
Le capteur à ultrason qui se trouve à l’intérieur de la poubelle mesure en permanence le
taux de remplissage de cette dernière. Si ce taux atteint 80%, la poubelle va appeler la
personne chargée de la vider par un appel téléphonique d’une durée de 20 secondes (le
téléphone va sonner pendant 20 secondes) avant de raccrocher. 3 secondes après avoir
raccrocher, elle lui enverra un SMS indiquant sa localisation et son taux de remplissage ;
Figure IV. 1 : message envoyer lorsque la poubelle est proche d’être remplie
Lorsque la poubelle sera pleine, elle se bloque et ensuite elle va encore appeler la
personne chargée de la vider par un appel téléphonique d’une durée de 20 secondes avant
de raccrocher. 3 secondes après avoir raccrocher, elle lui enverra un SMS indiquant sa
localisation et son taux de remplissage ;
CHAPITRE IV Réalisation de la poubelle
intelligente
Figure IV. 2 : message envoyer lorsque la poubelle est pleine
Si le capteur à ultrason qui se trouve à l’extérieur de la poubelle détecte un objet à une
distance de moins de 15 cm lorsque la poubelle est pleine, elle se n’ouvre pas mais parle
en prononçant la phrase suivante : « désolé la poubelle est pleine, ne jeter pas les ordures
par terre s’il vous plaît » ;
Pour vider la poubelle, il faut d’abord l’ouvrir et cela se fait en saisissant un code à quatre
caractères sur le clavier matriciel de la poubelle ;
Si le code est correct, la poubelle s’ouvre. Après 20 secondes, elle se ferme ;
S’il est incorrect, la poubelle ne s’ouvre pas et il faut attendre 10 secondes pour ressayer ;
Une fois la poubelle vidée, le cycle recommence.
IV.4. Alimentation de la poubelle
Nous avons utilisé un adaptateur AC/DC pour l’alimentation de la poubelle. Il s’agit d’un
bloc d’alimentation ayant pour rôle de convertir la tension alternative du secteur en une tension
continue.
CHAPITRE IV Réalisation de la poubelle
intelligente
Figure IV. 3 : adaptateur AC/DC
IV.4.1. Caractéristiques de l’adaptateur AC/DC
L’adaptateur que nous avons utilisé possède les caractéristiques suivantes :
Entrée : 100-240V~ 50/60Hz 1.6A
Sortie : 12V = 5A
IV.4.2. Prise jack femelle d’alimentation
C’est sur cette prise que nous allons connecter l’adaptateur AC/DC pour alimenter la
poubelle.
Figure IV. 4 : prise jack femelle d’alimentation
CHAPITRE IV Réalisation de la poubelle
intelligente
IV.4.3. Interrupteur à bascule ON/OFF
Il s’agit tout simplement d’un interrupteur qui nous permet de mettre sous-tension ou hors-
tension la poubelle.
Figure IV. 5 : interrupteur à bascule ON/OFF
IV.5. Le logiciel Fritzing
Ce logiciel open source, qui a été développé à l’université des sciences appliquées de
Potsdam en Allemagne, permet de concevoir des circuits électroniques, de les documenter, de
créer un schéma électrique et même de faire fabriquer un circuit imprimé à partir de ces
informations.
C’est le logiciel que nous avons utilisé pour réaliser le schéma de montage de notre poubelle
intelligente.
CHAPITRE IV Réalisation de la poubelle
intelligente
IV.5.1. L’interface de Fritzing
Voici l’interface que vous aurez en ouvrant pour la première fois Fritzing. On peut voir
différents menus, comme Platine d’essai, Vue schématique, Circuit imprimé et Code qui
permettront de faire différents types de schémas.
Figure IV. 6 : l’interface de Fritzing
IV.5.1.1. Platine d’essai
L’affichage de la platine d’essai va nous permettre de faire nos circuits. À droite il y a les
différents composants que l’on peut ajouter sur notre circuit. On pourra ensuite relier les
différentes bornes des composants à la platine d’essai.
CHAPITRE IV Réalisation de la poubelle
intelligente
Figure IV. 7 : platine d’essai sur Fritzing
Voici un exemple d’un montage avec la platine d’essai.
Figure IV. 8 : montage avec la platine d’essai
CHAPITRE IV Réalisation de la poubelle
intelligente
IV.5.1.2. Vue schématique
Cette catégorie permet d’avoir une image des composants avec les différentes bornes de
sortie. Ceci permet de voir quels composants sont branché sur quels ports et d’avoir une vision
plus claire du schéma électrique.
Figure IV. 9 : montage en vue schématique
IV.5.1.3. Circuit imprimé
Cette partie de Fritzing va vous permettre de construire votre propre maquette après avoir
fait votre circuit dans la partie Platine d’essai.
Figure IV. 10 : exemple d’un circuit imprimé sur Fritzing
CHAPITRE IV Réalisation de la poubelle
intelligente
IV.5.1.4. Code
Cette partie permet d’écrire un code qu’on pourra ensuite téléverser dans une carte Arduino
pour tester.
Figure IV. 11 : exemple d’un code sur Fritzing
IV.6. Branchement des composants
Après avoir présenté le logiciel Fritzing avec ses différentes parties, nous allons maintenant
brancher étape par étape les composants cités dans le précédent chapitre afin d’aboutir au
montage général de notre poubelle intelligente.
IV.6.1. Convertisseur DC-DC avec Arduino
La tension recommandée pour alimenter une carte Arduino Mega 2560 est comprise entre 7
et 12V, nous avons choisi de l’alimenter avec 9V.
CHAPITRE IV Réalisation de la poubelle
intelligente
Par contre notre adaptateur AC/DC délivre une tension de 12V, donc pour obtenir les 9V
nécessaire pour la carte Arduino, nous avons utilisé un convertisseur DC/DC.
Figure IV. 12 : branchement du convertisseur DC-DC avec Arduino
Convertisseur DC-DC LM2596 Arduino
OUT+ VIN
OUT- GND
Tableau IV. 1 : connexion des broches du convertisseur DC-DC avec Arduino
IV.6.2. Les capteurs à ultrason HC-SR04 avec Arduino
Comme décrit dans la constitution, la poubelle comprend deux capteurs à ultrason HC-SR04
qui sont respectivement placés à l’extérieur et l’intérieur de celle-ci.
CHAPITRE IV Réalisation de la poubelle
intelligente
Ce schéma (voir page suivante) montre comment ces deux capteurs sont branchés avec la
carte Arduino.
(1) (2)
Figure IV. 13 : branchement des capteurs à ultrason HC-SR04 avec Arduino
Broche Arduino
Vcc 5V
Trig Pin 8
Capteur à ultrason HC-SR04 (1)
Echo Pin 9
Gnd GND
Vcc 5V
Capteur à ultrason HC-SR04 (2) Trig Pin 6
Echo Pin 7
CHAPITRE IV Réalisation de la poubelle
intelligente
Gnd GND
Tableau IV. 2 : connexion des broches des capteurs à ultrason avec Arduino
IV.6.3. Les servomoteurs avec Arduino
(1) (2)
(1)
(2)
(3)
Figure IV. 14 : branchement des servomoteurs avec Arduino
Broche Convertisseur (1) Convertisseur (2) Arduino
VCC OUT+
Servomoteur (1) GND OUT-
Signal Pin 13
VCC OUT+
Servomoteur (2)
GND OUT-
CHAPITRE IV Réalisation de la poubelle
intelligente
Signal Pin 12
Tableau IV. 3 : connexion des broches des servomoteurs avec Arduino
IV.6.4. Module GSM SIM800L avec Arduino
(1)
(2)
Figure IV. 15 : branchement du module GSM SIM800L avec Arduino
Module GSM SIM800L Convertisseur DC-DC (1) Arduino
5V OUT+
GND OUT-
SIM_RXD Pin 16
CHAPITRE IV Réalisation de la poubelle
intelligente
SIM_TXD Pin 17
Tableau IV. 4 : connexion des broches du module GSM SIM800L avec Arduino
IV.6.5. Les modules MP3 et GPS avec Arduino
(1)
(2)
Figure IV. 16 : branchement des modules MP3 et GPS avec Arduino
Broche Convertisseur DC-DC (1) Arduino
VCC OUT+
GND OUT-
Module DFPlayer Mini MP3
RX Pin 14
TX Pin 15
Module GPS NEO-6M VCC OUT+
CHAPITRE IV Réalisation de la poubelle
intelligente
GND OUT-
RX Pin 16
TX Pin 17
Tableau IV. 5 : connexion des broches des modules MP3 et GPS avec Arduino
IV.6.6. Haut-parleur avec le module MP3
Le haut-parleur se branche directement sur le Module DFPlayer Mini MP3, de cette façon il
peut jouer n’importe quel fichier MP3 stocké dans la carte SD insérée dans le module.
Figure IV. 17 : branchement du haut-parleur avec le module MP3
Haut-parleur Module DFPlayer Mini MP3
(+) SPK_1
(-) SPK_2
Tableau IV. 6 : connexion des broches du haut-parleur avec le module MP3
CHAPITRE IV Réalisation de la poubelle
intelligente
IV.6.7. Les LED avec Arduino
Figure IV. 18 : branchement LED avec Arduino
Broche Arduino
Anode Pin 30
LED verte
Cathode GND
LED bleu Anode Pin 36
CHAPITRE IV Réalisation de la poubelle
intelligente
Cathode GND
Anode Pin 32
LED rouge
Cathode GND
Tableau IV. 7 : connexion des broches des LED avec Arduino
IV.6.8. L’afficheur LCD 16x2 avec Arduino
Figure IV. 19 : branchement de l’afficheur LCD 16x2 avec Arduino
Afficheur LCD 16x2 Arduino
VSS GND
VDD 5V
RS Pin 11
RW GND
E Pin 10
D4 Pin 5
CHAPITRE IV Réalisation de la poubelle
intelligente
D5 Pin 4
D6 Pin 3
D7 Pin 2
A 5V
K GND
Tableau IV. 8 : connexion des broches de l’afficheur LCD 16x2 avec Arduino
IV.6.9. Clavier matriciel 4x4 avec Arduino
Figure IV. 20 : branchement du clavier matriciel 4x4 avec Arduino
Clavier matriciel 4x4 Arduino
Ligne 1 Pin 39
Ligne 2 Pin 41
CHAPITRE IV Réalisation de la poubelle
intelligente
Ligne 3 Pin 43
Ligne 4 Pin 45
Colonne 1 Pin 47
Colonne 2 Pin 49
Colonne 3 Pin 51
Colonne 4 Pin 53
Tableau IV. 9 : connexion des broches du clavier matriciel 4x4 avec Arduino
IV.6.10. Montage général
Ce schéma (voir page suivante) regroupe tous les montages présentés ci-dessus, c’est le
schéma de câblage général de la poubelle. Les composants sont numérotés sur le schéma pour
pouvoir facilement les identifier dans la nomenclature qui se trouve juste après le schéma.
CHAPITRE IV Réalisation de la poubelle
intelligente
Figure IV. 21 : schéma de câblage général
CHAPITRE IV Réalisation de la poubelle intelligente
IV.6.10.1. Nomenclature
Numéro Désignation
1 Prise jack femelle d’alimentation
2 Capteur à ultrason HC-SR04 (1)
3 Servomoteur (1)
4 Servomoteur (2)
5 Capteur à ultrason HC-SR04 (2)
6 Interrupteur à bascule ON/OFF
7 Module DFPlayer Mini MP3
8 Deux résistances de 1KΩ
9 Module GSM SIM800L
10 Module GPS NEO-6M
11 LED verte
12 LED bleu
13 LED rouge
14 Résistance de 150Ω (1)
15 Résistance de 150Ω (2)
16 Résistance de 150Ω (3)
17 Résistance de 150Ω (4)
18 Résistance variable
19 Afficheur LCD 16x2
20 Clavier matriciel 4x4
21 Haut-parleur
22 Carte Arduino Mega 2560
23 Convertisseur DC-DC LM2596 (1)
24 Convertisseur DC-DC LM2596 (2)
25 Convertisseur DC-DC LM2596 (3)
26 Convertisseur DC-DC LM2596 (4)
27 Convertisseur DC-DC LM2596 (5)
Tableau IV. 10 : nomenclature du schéma de câblage
CHAPITRE V Réalisation de la poubelle intelligente
IV.6.10.2. Principe de fonctionnement
Le fonctionnement de ce schéma est directement lié au programme (code) stocké dans la
carte Arduino. Ce schéma fonctionne en respectant les instructions indiquées dans le programme.
En effet le fonctionnement se fait en deux grandes parties : Initialisation et Boucle. La
première partie (Initialisation) s’exécute en premier et une seule fois lorsqu’on met sous-tension
le montage, par contre la deuxième partie s’exécute après la première et en boucle aussi
longtemps que le montage reste sous-tension. Et dans chaque partie, le fonctionnement se
déroule de façon séquentielle, c’est-à-dire étape par étape.
IV.[Link]. Initialisation
On branche l’adaptateur AC/DC sur la prise jack d’alimentation ;
On appuie sur l’interrupteur d’alimentation, ce qui entraîne la mise sous-tension du
montage ;
Affichage de l’écran LCD ;
Allumage de la LED verte ;
Connexion du module GSM au réseau ;
Temporisation de 20 secondes ;
Envoi d’un SMS par le module GSM ;
Positionnement des deux servomoteurs respectivement à 40° et 175° ;
Connexion du module GPS au satellite ;
Allumage de la LED bleue.
IV.[Link]. Boucle
Si le premier capteur à ultrason détecte un objet à une distance de moins de 15cm :
Positionnement des deux servomoteurs respectivement à 180° et 35° ;
Temporisation de 15 secondes ;
Positionnement des deux servomoteurs respectivement à 40° et 175° ;
Si le deuxième capteur à ultrason détecte un objet à une distance comprise entre 5cm et
10cm :
Appel téléphonique par le module GSM ;
CHAPITRE V Réalisation de la poubelle intelligente
Temporisation de 3 secondes ;
Envoi d’un SMS par le module GSM ;
Si le deuxième capteur à ultrason détecte un objet à une distance de moins de 5cm :
Extinction de la LED verte et allumage de la LED rouge ;
Appel téléphonique par le module GSM ;
Temporisation de 3 secondes ;
Envoi d’un SMS par le module GSM ;
Si le premier capteur à ultrason détecte un objet à moins de 15cm :
Fonctionnement du haut-parleur ;
Si on rentre un code à quatre caractères sur le clavier et il est correct :
Positionnement des deux servomoteurs respectivement à 180° et 35° ;
Affichage de l’écran LCD ;
Temporisation de 20 secondes ;
Positionnement des servomoteurs respectivement à 40° et 175° ;
Extinction de la LED rouge et allumage de la LED verte ;
Si on appuie sur la touche « # » du clavier :
Affichage de l’écran LCD.
Si on rentre un code à quatre caractères sur le clavier et il est incorrect :
Affichage de l’écran LCD ;
Temporisation de 10 secondes ;
Affichage de l’écran LCD.
CHAPITRE V Réalisation de la poubelle intelligente
IV.7. Code source de la poubelle
C’est le programme que nous avons téléverser dans la carte Arduino pour faire fonctionner
la poubelle. Et il est divisé en trois parties.
Dans un premier temps, nous avons déclaré les variables et inclus les bibliothèques
nécessaires au fonctionnement de certains composants. La deuxième partie c’est la fonction
setup ou encore fonction d’initialisation, les instructions contenues dans cette fonction s’exécute
une seule fois lors de l’alimentation de la carte Arduino. Et enfin la troisième partie qui concerne
la fonction loup ou la boucle, c’est le cœur du programme, elle s’exécute en boucle aussi
longtemps la carte Arduino reste allumée.
Pour faciliter la compréhension du code, chaque ligne de ce code est accompagnée d’un
commentaire.
IV.7.1. Déclaration des variables et inclusion des bibliothèques
/* Initialisation des bibliothèques */
#include <TinyGPS++.h> /* Pour le module GPS */
#include <LiquidCrystal.h> /* Pour l'écran LCD */
#include <Keypad.h> /* Pour le clavier matriciel 4x4 */
#include <Servo.h> /* Pour les servomoteurs */
#include <DFRobotDFPlayerMini.h> /* Pour le module DFPlayer Mini MP3 */
/* Configuration des objets */
TinyGPSPlus gps; /* L'objet TinyGPSPlus */
LiquidCrystal lcd(11, 10, 5, 4, 3, 2); /* L'objet LiquidCrystal */
Servo monServo1;/*Créer un objet Servo pour contrôler le premier servomoteur*/
Servo monServo2;/*Créer un objet Servo pour contrôler le second servomoteur */
DFRobotDFPlayerMini player; /* L'objet DFRobotDFPlayerMini */
/* Configuration des variables */
/* créer une variable pour la latitude et la longitude */
double lat, lon;
/*Cette variable stockera le lien google maps contenant la latitude et la
longitude en provenance du module GPS*/
String lien_google_maps;
/*Le nombre de chiffres plus un caractère nul (4+1= 5) définit la longueur du
mot de passe*/
#define Longueur_du_mot_de_passe 5
/* Cette variable stockera l'entrée de l'utilisateur dans une chaîne */
char EntreeUtilisateur[Longueur_du_mot_de_passe];
/* Cette variable contient le mot de passe correct auquel la chaine
utilisateur doit correspondre */
char Mot_de_passe_correct[Longueur_du_mot_de_passe] = "2002";
/*Cette variable contient un compteur pour le nombre de fois où les touches du
clavier ont été enfoncées*/
byte EntreeUtilisateur_compteur = 0;
CHAPITRE V Réalisation de la poubelle intelligente
/* Cette variable contient l'entrée de chaque touche enfoncée */
char EntreeTouche;
/* Configuration du clavier */
const byte Lignes = 4; /* Constantes pour le nombre de lignes et */
const byte Colonnes = 4; /* colonnes du clavier */
/* Disposition physique du clavier utilisé dans ce projet */
char Touches[Lignes][Colonnes] =
{
{'1', '2', '3', 'A'},
{'4', '5', '6', 'B'},
{'7', '8', '9', 'C'},
{'*', '0', '#', 'D'}
};
bool Smart_Bin = true;
/*Définit comment les pins de ligne du clavier sont connectées avec
l'Arduino*/
byte Pins_de_ligne[Lignes] = {53, 51, 49, 47};
/*Définit comment les pins de colonne du clavier sont connectées avec
L'Arduino*/
byte Pins_de_colonne[Colonnes] = {45, 43, 41, 39};
/* Créer un objet Keypad */
Keypad monClavier ( makeKeymap(Touches), Pins_de_ligne, Pins_de_colonne,
Lignes, Colonnes);
String MessageEntrant = ""; /* Variable pour stocker le message entrant */
/* Variable pour stocker le numéro de téléphone */
const String PHONE = "+213792663584";
/*Ces trois variables permettent de définir le nombre de fois qu'une boucle
sera exécutée*/
int Ikama = 0;
int Verlan = 0;
int Chrice = 0;
/* Configuration des variables pour le premier capteur à ultrason HC-SR04 */
int pinTrig1 = 6; /* La broche Trig est connecté à la Pin 6 de la carte
Arduino */
int pinEcho1 = 7; /* La broche Echo est connecté à la Pin 7 de la carte
Arduino */
double duree1, distance1;
/* Configuration des variables pour le deuxième capteur à ultrason HC-SR04 */
int pinTrig2 = 8; /* La broche Trig est connecté à la Pin 8 de la carte
Arduino */
int pinEcho2 = 9; /* La broche Echo est connecté à la Pin 9 de la carte
Arduino */
/* T_D_R = taux de remplissage */
double duree2, distance2, DistanceMax = 0, T_D_R = 0;
/* L'anode de la LED rouge est connecté à la Pin 32 de la carte Arduino */
int LedRouge = 32;
/* L'anode de la LED verte est connecté à la Pin 30 de la carte Arduino */
int LedVerte = 30;
/* L'anode de la LED bleue est connecté à la Pin 36 de la carte Arduino */
int LedBleue = 36;
/* variables de temps */
unsigned long TempsReel1 = 0;
unsigned long DernierTemps1 = 0;
int delay1 = 20000;
CHAPITRE V Réalisation de la poubelle intelligente
IV.7.2. Fonction setup
/* Configurer le nombre de colonnes et de lignes de l'écran LCD */
[Link](16, 2);
/* Placer le curseur sur la quatrième colonne de la première ligne de
l'écran */
[Link](4, 0);
[Link]("POUBELLE"); /* Afficher ce mot sur l'écran */
[Link](2, 1); /* Placer le curseur sur (2, 1) */
[Link]("MADE IN IKAMA"); /* Afficher cette phrase sur l'écran */
pinMode(pinTrig1, OUTPUT); /* Configurer pinTrig1 comme une sortie */
pinMode(pinEcho1, INPUT); /* Configurer pinEcho1 comme une entrée */
pinMode(pinTrig2, OUTPUT); /* Configurer pinTrig2 comme une sortie */
pinMode(pinEcho2, INPUT); /* Configurer PinEcho2 comme une entrée */
pinMode(LedRouge, OUTPUT); /* Configurer LedRouge comme une sortie */
pinMode(LedVerte, OUTPUT); /* Configurer LedVerte comme une sortie */
pinMode(LedBleue, OUTPUT); /* Configurer LedBleue comme une sortie */
digitalWrite(LedRouge, LOW); /* Mettre LedRouge en position bas */
digitalWrite(LedVerte, HIGH); /* Mettre LedVerte en position haut */
digitalWrite(LedBleue, LOW); /* Mettre LedBleue en position bas */
while (millis() < 4000)
{
/* Mettre pinTrig2 au niveau bas */
digitalWrite(pinTrig2, LOW);
delayMicroseconds(2);
/* Mettre pinTrig2 au niveau haut pendant 10 microsecondes */
digitalWrite(pinTrig2, HIGH);
delayMicroseconds(10);
digitalWrite(pinTrig2, LOW);
/*Lit pinEcho2, renvoie le temps de parcours de l'onde sonore en
microsecondes*/
duree2 = pulseIn(pinEcho2, HIGH);
/* Calcul la distance2 */
distance2 = duree2 * 0.034 / 2;
/* Calcul la distance maximale */
DistanceMax = max(DistanceMax, distance2);
}
/* Initialisation de la communication série */
[Link](9600); /* débit en bauds pour le module GPS */
[Link](9600); /* débit en bauds pour le module DFPlayer */
[Link](9600); /* débit en bauds le module GSM */
delay(20000); /* Donner le temps au module GSM de se connecter au réseau */
[Link]("AT+CMGF=1\r"); /* Mettre le module GSM en mode text */
delay(100);
/* Configurer le module GSM pour récevoir des messages */
[Link]("AT+CNMI=2,2,0,0,0\r");
delay(100);
WelcomeMessage(); /* Faire appel à la fonction WelcomeMessage */
CHAPITRE V Réalisation de la poubelle intelligente
/* Rélier le servomoteur1 à la pin 12 de la carte Arduino */
[Link](12);
/* Rélier le servomoteur2 à la pin 13 de la carte Arduino */
[Link](13);
[Link](40); /* Positionner le servomoteur1 à 40° */
[Link](175); /* Positionner le servomoteur2 à 175° */
/* Démarrer la communication avec le module DFPlayer Mini MP3 */
if ([Link](Serial3))
{
[Link](30); /* Réglez le volume à 30 */
[Link](); /* Effacer l'écran LCD */
}
IV.7.3. Fonction loup
TempsReel1 = millis();
if (Smart_Bin == 0)
{
/* Récupérer la touche entrée par l'utilisateur */
EntreeTouche = [Link]();
if (EntreeTouche == '#') /* Si l'utilisateur appuie sur la touche # */
{
Chrice = 0;
[Link](); /* Efface l'écran LCD */
ServoClose(); /* On fait appel à la fonction ServoClose */
[Link](2, 0); /* Placer le curseur sur (2, 0) */
[Link](" FERMEE"); /* Affiche le mot " FERMEE " sur l'écran */
delay(3000); /* Attendre 3 secondes */
Smart_Bin = 1;
}
}
else Open();
/* Tant que les données sont disponibles sur le port série 1 */
while ([Link]())
{
/* Si les données sont envoyées à la fonction d'encodage */
if ([Link]([Link]()))
{
displayInfo(); /* Faire appel à la fonction displayInfo */
}
}
/* Mettre pinTrig1 au niveau bas */
digitalWrite(pinTrig1, LOW);
delayMicroseconds(2);
/* Mettre pinTrig1 au niveau haut pendant 10 microsecondes */
CHAPITRE V Réalisation de la poubelle intelligente
digitalWrite(pinTrig1, HIGH);
delayMicroseconds(10);
digitalWrite(pinTrig1, LOW);
/*Lit pinEcho1, renvoie le temps de parcours de l'onde sonore en
microsecondes*/
duree1 = pulseIn(pinEcho1, HIGH);
/* Calcul la distance1 */
distance1 = duree1 * 0.034 / 2;
/* Mettre pinTrig2 au niveau bas */
digitalWrite(pinTrig2, LOW);
delayMicroseconds(2);
/* Mettre pinTrig2 au niveau haut pendant 10 microsecondes */
digitalWrite(pinTrig2, HIGH);
delayMicroseconds(10);
digitalWrite(pinTrig2, LOW);
/*Lit pinEcho2, renvoie le temps de parcours de l'onde sonore en
microsecondes*/
duree2 = pulseIn(pinEcho2, HIGH);
/* Calcul la distance2 */
distance2 = duree2 * 0.034 / 2;
T_D_R = 100 - distance2*100/DistanceMax; /*Calcul du taux de remplissage */
/* Contraindre le taux de remplissage entre les valeurs 0 et 100 */
T_D_R = constrain(T_D_R, 0, 100);
/* Si la distance mesurée par le deuxième capteur est supérieur à 5cm */
if (distance2 > 5)
{
Ikama = 0;
digitalWrite(LedRouge, LOW); /* Eteindre la Led rouge */
digitalWrite(LedVerte, HIGH); /* Allumer la Led verte */
/* Si la distance mesurée par le premier capteur est inférieur à 15cm */
if (distance1 < 15 )
{
ServoOpen(); /* Faire appel à la fonction ServoOpen */
}
else
{
if ((TempsReel1 - DernierTemps1) > delay1)
{
DernierTemps1 = TempsReel1;
if (distance1 > 15 )
{
ServoClose();
}
}
}
}
CHAPITRE V Réalisation de la poubelle intelligente
if (distance2 < 5 && distance1 > 15 ) {
digitalWrite(LedVerte, LOW);
digitalWrite(LedRouge, HIGH);
if ( Ikama < 1) { /* Passer dans cette boucle une seule fois */
PasserAppel(); /* Passer l'appel */
delay(3000); /* Attendre 3 secondes */
EnvoyerPosition(); /* Envoyer la localisation de la poubelle */
Ikama = Ikama + 1;
}
}
if (distance2 < 5 ) {
if (distance1 < 15 ) {
if ( Verlan < 1) {
[Link](1);
Verlan = Verlan + 1;
}
}
if (distance1 > 15 ) {
Verlan = 0;
}
}
if ( distance2 > 5 && distance2 < 10 && distance1 > 15 ) {
if ( Chrice < 1) {
PasserAppel();
delay(3000);
Avertissement();
Chrice = Chrice + 1;
}
}
RecevoirMessage(); /* Faire appel à la fonction RecevoirMessage */
/* Si le message entrant est " Position " */
if ([Link]("Position") >= 0)
{
Position(); /* Faire appel à la fonction Position */
}
/* Si le message entrant est " Taux " */
if ([Link]("Taux") >= 0)
{
Taux(); /* Faire appel à la fonction Taux */
}
}
CHAPITRE V Réalisation de la poubelle intelligente
void RecevoirMessage()
{
/* Vérifier si les données sont disponibles sur le port série 2 */
if ([Link]() > 0)
{
/* Ajouter tous caractères entrants à la chaîne */
MessageEntrant = [Link]();
}
}
void Position()
{
[Link]("AT+CMGF=1"); /* Mettre le module GSM en mode text */
delay(1000);
/* Entrer le numéro de téléphone */
[Link]("AT+CMGS=\"" + PHONE + "\"\r");
delay(1000);
/* Le message à envoyer */
[Link]("VOICI MA POSITION EXACTE");
[Link](lien_google_maps);
delay(100);
[Link]((char)26); /* Code ASCII de CTRL+Z */
delay(1000);
}
void Taux()
{
[Link]("AT+CMGF=1");
delay(1000);
[Link]("AT+CMGS=\"" + PHONE + "\"\r");
delay(1000);
[Link]("Taux de remplissage: ");
[Link](T_D_R);
[Link]("%");
delay(100);
[Link]((char)26);
delay(1000);
}
void PasserAppel()
{
[Link]("ATD" + PHONE + ";"); /* Passer un appel téléphonique */
delay(20000); /* Attendre 20 secondes */
[Link]("ATH"); /* Racrocher l'appel */
delay(1000); /* Attendre 1 seconde */
}
void WelcomeMessage()
{
[Link]("AT+CMGF=1");
delay(1000);
[Link]("AT+CMGS=\"" + PHONE + "\"\r");
delay(1000);
CHAPITRE V Réalisation de la poubelle intelligente
[Link]("SALUT, JE SUIS DEJA CONNECTE AU RESEAU");
delay(1000);
[Link]((char)26);
delay(1000);
}
void EnvoyerPosition()
{
[Link]("AT+CMGF=1");
delay(1000);
[Link]("AT+CMGS=\"" + PHONE + "\"\r");
delay(1000);
[Link]("JE SUIS PLEINE, VOICI MA POSITION :");
[Link](lien_google_maps);
[Link]("Taux de remplissage: ");
[Link](T_D_R);
[Link]("%");
delay(100);
[Link]((char)26);
delay(1000);
}
void Avertissement()
{
[Link]("AT+CMGF=1");
delay(1000);
[Link]("AT+CMGS=\"" + PHONE + "\"\r");
delay(1000);
[Link]("JE SERAIS BIENTOT REMPLIE , VOICI MA POSITION :");
[Link](lien_google_maps);
[Link]("Taux de remplissage: ");
[Link](T_D_R);
[Link]("%");
delay(100);
[Link]((char)26);
delay(1000);
}
void displayInfo()
{
if ([Link]())
{
digitalWrite(LedBleue, HIGH);
latitude = [Link]();
longitude = [Link]();
lien= "[Link]/maps/place/" + String(lat, 6) + "," + String(lon, 6);
}
}
void clearData()
{
/* tant que l'entrée de l'utilisateur est différent de zéro */
while (EntreeUtilisateur_compteur != 0)
{
CHAPITRE V Réalisation de la poubelle intelligente
/*Efface les données d'entrée de l'utilisateur, les données numériques et
de chaîne sont rémise à zéro*/
EntreeUtilisateur[EntreeUtilisateur_compteur--] = 0;
}
return;
}
void ServoOpen()
{
[Link](180); /* Positionner le servomoteur1 à 180° */
[Link](35); /* Positionner le servomoteur2 à 35° */
}
void ServoClose()
{
[Link](40); /* Positionner le servomoteur1 à 40° */
[Link](175); /* Positionner le servomoteur2 à 175° */
}
void Open()
{
/* Positionne le curseur sur la première colonne de la première ligne de
l'écran */
[Link](1, 0);
/* Affiche la phrase " MOT DE PASSE " sur l'écran LCD */
[Link](" MOT DE PASSE");
/* Récupérer la touche entrée par l'utilisateur */
EntreeTouche = [Link]();
if (EntreeTouche) /* Si la touche est récupérée */
{
/*La chaîne de mot de passe est collectée par la variable EntreeUtilisateur*/
EntreeUtilisateur[EntreeUtilisateur_compteur] = EntreeTouche;
/* Afficher l'entrée de l'utilisateur sur l'écran */
[Link](EntreeUtilisateur_compteur, 1);
[Link]("*"); /* Les astérisques sont imprimés pour la confidentialité*/
/*Le nombre d'appuie sur les touches se déroulera jusqu'à ce 4 chiffres
soient entrés*/
EntreeUtilisateur_compteur++;
}
/*Si la chaîne d'entrée de l'utilisateur est égale à longueur du mot de
passe moins 1*/
if (EntreeUtilisateur_compteur == Longueur_du_mot_de_passe - 1)
{
/*Si la chaîne d'entrée de l'utilisateur correspond à la chaîne de mot de
passe Mot_de_passe_correct*/
if (!strcmp(EntreeUtilisateur, Mot_de_passe_correct))
{ /* Exécute ces instructions avant de revenir au début */
[Link]();
ServoOpen();
[Link](2, 0);
[Link](" OUVERTE");
[Link](0, 1);
CHAPITRE V Réalisation de la poubelle intelligente
[Link](" APPUYER SUR # ");
delay(20000);
Smart_Bin = 0;
}
/*Sinon si la chaîne d'entrée de l'utilisateur ne correspond pas à la
chaîne de mot de passe Mot_de_passe_correct*/
else
{ /* Exécute les instructions suivantes */
[Link]();
[Link](0, 0);
[Link]("CODE INCORRECT");
[Link](0, 1);
[Link]("REESSAYER");
[Link](13, 1);
[Link]("10");
delay(1000);
[Link](13, 1);
[Link]("09");
delay(1000);
[Link](13, 1);
[Link]("08");
delay(1000);
[Link](13, 1);
[Link]("07");
delay(1000);
[Link](13, 1);
[Link]("06");
delay(1000);
[Link](13, 1);
[Link]("05");
delay(1000);
[Link](13, 1);
[Link]("04");
delay(1000);
[Link](13, 1);
[Link]("03");
delay(1000);
[Link](13, 1);
[Link]("02");
delay(1000);
[Link](13, 1);
[Link]("01");
delay(1000);
[Link](13, 1);
[Link]("00");
delay(1000);
[Link]();
Smart_Bin = 1;
}
clearData();
}
}
CHAPITRE V Réalisation de la poubelle intelligente
IV.8. Réalisation pratique de la poubelle
IV.8.1. La poubelle utilisée
Pour concrétiser notre projet, nous avons utilisé la poubelle en plastiques suivante.
Figure IV. 22 : la poubelle utilisée
IV.8.2. Les étapes de la réalisation
IV.8.2.1. Fixation des composants sur la poubelle
La première étape consiste à fixer tous les composants sur la poubelle.
Figure IV. 23 : fixations des composants sur la poubelle
CHAPITRE V Réalisation de la poubelle intelligente
IV.8.2.2. Réalisation des bras articulés
Ce sont des mécanismes en bois qui permettent aux servomoteurs de soulever et baisser le
couvercle de la poubelle.
Figure IV. 24 : les bras articulés
IV.8.2.3. Fixation des bras sur la poubelle
Figure IV. 25 : fixation des bras articulés sur la poubelle
CHAPITRE V Réalisation de la poubelle intelligente
IV.8.2.4. Câblage
Figure IV. 26 : le câblage réalisé
IV.8.3. Résultat final
Figure IV. 27 : la poubelle intelligente
CHAPITRE V Réalisation de la poubelle intelligente
IV.9. Prix d’achat des composants
Ce tableau présente le prix de chaque composant utilisé dans ce projet ainsi que le prix total
d’achat de l’ensemble des composants.
Composant Nombre Prix unitaire Montant
Carte Arduino Mega 2560 (original) 1 9000 DA 9000 DA
Capteur à ultrason HC-SR04 2 600 DA 1200 DA
Servomoteur MG996R 2 1700 DA 3400 DA
Module GSM SIM800L EVB 1 2500 DA 2500 DA
Module GPS NEO-6M 1 2500 DA 2500 DA
Module DFPlayer Mini MP3 1 1300 DA 1300 DA
Convertisseur DC-DC LM2596 5 550 DA 2750 DA
Afficheur LCD 16x2 1 1000 DA 1000 DA
Clavier matriciel 4x4 1 300 DA 300 DA
LED 3 10 DA 30 DA
Résistance fixe 6 5 DA 30 DA
Résistance variable 1 15 DA 15 DA
Interrupteur à bascule ON/OFF 1 100 DA 100 DA
Adaptateur AC/DC 1 1500 DA 1500 DA
Boîte de dérivation 1 800 DA 800 DA
Poubelle 1 2500 DA 2500 DA
Platine d’essai 1 1800 DA 1800 DA
Total 30 725 DA
Tableau IV. 11 : prix d’achat des composants
CHAPITRE V Réalisation de la poubelle intelligente
IV.10. Conclusion
Dans ce chapitre, nous avons décrit la constitution de notre poubelle intelligente ainsi que
son principe de fonctionnement. Ensuite on a expliqué comment brancher des différents
composants utilisés avec la carte Arduino, puis nous avons présenté le schéma de câblage
général de la poubelle tout en expliquant son principe de fonctionnement. Pour finir, on a
présenté le code source de la poubelle, les différentes étapes de la réalisation pratique de notre
projet, et nous avons introduit dans un tableau le prix d’achat de chaque composant utilisé.
