Unité PR 2101 - Atelier Arduino - Rapport - Projet potager connecté - CHANTELOUP Marc COLLIOT Delphine THIBAULT Théo Groupe : 5 - PortFolio de ...

- Unité PR 2101 - Atelier Arduino -

 Rapport – Projet potager connecté

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.

Listes des composants nécessaires et budget

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

 On peut ainsi réaliser le projet pour un budget minimum de 40€.

 6

Explication du fonctionnement

 Le but est de capter les différents paramètres autour de la plante
(ensoleillement, taux d’humidité et température) puis à partir de recherche menée sur
la plante, on compare les données collectées à celle rentrer dans le programme et on
conditionne l’arrosage. On affichera également sur l’écran LCD ces différentes données
ainsi que le niveau d’eau dans le réservoir. Le niveau d’eau sera déterminé à l’aide
d’une émission d'ultrasons.

Objectifs

Nous allons donc devoir réaliser plusieurs objectifs :

 • Capter le taux d’humidité du sol.
 • Capter le taux d'ensoleillement.
 • Capter la température ambiante.
 • Déterminer le niveau du réservoir d’eau.
 • Gestion automatique de l’arrosage (durée - quantité).
 • Afficher les différentes variables sur un écran LCD.
 • Récupération des données via bluetooth.
 • Traitement des données récupérées par bluetooth.

 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é

 Pour commencer, nous avons utilisé un capteur de luminosité. Le but est de
déterminer le niveau d’éclairement que reçoit la plante. Pour cela nous nous sommes
renseignés sur le capteur puis nous avons effectué son montage. (cf annexe )

Schéma électrique

 A1
 1

Fonctionnement

 Le capteur de luminosité est en fait une photorésistance, c’est-à-dire une cellule
photo-électrique qui est sensible à l’intensité lumineuse. Cette intensité est ensuite
traduite en courant électrique qui varie en fonction de la quantité de lumière reçue.
Cette variation est proportionnelle.

 8

Branchement à l’Arduino

 Pour le brancher à l’Arduino, on le relie à l’alimentation et la masse. La donnée
reçue par l’Arduino peut prendre plusieurs valeurs donc on le relie à un pin analogique.

 Source :http://www.manuel-esteban.com/arduino-capteur-de-luminosite/

Code

 9

Capteur de température

 Le capteur de température est placé dans la serre de manière à relever la
température autour de la plante. L’objectif est ensuite d’ajuster la température ou
l’arrosage en fonction de cette température. (cf annexe )

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

 Le capteur utilise une technique solide pour mesurer la température. En effet,
celle-ci permet d’accroître la tension aux bornes d’une diode. Il y a en fait une chute
de tension entre la base et l’émetteur du transistor. On amplifie ensuite cette tension
pour générer un signal analogique proportionnel à la température.

 La sensibilité du capteur varie entre -40°C et 150°C, ce qui correspond à une
tension entre 0,1V et 2,0V. On peut alors en déduire les courbes suivants :

 10

Source : https://learn.adafruit.com/tmp36-temperature-sensor/

A partir de cela, on peut retrouver la température.

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

 Ce capteur fonctionne en mesurant les changements de conductivité du sol. En
effet, plus le sol est sec, plus sa résistivité augmente. Etant composé de deux broches,
il mesure la résistivité de la terre qui relie les deux broches.

Branchement à l’Arduino

 Le capteur possède deux sorties. On a une valeur qui varie et donne le
pourcentage d’humidité et une autre que l’on calibre pour déterminer si le sol est
humide ou non. On utilise donc un branchement analogique et un digital.

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

Pour éviter que LED disjonctent, on doit ajouter une résistance. On a :

 − + . + = 0 = 5 = 2,2 

 − + 
 = ⇔ = 380Ω
 
 14

Branchement

 On envoie au LED un signal numérique : allumée ou éteinte. On utilise un pin
analogique.

Code

 15

Le ventilateur

 Si la température est trop élevée, on décide de ventiler le potager pour la faire
diminuer. On ajoute donc un ventilateur au circuit.

Schéma électrique

On cherche à déterminer la résistance à utiliser. On a :

 = . + 0,6 ⇔ 5 − 0,6 = . 
 4,4
 ⇔ =
 
Or = 500 

 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

Le calcul de la résistance est le même que précédemment et le fonctionnement
également.

Branchement

 Le branchement de la pompe à eau est sur le même principe que celui du
ventilateur.

 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

Affichage des données

 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 :

 La température en degré en haut à gauche, la luminosité en pourcentage en bas
à gauche, la distance en pourcentage en haut à droite, et l’humidité en pourcentage en
bas à droite

Affichage lors de l’arrosage

 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

 Pour coder l’application, nous avons utilisé le site internet
http://ai2.appinventor.mit.edu qui nous a permis de coder l’application sans connaître
l’android.
 MIT AppInventor 2 se présente de la forme suivante :

 la partie design de l’application :

 22

la partie block qui permet de gérer les données envoyées/reçues :

 L’application permet donc d’envoyer : un 0 si on appui sur le bouton
