Académique Documents
Professionnel Documents
Culture Documents
CHANTELOUP Marc
COLLIOT Delphine Le 12/06/2018
THIBAULT Théo
Groupe : 5
1
2
Table des matières
Introduction ........................................................................................................... 5
Cahier des charges ................................................................................................. 6
Présentation du projet ....................................................................................... 6
Listes des composants nécessaires et budget ................................................... 6
Explication du fonctionnement .......................................................................... 7
Objectifs ............................................................................................................. 7
Gérer individuellement les différents capteurs ....................................................... 8
Capteur de luminosité ....................................................................................... 8
Schéma électrique ......................................................................................... 8
Fonctionnement ............................................................................................ 8
Branchement à l’Arduino ............................................................................... 9
Code ............................................................................................................... 9
Capteur de température .................................................................................. 10
Schéma électrique ....................................................................................... 10
Fonctionnement .......................................................................................... 10
Branchement à l’Arduino ............................................................................. 11
Code ............................................................................................................. 12
Capteur d’humidité .......................................................................................... 13
Fonctionnement .......................................................................................... 13
Branchement à l’Arduino ............................................................................. 13
Code ............................................................................................................. 13
Gérer les actionneurs grâce aux capteurs ............................................................. 14
Les LED ............................................................................................................. 14
Schéma électrique ....................................................................................... 14
Branchement ............................................................................................... 15
Code ............................................................................................................. 15
Le ventilateur ................................................................................................... 16
Schéma électrique ....................................................................................... 16
Branchement ............................................................................................... 17
Code ............................................................................................................. 17
3
La pompe à eau................................................................................................ 18
Schéma électrique ....................................................................................... 18
Branchement ............................................................................................... 18
Code ............................................................................................................. 19
Le niveau d’eau en réserve .............................................................................. 20
Fonctionnement .......................................................................................... 20
Code ............................................................................................................. 20
Affichage .......................................................................................................... 21
Affichage des données ................................................................................. 21
Affichage lors de l’arrosage.......................................................................... 21
L’application ..................................................................................................... 22
Description ................................................................................................... 22
AppInventor 2 .............................................................................................. 22
Arduino ........................................................................................................ 24
Code ............................................................................................................. 24
Rendu final de l’application : ....................................................................... 25
CONCLUSIONS .................................................................................................. 26
Annexes............................................................................................................ 27
Annexe 1 : Capteur ultrason ........................................................................ 27
Annexe 2 : Capteur hygrométrique .............................................................. 30
Annexe 3 : Capteur de température ............................................................ 32
Annexe 4 : Capteur de luminosité ................................................................ 34
Annexe 5 : Capteur Bluetooth...................................................................... 37
Annexe 6 : Schéma complet......................................................................... 39
Annexe 7 : Code complet ............................................................................. 40
Annexe 8 : Chronologie ................................................................................ 60
4
Introduction
Dans le cadre de la deuxième année au sein de l’ESIEE, nous avons dû réaliser
un projet. Le thème était de faire une application sur Arduino. Nous avons choisi de
réaliser un projet personnel qui devait répondre à la problématique suivante :
Comment créer un potager capable de se gérer de manière automatique ?
Pour réaliser ce projet nous avons d’abord écrit un cahier des charges puis nous
avons suivi un planning pour avancer étape par étape dans le projet. Ci-dessous, un
schéma récapitulatif des composants utilisés.
5
Cahier des charges
Nous avons tout d’abord établi un cahier des charges pour avoir un fil directeur
pendant la réalisation de notre projet. Nous avons également organisé un planning
pour pouvoir vérifier si notre avancement était correct et si nous n’avions pas de
retard (cf annexe ).
Présentation du projet
Le projet aura pour but de créer un potager avec un arrosage auto-géré. Notre
potager connecté enregistrera également les différentes variables extérieures
essentielles à la pousse d’une plante et les affichera sur le potager.
De plus, si nous arrivons à un système performant et fonctionnel, nous
implémenterons une connexion bluetooth pour collecter les données de nos différents
capteurs, sur un device (téléphone, ordinateur).
L’objectif étant ensuite de les traiter sur ce device (exploitation de données via
des graphiques par exemples). En fonction de notre avancement nous comptons
également gérer l’éclairement et la température de la plante.
Pour réaliser ce projet nous avons donc besoin d’une liste de composants :
• Capteurs de :
- Température
- Lumière
- Humidité/hydrométrie
- Indicateur de niveau d’eau (capteur ultra-son)
• Moteurs/Pompe à eau
• LED blanches
• Modules bluetooth
• Ecran LCD
• LED (indicatrice rouge/verte)
• Ventilateur
6
Explication du fonctionnement
Objectifs
7
Gérer individuellement les différents capteurs
Pour commencer, nous avons réalisé les montages de chaque capteur, leur
calibrage ainsi que leur code.
Capteur de luminosité
Schéma électrique
A1
1
Fonctionnement
8
Branchement à l’Arduino
Source :http://www.manuel-esteban.com/arduino-capteur-de-luminosite/
Code
9
Capteur de température
Schéma électrique
A2
1
On doit alors déterminer la résistance à utiliser. D’après la fiche capteur, le TMP36 peut
recevoir un courant de 0,05mA. On utilise donc une résistance de 723 kΩ.
Fonctionnement
10
Source : https://learn.adafruit.com/tmp36-temperature-sensor/
Branchement à l’Arduino
Ici encore, la donnée reçue par l’Arduino varie donc on doit le relier à un pin
analogique.
Source : https://forum.arduino.cc/index.php?topic=239264.0
11
Code
12
Capteur d’humidité
Enfin pour pouvoir savoir quand la terre a besoin d’être arrosée, on utilise un
capteur hygrométrique. Le but est de retourner le pourcentage d’humidité du sol et
d’activer l’arrosage si besoin. (cf annexe )
Fonctionnement
Branchement à l’Arduino
Source : http://www.orbit-dz.com/produit/scanner-automobile-2/arduino-compatibles/shields-et-
accessoires/temp%C3%A9rature-humidit%C3%A9_shields/module-humidite-sol-detail
Code
13
Gérer les actionneurs grâce aux capteurs
Les LED
Une fois que le niveau de luminosité est récupéré, on cherche à l’adapter pour
que les conditions d’éclairement de la plante soient optimales. Pour cela on ajoute des
LED au circuit pour éclairer la plante lorsque la luminosité est trop basse.
Schéma électrique
A1
1
−𝑉𝑠 + 𝑉𝑙𝑒𝑑
𝐼= ⇔ 𝑅 = 380Ω
𝑅
14
Branchement
Code
15
Le ventilateur
Schéma électrique
16
Donc on obtient une résistance d’environ 1kΩ.
On utilise une diode pour éviter qu’en cas de coupure d’alimentation, le moteur
ne s’arrête pas brusquement, ce qui pourrait l’endommager.
Branchement
Code
17
La pompe à eau
Enfin, si la terre est trop sèche, on actionne une pompe à eau pour arroser les
plantes. On ajoute donc au montage la pompe à eau.
Schéma électrique
Branchement
18
Code
19
Le niveau d’eau en réserve
Pour gérer la réserve d’eau, nous avons décidé d’utiliser un capteur à ultrasons.
Le principe est simple : le bac à eau contient une petite surface flottante, aligner dans
l’axes du capteur à ultrasons.
Fonctionnement
Si la surface est au fond du bac cela implique que le bac à eau est vide est que
nous devons le remplir, si la distance entre le flotteur et le capteur est égale à environ
2cm c’est que le bac à eau est plein. En effet nous avons laissé une distance de 2 cm
entre la hauteur maximale atteinte par l’eau et le capteur pour plusieurs raisons.
Premièrement, pour éviter que le capteur entre en contact avec l’eau. Deuxièmement
les mesures en dessous de 2cm perdent en précision à cause de l’angle d'émission de
l’onde. La distance est trop courte ce qui favorise les échos et nuit à la précision du
capteur.
Code
20
Affichage
Les valeurs qui sont récupérés par les différents capteur sont ensuite affichés
sur l'écran LCD avec des icônes comme suit :
21
Lorsque l’arrosage est en cours, celui-ci s’affiche sur l'écran LCD , seul le menu
est prioritaire sur cette affichage.
L’application
Description
Nous avons décidé de réaliser une application afin de gérer à distance les
différents éléments (arrosage, ventilation, éclairage) de notre potager connecté.
Pour cela, nous avons utiliser le module bluetooth RN-42 afin de communiquer
avec un téléphone.
Nous n’avons cependant réussi pour l’instant que la liaison bluetooth dans un
sens (téléphone vers arduino), dès qu’on mettre la liaison dans les deux sens, les
données ne sont plus bonnes.
AppInventor 2
22
la partie block qui permet de gérer les données envoyées/reçues :
Ces données seront ensuite récupérées par le module bluetooth (cf. annexe) et
23
traitées par l’arduino pour permettre la ventilation, l’arrosage ou l’éclairage du
potager.
Arduino
Nous avons codé l’arduino de telle manière que les données reçues des capteurs
soient plus importantes que celles du bluetooth ou du menu.
Code
24
Rendu final de l’application :
25
CONCLUSIONS
Après un semestre de travail nous sommes arrivés, et même plus loin que ce
que nous avions déterminer lors de notre premier cahier des charges et nous aurions
souhaité apporter encore d’autre modifications à ce projet cependant, Au travers de
ce projet nous avons créé de solide connaissance théorique et technique sur l’arduino
est ses applications ainsi que sa mise en œuvre. Nous avons appris à travailler en
équipe, se répartir les tâches, s’écouter, discuter et débattre autour des problèmes
rencontré ainsi qu'à leur résolution. Cela nous appris la gestion de projet, nous
sommes partis d’une simple idée entre amis et nous avons construit quelque chose
autour de cette idée qui est désormais fonctionnel et qui a une application
quotidienne.
Cependant nous regrettons de n’avoir pu avoir plus de temps pour finir la
connection bluetooth, en effet nous n’arrivons pas encore à afficher les valeurs
récupérer par nos capteurs.
Nous aurions également aimé rajouter d’autre capteur comme une petite
caméra pour observer l’évolution de la plante.
26
Annexes
Caractéristique technique :
Alimentation: 5 Vcc
Consommation: 15 mA
Fréquence: 40 kHz
Portée: de 6...10 cm à 4 m
Déclenchement: impulsion TTL positive de 10µs
Signal écho: impulsion positive TTL proportionnelle à la distance.
Calcul: distance (cm) = impulsion (µs) / 58
Dimensions: 45 x 21 x 18 mm
27
Le principe de fonctionnement du capteur est entièrement basé sur la vitesse du son.
1. On envoie une impulsion HIGH de 10µs sur la broche TRIGGER du capteur.
2. Le capteur envoie alors une série de 8 impulsions ultrasoniques à 40KHz
(inaudible pour l'être humain, c'est quand plus agréable qu'un biiiiiiiip).
3. Il y a toujours un silence de durée fixe après l'émission des ultrasons pour
éviter de recevoir prématurément un écho en provenance directement du
capteur.
4. Les ultrasons se propagent dans l'air jusqu'à toucher un obstacle et retourne
dans l'autre sens vers le capteur.
5. Le capteur détecte l'écho et clôture la prise de mesure.
Le signal sur la broche ECHO du capteur reste à HIGH durant les étapes 3 et 4, ce
qui permet de mesurer la durée de l'aller-retour des ultrasons et donc de déterminer
la distance.
Branchement :
28
● L’alimentation V+ de la carte Arduino va sur la broche VCC du capteur.
● La broche 0V de la carte Arduino va sur la broche GND du capteur.
● La broche C.1 de la carte Arduino va sur la broche TRIGGER du capteur.
● La broche C.2 de la carte Arduino va sur la broche ECHO du capteur
29
Annexe 2 : Capteur hygrométrique
Capteur Hygromètre
Caractéristique technique :
Interface: compatible Grove
Alimentation: 3,3 ou 5 Vcc
Consommation: 35 mA maxi
Dimensions: 60 x 20 x 13 mm
30
Branchement :
31
Annexe 3 : Capteur de température
Capteur de température
Caractéristique technique :
Consommation typique 60µA
Précision : ±0,75 °C (typique)
Etalonnée directement en degrés Celsius
Gain de la sonde (sortie) : 10 mV/°C
Faible auto-échauffement : 0,08 °C sans courant d'air
Tension d'alimentation : +4 à +30 V c.c. (conseillé +20V)
32
Branchement :
33
Annexe 4 : Capteur de luminosité
Capteur de lumière
Caractéristique technique :
Résistance à la lumière minimum 10 kΩ
Résistance d'obscurité 1MΩ
Temps de chute 5ms
Temps de croissance 35ms
Nombre de broches 2
Résistance à la lumière maximum 50kΩ
Température d'utilisation maximum 75°C
Température minimum de fonctionnement -40°C
Plage de résistance à la lumière 10 kΩ → 50 kΩ
Tension nominale 100 V
Puissance dissipée 80mW
Gamme de température de fonctionnement -40 → +75°C
34
Principe de fonctionnement du capteur :
Une photorésistance est une résistance sensible à la lumière. Cela signifie qu’en
fonction de la lumière qu’elle perçoit sa résistance va varier. Nous avons donc
utiliser cette caractéristique pour réaliser notre montage.
Plus la valeur de la résistance est élevée, plus la sensibilité à la luminosité du
capteur sera grande. Mais pas de panique, ça fonctionne très bien avec des
résistances plus faibles.
35
Branchement :
36
Annexe 5 : Capteur Bluetooth
Caractéristique technique :
Fréquence : de 2,402 à 2,480 GHz
Tension de fonctionnement : de 3,3 à 6 V
Température de fonctionnement : -40 ~ +70 °C
Dimensions : 45 x 16,6 x 3,9 mm
Les données série qui rentrent dans le module sur la patte RX sont envoyés par la
connection Bluetooth. Les données reçues par Bluetooth sont envoyées sur la
broche de sortie Tx.
Dans le mode de données, toutes les données reçues par Bluetooth se retrouvent en
sortie (Broche Tx), tandis que toutes les données imposées à l’entrée du module
Bluetooth (broche Rx) sont envoyées par radio vers l’appareil qui lui est connecté.
37
Branchement :
38
Annexe 6 : Schéma complet
39
Annexe 7 : Code complet
//-------------------------------------------------------------------------------------------------------
---------------------------
//-----------------------------------------------------------BIBLIOTHEQUE------------------------
-----------------------------------
//-------------------------------------------------------------------------------------------------------
---------------------------
#include <Wire.h>
#include <Adafruit_RGBLCDShield.h>
#include <utility/Adafruit_MCP23017.h>
#include <SoftwareSerial.h>
//-------------------------------------------------------------------------------------------------------
---------------------------
//-------------------------------------------------------------VARIABLE-----------------------------
--------------------------------
//-------------------------------------------------------------------------------------------------------
---------------------------
//Ecran
Adafruit_RGBLCDShield lcd = Adafruit_RGBLCDShield();
//Caractères spéciaux
byte thermo[8] = {
B00000, B00100, B01010, B01010, B11111, B11111, B01110, B00000,
};
byte soleil[8] = {
B00000, B10101, B01110, B11111, B01110, B10101, B00000, B00000,
};
byte vapeur[8] = {
B00100, B01110, B11111, B00010, B01000, B00101, B10010, B01000,
};
//***************************************************************
*****************************************************************
*
int bluetoothTx = 2; // TX-O pin of bluetooth mate, Arduino D2
int bluetoothRx = 3; // RX-I pin of bluetooth mate, Arduino D3
int donnees; //donées recues
SoftwareSerial bluetooth(bluetoothTx, bluetoothRx);
40
//***************************************************************
*****************************************************************
*
//variables de temps
unsigned long previousMillis = 0;
const long interval_sec = 1000;
const long interval_min = 60000;
unsigned int h[4] = {1, 2, 0, 0};
String StringHeure;
//***************************************************************
*****************************************************************
*
//Température
const int inPinThermometre = 2;
const int outPinVentilateur = 5;
int temperature;
boolean ventilateur = false;
//***************************************************************
*****************************************************************
*
//Luminosité
const int inPinLuminometre = 1;
const int outPinLED = 10;
int luminosite;
boolean ledON = false;
//***************************************************************
*****************************************************************
*
//Arrosage
int PinAnalogiqueHumidite=0;
int PinNumeriqueHumidite=7;
int PinPompe=9;
int secheresse;
int humidite;
boolean pompe = false;
boolean aro = false;
41
//***************************************************************
*****************************************************************
*
//Capteur de niveu d'eau
int trig = 12 ;
int echo = 11;
float lecture_echo;
int distance;
boolean critique = false;
//-------------------------------------------------------------------------------------------------------
---------------------------
//--------------------------------------------------------------SETUP---------------------------------
------------------------------
//-------------------------------------------------------------------------------------------------------
---------------------------
void setup() {
42
pinMode(outPinLED, OUTPUT); //pin digital pour les outPinLEDs en
sortie
pinMode(inPinLuminometre, INPUT); //pin analogique pour capteur de
luminosité en entrée
//démarage du programme
affichageDemarage();
setHorloge(); //mise à l'heure de l'horloge par l'utilisateur
}
//-------------------------------------------------------------------------------------------------------
---------------------------
//---------------------------------------------------------------LOOP---------------------------------
------------------------------
//-------------------------------------------------------------------------------------------------------
---------------------------
void loop() {
horloge();
application();
43
affichageNormal();
}
thermometre();
//temperature = 20;
luminometre();
humidimetre();
//secheresse = 0;
nvEau();
}
//-------------------------------------------------------------------------------------------------------
---------------------------
//-----------------------------------------------------------VENTILATION---------------------------
---------------------------------
//-------------------------------------------------------------------------------------------------------
---------------------------
//***************************************************************
*****************************************************************
**
//thermometre : recoit et traite les données envoyées par le capteur de
température et recues par l'arduino
void thermometre() {
float val; //initialisation de la variable qui contiendra la valeur
envoyée par le capteur
val = analogRead(inPinThermometre); //on entre dans la variable, la valeur
recue par l'arduino
temperature = val*5/1023*1000/30; // 5V valeur max , 1023 car capteur sur
10 bits ensuite nous convertisson le resultats ( Farhen) en degré celcius.
44
// Serial.print("température : ");
// Serial.print(temperature);
// Serial.println("°C");
}
//***************************************************************
*****************************************************************
**
//ventilation : permet d'activer la pompe
void ventilation() {
if (temperature >= 21 || ventilateur) // condition sur la valeur de la
température : si il fait plus de 21°C ou que l'utilisateur l'actionne
{
digitalWrite(outPinVentilateur, HIGH); //Sortie en numérique
}
else
{
digitalWrite(outPinVentilateur, LOW);
}
}
//-------------------------------------------------------------------------------------------------------
---------------------------
//------------------------------------------------------------ECLAIRAGE----------------------------
---------------------------------
//-------------------------------------------------------------------------------------------------------
---------------------------
//***************************************************************
*****************************************************************
**
//luminometre : recoit et traite les données envoyées par le capteur de
luminosité et recues par l'arduino
void luminometre() {
luminosite = analogRead(inPinLuminometre); //on entre dans la variable, la
valeur recue par l'arduino (en lux compris entre O et 100)
//Serial.print("valeur récupérée par le capteur de luminosité (en lux) : ");
//Serial.println(luminosite);
//Serial.print("luminosité : ");
//Serial.print(luminosite/10);
//Serial.println("%");
45
}
//***************************************************************
*****************************************************************
**
//eclairage : permet d'activer les leds
void eclairage() {
if (ledON || luminosite<400) //Si le nombre de lux est inférieur à 400 (soit
40% de luminosité) ou que l'utilisateur l'actionne
{
digitalWrite(outPinLED, HIGH); //Sortie en numérique
}
else
{
digitalWrite(outPinLED, LOW);
}
}
//-------------------------------------------------------------------------------------------------------
---------------------------
//-------------------------------------------------------------ARROSAGE----------------------------
---------------------------------
//-------------------------------------------------------------------------------------------------------
---------------------------
//***************************************************************
*****************************************************************
**
//humidimetre : recoit et traite les données envoyées par le capteur de
d'humidité et recues par l'arduino
void humidimetre() {
float hsol;
hsol = analogRead(PinAnalogiqueHumidite); // Lit la tension analogique
humidite = (1023-hsol)/7,23; // 1023 nb de bits -1 sur 10 bits diviser
par la valeur 100%
secheresse = digitalRead(PinNumeriqueHumidite); // Lit la tension digitale
46
// Serial.print("humidité : ");
// Serial.print(humidite);
// Serial.println("%");
}
//***************************************************************
*****************************************************************
**
//arrosage : permet d'activer la pompe
void arrosage() {
if (temperature>=7) { //si la température est supérieur à 7°C pour
éviter l'arrosage lorsque les températures sont trop proche des températures de
gèle
if (pompe || secheresse==1) //Si le signal envoyé par le capteur est de 1
ou que l'utilisateur l'actionne
{
aro = true;
digitalWrite(PinPompe, HIGH); //Sortie digital
}
else {
digitalWrite(PinPompe, LOW);
aro = false;
}
}
}
//-------------------------------------------------------------------------------------------------------
---------------------------
//-----------------------------------------------------------NIVEAU D'EAU-------------------------
----------------------------------
//-------------------------------------------------------------------------------------------------------
---------------------------
//***************************************************************
*****************************************************************
**
//nvEau : recoit et traite les données envoyées par le capteur de d'ultrason et
recues par l'arduino pour déterminer le niveau d'eau restant dans la reserve
void nvEau() {
int cm; //initialisation de la variable qui contiendra la valeur
envoyée par le capteur
47
digitalWrite(trig, HIGH); // on ecrit dans le pin digital
delayMicroseconds(10); // imposition d'un delais
//-------------------------------------------------------------------------------------------------------
---------------------------
//------------------------------------------------------------HORLOGE------------------------------
---------------------------------
//-------------------------------------------------------------------------------------------------------
---------------------------
//***************************************************************
*****************************************************************
**
//setHorlaoge : permet de régler l'heure losque la fonction est appelée
void setHorloge() {
48
unsigned int select = 0; //creer une variable qui permettra de
choisir si on change les unités/disaines d'heures et les unités/disaines de
minutes
while(!(lcd.readButtons() & BUTTON_SELECT)){ //on sort du réglage de
l'heure lorsque qu'on appui sur le bouton select
affichageSetHorloge(1); //affichage pendant la modification de
l'heure (voir fonction affichageSetHorloge(1))
if (lcd.readButtons() & BUTTON_LEFT){ //un appui sur le bouton gauche
permet de passer des unités de minutes aux disaines de minutes aux unités
d'heures aux disaines d'heures
if (select == 3) { //si select est égal à 3 (donc si on est sur les
disaines d'heures)
select = select; //on ne va pas plus loin
}
else { //sinon
select = (select+1); //on peut passer des unités de minutes aux
disaines de minutes aux unités d'heures aux disaines d'heures
delay(500);
}
}
if (lcd.readButtons() & BUTTON_RIGHT){ //un appui sur le bouton droit
permet de passer des disaines d'heures aux unités d'heures aux disaines de
minutes aux unités de minutes
select = (select-1)%5;
delay(500);
}
49
break;
}
}
affichageSetHorloge(0); //affichage après la modification de
l'heure pour rappeler l'heure fixée (voir fonction affichageSetHorloge(0))
delay(500);
}
//***************************************************************
*****************************************************************
**
//setDixH : cette fonction permet de modifier les disaines d'heure en appuiant
sur les boutons haut et bas (les fonction suivante foncionnent sur le même
principe)
void setDixH () {
if (lcd.readButtons() & BUTTON_UP) { //si on appui sur le bouton haut les
disaines d'heure augmentes de 1
if (h[1] >= 4) { //si les unité d'heures sont supérieures ou égales
à4
h[0] = (h[0]+1)%2; //les disaine d'heures augmentent d'un
modulo 2 (valeurs entre 0 et 1) cela évite les abération comme 24h ou 25h
}
else { //sinon
h[0] = (h[0]+1)%3; //les disaines d'heures augmente
naturelement de un modulo 3 (valeures entre 0et 2)
}
delay(500);
}
else if (lcd.readButtons() & BUTTON_DOWN) { //si on appui sur le bouton baas
les disaines d'heure diminue de un
h[0] = (h[0]-1)%3; //les disaines d'heure diminue de un modulo
3
delay(500);
}
}
//***************************************************************
*****************************************************************
**
50
void setUnH () {
if (lcd.readButtons() & BUTTON_UP) {
if (h[0] == 2) {
h[1] = (h[1]+1)%4;
}
else {
h[1] = (h[1]+1)%10;
}
delay(500);
}
else if (lcd.readButtons() & BUTTON_DOWN) {
if (h[1] == 0) {
h[1] = 0;
}
else {
h[1] = (h[1]-1);
}
delay(500);
}
}
//***************************************************************
*****************************************************************
**
void setDixMin () {
if (lcd.readButtons() & BUTTON_UP) {
h[2] = (h[2]+1)%6;
delay(500);
}
else if (lcd.readButtons() & BUTTON_DOWN) {
if (h[2] == 0) {
h[2] = 0;
}
else {
h[2] = (h[2]-1);
}
delay(500);
}
}
51
//***************************************************************
*****************************************************************
**
void setUnMin () {
if (lcd.readButtons() & BUTTON_UP) {
h[3] = (h[3]+1)%10;
delay(500);
}
else if (lcd.readButtons() & BUTTON_DOWN) {
if (h[3] == 0) {
h[3] = 0;
}
else {
h[3] = (h[3]-1);
}
delay(500);
}
}
//***************************************************************
*****************************************************************
**
//horloge : permet de faire tourner l'horloge
void horloge () {
unsigned long currentMillis = millis(); //currentMillis est égal au
nombres de milliseconde écoulées depuis le démarrage de l'arduino
if (currentMillis - previousMillis >= interval_min) //si il s'est écoulé 1 minute
{
previousMillis = currentMillis;
h[3] = (h[3]+1)%10; //le nombre de minutes de l'horloge
augmente d'un modulo 10 (valeur comprise entre 0 et 9)
if (h[3] == 0) { //Si le nouveau nombre de minutes est
égale à 0
h[2] = (h[2]+1)%6; //le nombre de disaines de minutes
augmente d'un modulo 6 (valeurs comprises entre 0 et 6)
if (h[2] == 0) { //Si le nouveau nombre de disaines de
minutes est égale à 0
if (h[0] == 2) { // Si le nombre de disaines d'heures est
egal à 2 (heure > 19h59)
h[1] = (h[1]+1)%4; // le nombre d'unité d'heure
52
augmente 1 modulo 4 (20h à 24h)
}
else { // Sinon
h[1] = (h[1]+1)%10; // le nombre d'unité d'heure
augmente de 1 modulo 10 (valeurs comprises entre 0 et 9)
}
if (h[1] == 0) { // Si le nouveau nombre d'unité d'heure est
égale à 0
h[0] = (h[0]+1)%3; // le nombre de disaines d'heures
augmente de un modulo 3 (valeurs comprises entre 0 et 2)
}
}
}
}
}
//***************************************************************
*****************************************************************
***
String getStringHeure () {
return StringHeure = (String) h[0]+(String) h[1]+":"+(String) h[2]+(String) h[3];
//retourne l'heure de la forme XX:XX
}
//-------------------------------------------------------------------------------------------------------
---------------------------
//-----------------------------------------------------------BLUETOOTH----------------------------
----------------------------------
//-------------------------------------------------------------------------------------------------------
---------------------------
//***************************************************************
*****************************************************************
***
//application
void application() {
if(bluetooth.available()) //si le bluetooth envoie un caractère
{
donnees = bluetooth.read(); //on range la donnée recue par bluetooth dan la
variable donnees
//Serial.println(donnees);
53
//Serial.println();
bluetooth.flush(); //on nettoie le bt
if (donnees == 0) { //si la donnee recue est un 0
if (!ventilateur) { //si le ventilateur n'est pas actif
ventilateur = true; //on active le ventilateur
}
else {
ventilateur = false; //sinon on le désactive
}
}
else if (donnees == 1) { //si la donnee recue est un 1
if (!pompe) { //si le ventilateur n'est pas actif
pompe = true; //on active le ventilateur
}
else {
pompe = false; //sinon on la désactive
}
}
else if (donnees == 2) { //si la donnee recue est un 2
if (!ledON) { //si le ventilateur n'est pas actif
ledON = true; //on active le ventilateur
}
else {
ledON = false; //sinon on les désactives
}
}
}
}
//-------------------------------------------------------------------------------------------------------
---------------------------
//-----------------------------------------------------------AFFICHAGE-----------------------------
---------------------------------
//-------------------------------------------------------------------------------------------------------
---------------------------
void affichageNormal() {
lcd.createChar(0, thermo); //
lcd.createChar(1, soleil);
lcd.createChar(2, vapeur);
54
lcd.setCursor(0, 0);
lcd.write(0);
lcd.print(temperature);
lcd.write(223);
lcd.print("C ");
lcd.setCursor(0, 1);
lcd.write(1);
lcd.print(luminosite/10);
lcd.print("% ");
lcd.setCursor(11, 1);
lcd.write(2);
lcd.print(humidite);
lcd.print("%");
lcd.setCursor(11,0);
lcd.print(distance);
lcd.print("% ");
}
//***************************************************************
*****************************************************************
**
void affichageSetHorloge(int a) {
if (a == 0) {
lcd.home();
lcd.print("Vous avez fixe l'heure à :");
lcd.setCursor(0,1);
affichageHorloge();
delay(interval_sec);
lcd.clear();
}
else if (a == 1) {
lcd.home();
lcd.print("Select heure :");
lcd.setCursor(0,1);
affichageHorloge();
}
else {
55
lcd.home();
affichageHorloge();
}
}
//***************************************************************
*****************************************************************
***
void affichageHorloge() {
Serial.println(getStringHeure());
lcd.print(getStringHeure());
}
//***************************************************************
*****************************************************************
***
void affichageArosage() {
Serial.println("Arrosage en cours");
Serial.println();
lcd.clear();
lcd.setCursor(4,0);
lcd.print("Arrosage");
lcd.setCursor(2,1);
lcd.print("en cours ...");
}
//***************************************************************
*****************************************************************
***
void affichageDemarage() {
Serial.println("Atelier E2 : Projet potager connecte 'kiwi'");
Serial.println("Auteurs : Chanteloup Marc, Colliot Delphine, Thibault Theo");
Serial.println("Ce potager connecte recois les information suivantes :");
Serial.println(" -la temperature");
Serial.println(" -l'humidite du sol");
Serial.println(" -la luminosite");
Serial.println(" -le pourcentage d'eau restant en réserve");
Serial.println("Et actionne le cas echeant, les actionneurs suivants :");
Serial.println(" -un ventilateur");
Serial.println(" -une pompe a eau");
56
Serial.println(" -des leds");
Serial.println("Il est egalement capable de communiquer en bluetooth avec un
telephone");
lcd.clear();
lcd.home();
lcd.print(" Atelier E2");
delay(500);
lcd.clear();
lcd.print("Potager connecte");
lcd.setCursor(0,1);
lcd.print(" 'kiwi'");
delay(500);
lcd.clear();
lcd.home();
lcd.print(" Bienvenu !");
delay(500);
}
//***************************************************************
*****************************************************************
***
void menu() {
57
ventilateur = false;
}
delay(100);
break;
}
break;
case 2 :
lcd.print("Arroser");
if (lcd.readButtons() & BUTTON_RIGHT) {
lcd.clear();
if (!pompe) {
pompe = true;
}
else {
pompe = false;
}
delay(100);
break;
}
break;
case 3 :
lcd.print("Eclairer");
if (lcd.readButtons() & BUTTON_RIGHT) {
lcd.clear();
if (!ledON) {
ledON = true;
}
else {
ledON = false;
}
delay(100);
break;
}
break;
case 4 :
lcd.print("Horloge");
if (lcd.readButtons() & BUTTON_RIGHT) {
lcd.clear();
delay(200);
affichageHorloge();
58
delay(interval_sec*10);
break;
}
break;
case 5 :
lcd.print("Changer l'heure");
if (lcd.readButtons() & BUTTON_RIGHT) {
lcd.clear();
delay(100);
setHorloge();
break;
}
break;
}
if (lcd.readButtons() & BUTTON_UP) {
choix = (choix+1)%6;
lcd.clear();
delay(200);
}
else if (lcd.readButtons() & BUTTON_DOWN) {
choix = (choix-1)%10;
lcd.clear();
delay(200);
}
}
}
59
Annexe 8 : Chronologie
Du 29 janvier au 2 février, la seconde semaine de notre atelier nous avons pu, après
avoir pris en main arduino, commencer à réfléchir à notre projet personnel. Dans un
premier temps nous avons pensé à réaliser une prothèse pour capter les zones de
pression sur un membre amputé, faute de réellement connaissance dans le domaine
médicales et au vu des premières réflexion autour du projet, nous avons décidé de
nous orienter vers quelque de plus concret au vu du temps impartie.
Nous sommes donc décider sur un projet de potager connecté dont le détail du cahier
des charges est disponible dans ce rapport.
Lors de la première séance du 29 janvier, nous avons tout d’abord eu une réflexion de
groupe autour du projet que nous avons concrétiser en fixant un cahier des charges,
ainsi qu’un inventaire du matériel dont nous aurions besoin.
Le lendemain nous avons effectué nos premières demandes de matériel et commencer
à chercher sur internet les différents composant qui n'était pas à disposition à l'école.
Nous avons également établi une chronologie pour nous permettre de nous fixer des
deadlines pour différentes version intermédiaire du projet.
Du mercredi au vendredi, ayant à disposition le capteur de température, le capteur de
lumière, les leds ainsi que l'écran LCD. Nous avons commencé à lire la datasheet des
capteurs, pour en comprendre le fonctionnement, ainsi qu’a procédé à des montages
simples, un capteur à la fois.
Nous avons réussi à la fin de la semaine à étalonner le capteur de lumière ainsi qu'à
effectuer son schéma, de même pour le capteur de température.
Nous avons cependant rencontré des problèmes lorsque nous avons souhaité mettre
en commun les capteurs avec les composants avec lesquels ils doivent fonctionner en
parallèles, le capteur de lumière avec les LEDS et le capteur de température avec le
ventilateur.
Mardi 6 février
Première séance de TP en dehors des semaines de projets, nous avons commencé à
nous intéresser à l'interface bluetooth, nous utilisons un capteur bluetooth HC-06.
60
Nous commençons également à afficher les valeurs de nos capteurs de température et
de lumière sur notre écran LCD.
La mise en relation entre les capteurs et les composants ont été mis en pause durant
cette séance.
Mardi 13 février
Dans la continuité de la semaine passée, et pour rendre un meilleur visuel lors de
l’affichage, nous avons codé des icônes qui s’affiche sur l'écran LCD à côté des valeurs
de nos capteurs.
Nous avons repris la mise en relation Capteur/Composant, les leds s’allume désormais
en dessous d’une certaines valeurs (en lux) du capteur de lumière.
Mardi 6 mars
Suite au conseil de monsieur Delabie, et du manque d’information concernant le
capteur bluetooth HC-06, nous avons décidé d’utiliser un capteur RN-42.
Monsieur Delabie nous a mis à disposition un TP de mise en oeuvre du TP pour
pouvoir en découvrir les bases que nous pousserons plus tard.
Désormais le ventilateur se mets en route lorsque la température dépasse un certain
seuil.
Mardi 13 mars
Nous avons commencé à mettre en oeuvre la connection bluetooth, tout d’abord les
branchements, ainsi que le code, problème de compilation lors de l'exécution du code.
Nous avons également essayé de créer notre premier circuit en implémentant, nos
deux premiers capteurs et nos deux premiers composant, sur la même maquette, le
code semble fonctionner nous pensons donc que notre problème vient du montage
électrique.
Nous vérifions que les capteurs marchent toujours séparément.
Mardi 20 mars
Le branchement du module bluetooth, et le code marche, le module rentre de le mode
connection , la LED clignote. Nous n’avons malheureusement pas encore d’application
pour pouvoir y connecter notre module. Nous nous lançons donc dans sa production
en utilisant AppInventor, un site du MIT qui permet de réaliser des applications
mobiles simple pour par exemple connecter notre module bluetooth et
recevoir/envoyer des informations, car nous n’avons pas les connaissances nécessaires
pour développer intégralement l’application seul.
Mardi 3 avril
Le premier circuit marche, il contient le capteur de température et le capteur
d’humidité, ainsi de les LEDS et le ventilateur, le tout relié à l'écran LCD qui affiche les
données.
Nous avançons dans l’application bluetooth mobile, nous prenons bien en main le site
du MIT.
61
Nous recevons la pompe à eau qui nous servira à contrôler l’arrosage via les données
transmise par le capteur d'humidité toujours en cours d’acheminement.
Mardi 10 avril
Le capteur d'humidité vient d’arriver, nous effectuons donc ses branchements ainsi
que son code pour valider son bon fonctionnement avant de l'implémenter au circuit.
Aucun problème rencontré, nous effectuons l'étalonnage du capteur, ainsi que sa mise
en relation avec la pompe à eau qui s’active lorsque le capteur détecte un niveau
d'humidité trop important.
Vendredi 4 mai
Nous implémentons le capteur d'humidité et la pompe à eau au circuit final, ainsi que
leur code, au code final. Mais celui-ci ne compil pas, après résolution du problème le
circuit ne marche toujours pas nous pensons que cela provient du montage électrique.
Mardi 15 mai
La mise en relation de l’intégralité des capteurs et composants est réussi l’ensemble
fonctionne, sur les conseils de nos professeur nous décidons d'implémenter de
nouvelle fonctionnalité, et d’utiliser un capteur à ultrasons, ainsi que de rajouter une
horloge au système afin de pouvoir prévoir des arrosages lorsque la connection
application/module sera fonctionnel.
L’application du module bluetooth est terminé.
Vendredi 18 mai
Nous recevons le capteur à ultrasons, celui-ci va nous servir à définir la réserve d’eau
restante dans le bac prévu à cet effet.
Nous effectuons le branchement électrique sur la maquette, et rédigeons le code pour
le bon fonctionnement de celui-ci.
Le capteur marche, nous modifions maintenant notre code de manière à être plus
précis (l’unité de mesure passe du mètre au cm) nous gagnons en précision.
Puis finalement nous étalons le capteur.
Jeudi 24 mai
Nous affichons les valeurs du capteur d’ultrasons sur l'écran LCD, nous créons une
icône d’affichage pour celui ci
Nous essayons d'implémenter celui au circuit complet, ainsi que d'implémenter son
code dans le code général.
Mais nous rencontrons des difficultés, nous ne savons si le problème vient du
montage, ou du code.
Nous refaisons notre circuit à un capteur et nous essayons d'envoyer des donnés à
notre application mobile.
62
Vendredi 1 juin
Nous réussissons à envoyer des mots à notre application via le bluetooth, pas encore
de données. Nous n’arrivons pas non plus à envoyer des données de l’application vers
le module.
L’ensemble du circuit est fonctionnel est marche ensemble.
L’horloge qui permet de prévoir des heures d’arrosage est fini.
Mardi 5 juin
Nous évoquons avec nos professeur la possibilité de réaliser un circuit imprimé pour
pour effectuer un rendu final du projet, malheureusement le temps de réalisation
semble trop court au vu de la soutenance de projet arrivant à grand pas nous nous
focalisons sur un rendu final fonctionnel de notre projet.
Nous arrivons désormais à transmettre les données des capteurs via bluetooth sur
l’application. L’envoie de données de l’application vers le module est toujours
opérationnel
63