“Ventilation”
 un 1 si on appui sur le bouton “Arrosage”
 un 2 si on appui sur le bouton “Éclairage”

 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

 L’arduino reçoit les données passant envoyées du téléphone vers le module
bluetooth puis les traités :
 - S’il reçoit un 0, et que le ventilateur est désactivé, alors il l’active sinon il ne fait
rien.
 - S’il reçoit un 1, et que la pompe est désactivée, alors il l’active sinon il ne fait
rien.
 - S’il reçoit un 2, et que les leds sont désactivées, alors il les actives sinon il ne
fait rien.

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.

 Nous souhaitons remercier nos professeur monsieur Fakri et monsieur
poulichet pour cette expérience et pour leur aide au cours du projet.
 A Josselin Lefebvre pour ses indications quant à l’utilisation de AppInventor
pour la réalisation de l’application gérant le bluetooth.
 Ainsi que l’ESIEE Space pour le prêt du capteur d’ultrasons et des tuyaux pour la
pompe à eau.

 26

Annexes

Annexe 1 : Capteur ultrason

 Capteur Ultrason HC-SR04

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

Principe de fonctionnement du capteur :

 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

Principe de fonctionnement du capteur :
Ce capteur mesure l'humidité du sol à partir des changements de conductivité
électrique de la terre (la résistance du sol augmente avec la sécheresse).
 ● Une sortie digitale avec un seuil réglable par potentiomètre.
 ● Une seconde sortie analogique permet de suivre les fluctuations précises de
 l'humidité du sol.
La fourche du capteur se plante verticalement dans la terre (pot de fleur, jardin...). On
mesure la résistance électrique entre les deux électrodes. Un comparateur à seuil
active une sortie digitale quand un seuil réglable est dépassé.

 30

Branchement :

Le capteur se branche simplement avec 2 fils sur la platine de mesure (GND et
signal).
La platine de mesure est alimentée directement par l'Arduino en 5V et possède deux
sorties indépendantes, analogique / digitale.

 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)

Principe de fonctionnement du capteur :
le LM35 est un circuit intégré calibré en usine pour être utilisé comme capteur de
température de précision. Sa principale particularité tient en ceci que sa tension de
sortie Vout est linéairement proportionnelle à la température exprimée en degrés
Celsius. Plus exactement, la tension de sortie Vout augmente de 10 mV chaque fois
que la température augmente de 1°C
Le LM35 peut mesurer des température comprise entre -55 et +150.
le capteur LM35 nécessite une alimentation négative pour mesurer des températures
en dessous de 0°C. La sortie est proportionnelle à la température, par conséquent -
10°C équivaut à -0,1 volt. De fait, avec une simple alimentation 5v, comme celle des
cartes Arduino, il n'est possible de mesurer que des températures positives.

 32

Branchement :

 ● L’alimentation 5V de la carte Arduino va sur la broche VCC du capteur.
 ● La broche GND de la carte Arduino va sur la broche GND du capteur.
 ● La broche A0 de la carte Arduino va sur la broche Vout du capteur.

 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 un composant dont la résistivité dépend de la luminosité
ambiante. On va donc s’en servir pour détecter le fortes variation de la luminosité.
On note l’illumination en « lux », voici un graphe qui montre l’évolution en lux en
fonction de la résistance.

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

 Capteur bluetooth RN-42

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

Principe de fonctionnement du capteur :

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.

ll existe un mode de commande, ou les données présentées sur le port série
(broches Rx et Tx) sont interprétées comme des commandes (par exemple : changer
le mot de passe, le nom diffusé, la vitesse de transmission, donner l’ordre de scanner
les appareils Bluetooth accessibles, se connecter à un certain réseau, etc..)

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 :

 ● L’alimentation 5V de la carte Arduino va sur la broche VCC du capteur.
 ● La broche GND de la carte Arduino va sur la broche GND du capteur.
 ● La broche 3 de la carte Arduino va sur la broche TX du capteur.
 ● La broche 4 de la carte Arduino va sur la broche RX du capteur

 38

Annexe 6 : Schéma complet

 39

Annexe 7 : Code complet

//-------------------------------------------------------------------------------------------------------
---------------------------
//-----------------------------------------------------------BIBLIOTHEQUE------------------------
-----------------------------------
//-------------------------------------------------------------------------------------------------------
---------------------------
#include 
#include 
#include 
#include 

//-------------------------------------------------------------------------------------------------------
---------------------------
//-------------------------------------------------------------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() {

 Serial.begin(9600); //Initialisation du Serial

 lcd.begin(16,2); //Initialisation du lcd

 bluetooth.begin(115200); // La vitesse par défaut de Bluetooth Mate
est de 115200bps
 bluetooth.print("$"); // Print three times individually
 bluetooth.print("$"); // $$$ permet de rentrer dans le mode de
commande
 bluetooth.print("$"); // Enter command mode
 delay(100); // Short delay, wait for the Bluetooth Mate to send
back CMD
 bluetooth.println("U,9600,N"); // Change temporairement la vitesse à
9600, sans parité
 bluetooth.begin(9600); // Start bluetooth serial at 9600

 //Initialisation des pins des différents capteurs
 pinMode(outPinVentilateur, OUTPUT); //pin analogique pour le
outPinVentilateurateur en sortie
 pinMode(inPinThermometre, INPUT); //pin analogique pour le capteur de
température en entrée

 42

pinMode(outPinLED, OUTPUT); //pin digital pour les outPinLEDs en
sortie
 pinMode(inPinLuminometre, INPUT); //pin analogique pour capteur de
luminosité en entrée

 pinMode(PinPompe, OUTPUT); //pin digital pour la pompe en sortie
 pinMode(PinAnalogiqueHumidite, INPUT); //pin analogique pour le capteur
d'humidité en entrée
 pinMode(PinNumeriqueHumidite, INPUT); //pin digital pour le capteur
d'humidité en entrée

 pinMode(trig, OUTPUT); //pin digital pour le capteur d'ultra-son en
sortie
 digitalWrite(trig, LOW); //le capteur d'ultra-son est à l'état bas
 pinMode(echo, INPUT); //pin digital pour le capteur d'ultra-son en
entrée

 //démarage du programme
 affichageDemarage();
 setHorloge(); //mise à l'heure de l'horloge par l'utilisateur
}

//-------------------------------------------------------------------------------------------------------
---------------------------
//---------------------------------------------------------------LOOP---------------------------------
------------------------------
//-------------------------------------------------------------------------------------------------------
---------------------------
void loop() {
 horloge();
 application();

 if (lcd.readButtons() & BUTTON_SELECT) {
 menu();
 }
// else if (aro) {
// affichageArosage();
// }
 else {

 43

affichageNormal();
 }

 thermometre();
 //temperature = 20;
 luminometre();
 humidimetre();
 //secheresse = 0;

 if ( (h[0]==0 && h[1]>6) || h[0]==1 || (h[0]==2 && h[1]==0) )
{ //innactivité pendant la nuit (entre 21h et 00h)
 ventilation();
 eclairage();
 arrosage();
 }

 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.

// Serial.print("valeur récupérée par le capteur de température : ");
// Serial.println(val);

 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

// 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

 digitalWrite(trig, LOW); // on ecrit dans le pin digital
 lecture_echo = pulseIn(echo, HIGH);
 cm = lecture_echo / 58; // conversion de la valeur renvoyé par le
capteur en cm.
 if (cm =8) { //conidtion sur la valeur renvoyer par le capteur
 distance = 0;
 }
 else { //traitement des autres cas de la valeur renvoyé par le
capteur
 distance = 100-cm*12,5; // produit en croix pour obtenir la distance en
cm en fonction de la valeur renvoyé par le capteur
 }

// Serial.print("valeur récupérée par le capteur d'ultra-son : ");
// Serial.println(lecture_echo);
// Serial.print("distance : ");
// Serial.print(cm);
// Serial.println(" cm");
// Serial.print("reserve d'eau : ");
// Serial.print(distance);
// Serial.println("%");
}

//-------------------------------------------------------------------------------------------------------
---------------------------
//------------------------------------------------------------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);
 }

 switch (select) { //en fonction de la valeur de select on modifi
soit :
 case 0 : //les unités de minutes (si select = 0)
 setUnMin (); //voir setUnMin ()
 break;
 case 1 : //les unités de minutes (si select = 1)
 setDixMin (); //voir setDixMin ()
 break;
 case 2 : //les unités de minutes (si select = 2)
 setUnH (); //voir setUnH ()
 break;
 case 3 : //les unités de minutes (si select = 3)
 setDixH (); //voir setDixH ()

 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() {

 unsigned int choix = 0;
 delay(200);
 while(!(lcd.readButtons() & BUTTON_RIGHT)){
 lcd.home();
 switch (choix) {
 case 0 :
 lcd.clear();
 lcd.print ("Menu");
 break;
 case 1 :
 lcd.print("Ventiler");
 if (lcd.readButtons() & BUTTON_RIGHT) {
 lcd.clear();
 if (!ventilateur) {
 ventilateur = true;
 }
 else {

 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 22 janvier au 26 janvier, nous avons commencé notre atelier autour de l’arduino, la
première semaine fut entièrement consacrée à la découverte et à la manipulation de
la carte arduino uno, capteur, ecran LCD autour de TP.
Lors de ces TP nous avons, mis en oeuvre la carte arduino, appris à structurer un
programme.
Notre premier programme/circuit avait pour but de faire clignoter une led, par la suite
nous en avons implémenté une seconde, via le code nous avons réalisé plusieur petite
fonction comme faire clignoter les deux en cadence, ou lorsque l’une est allumé l’autre
est éteinte ect.

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

Jeudi 7 juin pers
Dernière ligne droite avant la soutenance du projet nous peaufinons les derniers
détails en vue de la présentation de notre projet.

 63