Rapport Projet EI5 - Ruche Intelligente

Rapport de Projet Ruche Intelligente
AGI 2014-2015 - Istia
Ruche Intelligente
Supervision de ruches en ligne
Projet ralis par
Johan BRUN
Florian LIGNEUL
Thomas MAUGIN
Projet encadr par

Sbastien LAGRANGE
AGI 2014-2015 - Istia
ENGAGEMENT DE NON PLAGIAT

Je, soussign , dclare
tre pleinement conscient(e) que le plagiat de documents ou dune partie dun document publis sur
toutes formes de support, y compris linternet, constitue une violation des droits dauteur ainsi quune
fraude caractrise. En consquence, je mengage citer toutes les sources que jai utilises pour crire
ce rapport ou mmoire.
Signature :

Signature :

Signature :
Page 1 sur 46
AGI 2014-2015 - Istia
REMERCIEMENTS
Avant tout, il nous semble important de commencer ce rapport en remerciant M. Sbastien
LAGRANGE, notre encadrant, qui nous a suivi durant ce projet et qui sest toujours montr disponible
pour rpondre nos questions.
Nous tenons remercier lIstia et toute son quipe pdagogique pour les connaissances transmises
durant notre formation, connaissances qui nous ont permis de mener bien ce projet.
Nous souhaitons galement exprimer notre reconnaissance toutes les personnes ayant contribu
de prs ou de loin au dveloppement de cette application.
Page 2 sur 46
AGI 2014-2015 - Istia
TABLE DES MATIERES

Engagement de non plagiat ...................................................................................................................... 1
Remerciements ......................................................................................................................................... 2
Prsentation du document ....................................................................................................................... 5
Contexte dcriture ................................................................................................................................... 5
Prsentation de lquipe ........................................................................................................................... 5
1. Prsentation du projet .............................................................................................................................. 6
1.1. Contexte ............................................................................................................................................. 6
1.2. Objectifs pdagogiques ...................................................................................................................... 6
1.3. Ide gnrale du produit ................................................................................................................... 6
1.4. Contraintes ......................................................................................................................................... 6
2. Technologies et outils utiliss ................................................................................................................... 7
2.1. Langages de dveloppement ............................................................................................................. 7
2.2. Plateformes, Libraires et Frameworks ............................................................................................... 9
2.3. Outils daide au dveloppement ...................................................................................................... 10
3. Travail ralis .......................................................................................................................................... 12
3.1. Analyse - Fonctionnalits ................................................................................................................. 12
3.2. Conception ....................................................................................................................................... 13
3.3 Dveloppement ................................................................................................................................ 18
3.4. Dploiement .................................................................................................................................... 18
3.5. Tests et amliorations ...................................................................................................................... 18
3.6 Bilan du travail ralis ....................................................................................................................... 18
4. Dveloppement....................................................................................................................................... 19
4.1. Acquisition des donnes - Electronique........................................................................................... 19
4.2. Traitement des donnes - Arduino .................................................................................................. 19
4.3 Acquisition des donnes - Raspberry Pi ............................................................................................ 21
4.4. Service web - Raspberry Pi ............................................................................................................... 21
Page 3 sur 46
AGI 2014-2015 - Istia
4.4. Client web ........................................................................................................................................ 23

4.5. Bilan de lapplication ........................................................................................................................ 25
4.6. Conclusion sur le travail effectu ..................................................................................................... 26
5. Gestion de projet .................................................................................................................................... 28
5.1. Cycle de vie ...................................................................................................................................... 28
5.2. Macro-planning et rpartition des activits .................................................................................... 29
5.3. Gestion des sources avec Bitbucket ................................................................................................. 30
5.4. Sparation du travail ........................................................................................................................ 31
5.5. Gestion des tches ........................................................................................................................... 32
5.6. Bilan de cette gestion....................................................................................................................... 32
6. Bilan global .............................................................................................................................................. 33
6.1. Ides damlioration ........................................................................................................................ 33
6.2. Aspects pdagogiques ..................................................................................................................... 33
6.3. Difficults rencontres ..................................................................................................................... 33
6.4. Avis personnels ................................................................................................................................ 35
Annexe 1 : Mise en place du serveur Ruby sur RubyMine ......................................................................... 43
Gem ......................................................................................................................................................... 43
Mise en place .......................................................................................................................................... 43
Annexe 2 : Mise en place du serveur dacquisition des donnes Arduino .............................................. 44
Procedure ................................................................................................................................................ 44
Exemple de code ..................................................................................................................................... 44
Annexe 3 : Exemple de code du serveur dacquisition des donnes Raspberry...................................... 45
Procedure ................................................................................................................................................ 45
Exemple de code ..................................................................................................................................... 45
Annexe 4 : Macro planning version pleine page ......................................................................................... 46
Rsum ................................................................................................................................................... 47
Summary ................................................................................................................................................. 47
Page 4 sur 46
AGI 2014-2015 - Istia
INTRODUCTION
PRESENTATION DU DOCUMENT
Ce document fut conu dans le cadre du projet tuteur de la troisime anne de cycle ingnieur
dispens pour le diplme dingnieur par lIstia Angers (Institut des Sciences et Techniques de
lIngnieur dAngers). Il fut rdig en deux semaines et clt le projet.
Ce document est le rapport rcapitulant tout ce qui a t labor par notre quipe durant les 24
semaines de projet, sur une priode allant du 22 Septembre 2014 au 11 Fvrier 2015. Il prsente la
faon dont nous avons gr ce projet, les technologies utilises, le travail ralis puis tablit un bilan de
ce projet.
CONTEXTE DECRITURE
Le prsent document a pour but dinformer lquipe pdagogique de toute lorganisation de notre
projet, ce que lon a produit, ce que lon a appris, les outils utiliss, ainsi que les difficults rencontres.
Remarque : Ce document pouvant tre par moment technique, un glossaire a t rdig en fin de ce
document afin dexpliquer certains termes. Ces derniers seront crits en bleu afin de signifier au lecteur
que ce terme fait partie du glossaire.
PRESENTATION DE L EQUIPE
Notre groupe est compos de trois tudiants de la promotion des 3mes anne du cycle ingnieur (EI5),
suivant le parcours Automatique et Gnie Informatique (AGI) de lIstia dAngers. En voici les membres :
Johan BRUN
Florian LIGNEUL
Thomas MAUGIN
Nous tions encadrs tout au long de ce projet par M. Sbastien LAGRANGE, enseignant-chercheur
lIstia.
Page 5 sur 46
AGI 2014-2015 - Istia
1. PRESENTATION DU PROJET
1.1. CONTEXTE
Ce projet fut ralis dans le cadre des projets tuteurs dEI5. Le but est dutiliser nos comptences,
lesprit de travail dquipe et notre capacit travailler en autonomie dans un projet innovant. Nous
voulions un projet mlangeant diffrentes technologies, cest pourquoi nous avons choisi ce projet.
1.2. OBJECTIFS PEDAGOGIQUES

Ce projet sinscrit dans le cadre de notre formation en utilisant les connaissances et comptences en
dveloppement logiciel apprises durant les cours dispenss par lIstia, et a pour objectifs de nous faire
dcouvrir de nouvelles technologies, de mettre en uvre nos capacits en gestion de projet travers un
travail en quipe, ainsi que de renforcer nos comptences en dveloppement logiciel, travers
lutilisation de langages de programmation.
1.3. IDEE GENERALE DU PRODUIT

Le dclin des abeilles en France peut devenir un vrai problme environnemental. Pour lutter contre,
mettre la disposition des apiculteurs un outil de supervision de leurs ruches peut les aider garantir la
survie de leurs abeilles.
Le but du produit est alors de placer des capteurs dans une ruche afin de rcuprer diffrentes donnes,
qui seront enregistres et archives par un serveur web. De plus, le produit final sera pourvu dune
interface web (consultable laide dun navigateur web tel que Mozilla Firefox ou Google Chrome) afin
de pouvoir configurer la supervision des ruches et consulter les donnes.
1.4. CONTRAINTES
Ce projet na que peu de contraintes, mis part les celles de temps. Nous navions pas besoin dacheter
de matriel, ayant dj tout de fourni par lIstia. Nous tions compltement libre vis--vis des
technologies utiliser.
Page 6 sur 46
AGI 2014-2015 - Istia
2. TECHNOLOGIES ET OUTILS UTILISES

2.1. LANGAGES DE DEVELOPPEMENT
2.1.1. LANGAGES WEB
Afin dafficher le site web, nous avons utilis plusieurs langages web. Ceux-ci, bien quayant des rles
diffrents, sont complmentaires.
HTML (HyperText Markup Language) : cr en 1993, ce langage gre et organise le contenu
du site. Cest un langage de balises (dfinies par < >, les plus connues sont <html> et
<body>). Chaque balise sa signification et son utilit (par exemple, crire <b> Mon mot
</b> affichera Mon mot en gras). C'est donc en HTML que nous avons crit ce qui doit
FIGURE 1 : LOGO HTML
tre affich sur la page : du texte, des liens, des images
CSS (Cascading Style Sheets, aussi appeles Feuilles de style) : cr en 1996, il gre
l'apparence de la page (agencement, positionnement, dcoration, couleurs, taille du
texte). Un fichier CSS est compos de plusieurs rgles de prsentation qui permettent
dappliquer des styles aux balises HTML.
FIGURE 2 : LOGO CSS
En rsum, le HTML dfinit le contenu. Le CSS permet, d'arranger ce contenu et de dfinir

la prsentation : couleurs, image de fond, marges, taille du texte
Javascript : Souvent abrg JS, le JavaScript fut cr en 1995 par Brendan Eich. Cest un
langage de programmation interprt, principalement utilis dans les pages web dynamiques.
Cest linterprteur du navigateur internet qui interprte le code afin de le faire fonctionner.
Le JavaScript est un lorigine un langage dit ct client, c'est--dire que les scripts sont
excuts par le navigateur de lutilisateur. Cela diffre des langages de scripts dits ct FIGURE 3 : LOGO JS
serveur qui sont excuts par le serveur web. Mais dsormais, grce nodeJs (voir plus
bas), il est possible de dvelopper des serveurs avec ce langage.
2.1.2. LANGAGES INTERPRETES

Un langage interprt est un langage qui est lu par un interprteur. Il excute le programme au fur et
mesure de lexcution. Lavantage de ces langages est la grande portabilit et la facilit de la
programmation. Il faut noter que les langages web cit ci-dessus sont galement des langages
interprts.
Ruby : Ruby est un langage de programmation libre. Il est interprt et multi-paradigme. Le
langage a t standardis au Japon en 2011 et en 2012 par l'Organisation internationale de
normalisation. Ce langage est connu pour utiliser la programmation objet au maximum,
comme par exemple, chaque type (int, char) est un objet. Il ressemble sur des points ses
FIGURE 4 : LOGO
RUBY
Page 7 sur 46
AGI 2014-2015 - Istia
concurrents Java et C# car il dispose lui aussi dun garbage collector charg de librer de la mmoire
au fur et mesure de lexcution du programme.
Python : Le python est un langage orient objet invent dans les annes 1990 par Guido
van Rossum. La prochaine version publique cre en 1991. Il est multi-plateforme et multiparadigme. Cest un langage trs largement utilis pour la programmation imprative. Il est
aussi adapt la programmation dun petit programme ou un plus gros projet.
FIGURE 5 : LOGO
PYTHON
Ce langage de nombreux avantages : il ne ncessite ni compilateur, ni logiciel de

dveloppement (IDE) particulier, linterprteur Python est souvent install sur les machines, Windows
comme Linux / Mac OS, il jouit de centaines de bibliothques fiables et puissantes et il est souvent plus
lisible que dans dautres langages.
2.1.3 LANGAGES COMPILES

Un langage compil est un langage qui est transcrit en langage machine par le dveloppeur laide dun
compilateur. Il a lavantage dtre excut plus rapidement, mais oblige le dveloppeur recompiler son
programme chaque test et pour chaque plateforme.
C++ : Le C++ est un langage compil qui fit son apparition en 1983. Il est multiparadigme. Il a la spcificit dtre compltement libre (il nappartient
personne) et compatible avec tous les systmes (Linux, Windows). Cest un des
langages les plus utiliss dans le monde, de par son anciennet mais galement
sa richesse de diffrentes librairies. De plus, tre un langage compil lui donne
lavantage dtre plus rapide que les langages interprts, sachant que son code
est transcrit en langage machine. Il est utilis dans ce projet pour programmer
lArduino.
FIGURE 6 : LOGO C++
2.1.4 UTILISATION DES LANGAGES

Lutilisation de ces langages est renseigne dans la figure 7 ci-dessous :
Langage
But
HTML / CSS
Site web (cot client)
Javascript
Site web (cot client)- Ancien serveur dacquisitions des

donnes
Ruby
Site web (cot serveur)
Page 8 sur 46
Python
Serveur dacquisitions des donnes
C++
Programmation de lArduino
AGI 2014-2015 - Istia
FIGURE 7 : UTILISATION DES LANGAGES
2.2. PLATEFORMES, LIBRAIRES ET FRAMEWORKS

2.2.1 NODEJS
Node.js a t cr par Ryan Lienhart Dahl en 2009. Cest une plate-forme logicielle
construite sur l'excution JavaScript de Chrome (avec le moteur V8) pour construire
facilement des applications de rseau rapides et volutives.
FIGURE 8 : LOGO
NODEJS
Node.js utilise un modle non-bloquant (par exemple, quand il demande une donne la
base de donnes, le temps de recevoir la rponse, il va excuter le code suivant et revenir une fois la
rponse reue), vnementiel (son code nest compos que de fonctions directement appeles par le
client), ce qui le rend lger et efficace. Il est idal pour les applications en temps rel requrant un grand
nombre de donnes. La nouveaut de Node.js est quil rend dsormais possible le dveloppement de
serveur laide de JavaScript, qui nest de ce fait plus seulement un simple langage ct client.
Node.js intgre une bibliothque de serveur HTTP qui permet de faire tourner un serveur web sans avoir
besoin de logiciel externe. Cela permet galement de contrler la faon dont le serveur web fonctionne
(directement dans le code).
Pour assurer la communication client-serveur, Node.js utilise un systme de socket (grce la librairie
Node.js socket.io). Pour le reste, cest la puissance du langage JavaScript qui sexprime, un langage
simple, enrichissable par des librairies externes et pouvant tre utilis en tant que langage objet.
Node.js peut tre enrichi, comme JavaScript, laide de diverses librairies (appeles galement
packages), comme par exemple Node-schedule qui permet de programmer un vnement une
date/heure prcise.
2.2.2 RUBY ON RAILS

Ruby on Rails est un framework open-source pour le langage Ruby. Suivant, le modle
MVC, il propose au dveloppeur une architecture bien prcise permettant de
dvelopper plus vite et plus intuitivement. Il ajoute galement beaucoup de fonctions
internes afin dajouter plus dabstraction, cest dire permettre au dveloppeur de
dvelopper de manire soccuper moins du code et plus des fonctionnalits du
programme.
FIGURE 9 : LOGO
RUBY ON RAILS
Page 9 sur 46
AGI 2014-2015 - Istia
Nous avons dcid dutiliser le langage Ruby avec le framework Ruby On Rails, car ce dernier propose
une architecture MVC et un outil de scaffolding trs utile pour dbuter un projet et organiser son code
de manire uniforme. La philosophie du framework est la suivante : Ne vous rptez pas et
Convention plutt que configuration, cest pour cela quil dispose aussi dune API REST en parallle des
contrleurs et des vues normales du site ce qui tait ncessaire pour le groupe travaillant sur
lapplication Android et qui permet de faire le travail beaucoup plus rapidement tant donn quil ny a
pas refaire un projet pour le service web.
Ruby dispose dun gestionnaire de packet : RubyGem (quivalent de npm pour nodeJS). Il est trs
pratique pour installer et dployer des librairies, nous avons utilis pas moins dune vingtaine de gem
pour ce projet (gestion des utilisateurs, des droits, dploiement ).
2.2.3. BOOTSTRAP
Twitter Bootstrap, est une collection doutils utiles la cration de sites web et
applications web. C'est un ensemble qui contient des codes HTML et CSS, des formulaires,
boutons, et autres lments interactifs, ainsi que des extensions JavaScript en option. On
y obtient, grce son utilisation, un site ergonomique et esthtique.
FIGURE 10 : LOGO
BOOTSTRAP
2.3.4. JQUERY
jQuery est une librairie JavaScript permettant de simplifiant la communication entre
le html et le JavaScript sur une page HTML (et donc cot client). Il est trs simple
utiliser, et de ce fait est intgr dans 80 % des 10.000 sites web les plus visits sur
lInternet.
2.3. OUTILS DAIDE AU DEVELOPPEMENT

2.3.1 GIT
Git est un logiciel de gestion de sources, cre par Linus Torvalds, permettant un travail
collaboratif entre plusieurs dveloppeurs sur les mmes sources. Cest un petit logiciel,
cr lorigine pour Linux puis adapt Windows, facile mettre en place (linstallation
dun serveur Git ne ncessite que quelques commandes sur le serveur de dveloppement,
ainsi que pour le client sur nos machines personnelles). Les commandes sont simples
retenir et peu dentre elles nous sont vraiment utiles. Exemple des plus utilises:
FIGURE 11 : LOGO
JQUERY
FIGURE 12 : LOGO DE
GIT
git clone : permet de cloner le contenu dun serveur Git.

git commit a : insrer nos mises jour dans un paquet .
git status : voir ltat des sources (voir si elles ont t enregistres dans des commits, combien
de commits qui nont pas encore t envoys au serveur).
git push : envoyer les mises jour au serveur.
git pull : tlcharger les dernires mises jour.
Page 10 sur 46
AGI 2014-2015 - Istia
git clone : premire tre utilise sur nos postes afin de pouvoir cloner le dpt Git cr sur le
serveur.
git checkout . : rinitialise lespace de travail au dernier commit effectu ou tlcharg
Et pourquoi spcialement Git ? Il existe dautres outils de gestion de sources, par exemple SVN. Mais Git
tait le seul outil de gestion dj connu par plusieurs des membres du groupe. De plus, il existe sur le
net Bitbucket qui permet de crer un dpt sur un serveur priv.
2.3.2 SUBLIME TEXT 2

Sublime Text est un diteur de texte permettant la coloration syntaxique suivant le langage
en cours dcriture par le dveloppeur, ainsi que lauto-compltion. Son interface simple et
sa coloration efficace en fait un diteur de code pratique. De plus, il peut tre complt par
diffrents plugins (par exemple, il est possible de rajouter un module pour la
reconnaissance des diffrentes fonctions dune librairie en cours dutilisation).
FIGURE 13 : LOGO
SUBLIME TEXT
2.3.3 RUBYMINE
RubyMine est lIDE pour Ruby dit par Jetbrains qui ralise toutes les fonctions de base
dun IDE (comme IntelliJ) et permet de lancer directement un serveur Rails. Il est
privilgier face au simple diteur de texte, car la complexit dun projet sur Ruby On Rails
implique de nombreux fichiers et oblige lutilisateur disposer dune auto-compltion
efficace (ce que ne propose pas Sublime Text dans ce cas).
Page 11 sur 46
FIGURE 14 : RUBY ON
MINE
AGI 2014-2015 - Istia
3. TRAVAIL REALISE
Durant tout le projet, le travail ralis fut compos de six grandes activits :
Analyse et dfinitions des fonctionnalits

Conception
Dveloppement
Dploiement
Test et amliorations
3.1. ANALYSE - FONCTIONNALITES

Le but du projet tait de crer une ruche intelligente, cest--dire de pouvoir superviser la ruche
distance laide dun systme informatique tel quun ordinateur ou un mobile.
La liste des fonctionnalits de ce projet est prcise en figure 15 :
Numro
fonctionnalit
de Nom de la fonctionnalit
FT01
Visualiser le nombre dabeille dans

la ruche
FT02
Visualiser le taux de temprature et

dhumidit dans la ruche
FT03
Visualiser un historique des donnes
FT04
Ajouter / modifier / supprimer une

ruche surveiller
FT05
Ajouter / modifier / supprimer un

capteur dune ruche
FIGURE 15 : FONCTIONNALITES DE BASE DU PROJET
Page 12 sur 46
AGI 2014-2015 - Istia
3.2. CONCEPTION
Le but de cette phase est de dfinir une
architecture de notre projet, afin de
raliser les plans et que chacun puisse
travailler dessus. Ce projet est un
mlange
dlectronique
et
dinformatique. On retrouve plus que le
dveloppement dun logiciel. Ces
diffrentes parties communiquent entre
elle (voir figure 16). On retrouvera la
fonction de chaque partie en figure 17.
FIGURE 16 : SCHEMA DE L'ARCHITECTURE DU PROJET
Nom de la partie
Rle
Ruche
Tout simplement la ruche contenant les abeilles et les capteurs
Arduino
Collecter les donnes des capteurs de la ruche

Envoyer les donnes la Raspberry grce un metteur HF (Haute
Frquence)
ARF-53
Emetteur / Rcepteur HF (Haute Frquence). Utilise la liaison srie
Raspberry Pi
Hbergement de la base de donnes

Rception des donnes de lArduino
Stockage de ses donnes dans la base de donnes
Hbergement du service web
Wifi
Le wifi permet un mobile ou un ordinateur de consulter les

donnes mise disposition par la Raspberry Pi
Interface de lutilisateur permettant de visualiser les donnes

travers le wifi de la Raspberry Pi.
Smartphone
Ordinateur
FIGURE 17 : DIFFERENTES PARTIES DU PROJET
Page 13 sur 46
AGI 2014-2015 - Istia
DETAILS SUR LA RASPBERRY PI

Cette carte programmable est le cur du projet. En effet, elle effectue un grand nombre dactions. Elle
est alors dcompose en plusieurs parties (voir figure 18 et figure 19 pour les dtails).
FIGURE 18 : COMPOSITION DE LA RASPBERRY PI
Nom de la partie
Fonction
Interface Srie
Entre / Sortie srie de la Raspberry. Sert la rception des donnes de

lArduino
Serveur Python
Rception des donnes de lArduino et stockage dans la base de donnes
Base de donnes
Stockage des donnes des capteurs des ruches, les configurations utilisateurs
et des comptes sur site web
Page 14 sur 46
AGI 2014-2015 - Istia
Serveur Ruby
Serveur web qui hberge le site web.
Interface Web
Interface web o les utilisateurs pourront se connecter au serveur Ruby et

consulter les donnes
FIGURE 19 : DETAILS DE LA COMPOSITION DE LA RASPBERRY PI
DETAILS SUR LE SERVEUR RUBY

A RCHITECTURE EN TROIS PARTIES
Le serveur Ruby est un serveur web, destin offrir lutilisateur des interfaces web. Il hberge alors un
site web. On peut dcouper ce dernier en trois parties (voir figure 20) :
Le client, contenant lensemble des interfaces graphiques. Elles permettront lutilisateur de

consulter les donnes rcoltes par le serveur Python.
Le serveur, qui traite et restitue les donnes
La base de donnes, qui stocke les donnes.
On rappelle que dans notre cas, le serveur et la base de donnes se trouve au mme endroit, sur la carte
Raspberry Pi.
On se retrouve avec une application de type client <-> serveur, trs utilis dans le web, o gnralement
le client demande une information, le serveur traite la demande et renvoie linformation sous forme
dune page contenant du HTML, du CSS et du Javascript. Le navigateur de lutilisateur se contente alors
dafficher cette page.
FIGURE 20 : FONCTIONNEMENT CLIENT <-> SERVEUR
Page 15 sur 46
AGI 2014-2015 - Istia
D IAGRAMME DE CLASSE
Le service web tant un logiciel, une conception prliminaire est ncessaire afin de tracer les plans crer
un projet propre et organis. Pour ce faire, nous avons alors ralis un diagramme de classe afin que
chacun puisse se baser dessus (voir figure 21)
FIGURE 21 : DIAGRAMME DE CLASSE DE L'APPLICATION WEB
Les diffrents objets sont prciss dans le tableau en figure 22.

Nom de lobjet
Description
User (Utilisateur)
Reprsente un utilisateur de lapplication.
Hive (Ruche)
Reprsente une ruche. Elle est relie une Arduino
Sensor (Capteur)
Reprsente un capteur. Il a reli une Arduino et dispose dun Type.
SensorType (Type capteur)
Reprsente le type dun capteur (humidit, temprature)
Page 16 sur 46
Arduino
Reprsente une arduino
Datum
Valeur des capteurs
AGI 2014-2015 - Istia
FIGURE 22 : DETAILS SUR LES OBJETS DE L'APPLICATION WEB
M ODELE MVC
Afin de crer un site web maintenable, lutilisation de larchitecture MVC (figure 23) est un bon choix.
Quest-ce que MVC ?

MVC, pour Modle Vue Controller est une
mthode dorganisation du code qui ralise un
dcoupage en trois parties. Le principe est simple :
on isole la partie qui contient les donnes (Model)
et la partie qui affiche les donnes (Vue). Le
contrleur (Controller) fait office de routeur.
Une analogie intressante est celle de la tlvision
:
Le fournisseur des chanes est le Model. Il
contient toutes les donnes mais ne gre pas
laffichage
La vue est la tlvision. Il reoit des donnes du fournisseur et les affiches lutilisateur.
La tlcommande de lutilisateur est le contrleur : il choisit quelle donne afficher.
FIGURE 23 : SCHEMA DE L'ARCHITECTURE MVC
NOTES SUR LE CHOIX DES TECHNOLOGIES

Nous avons dans un premier temps choisi de faire lacquisition des donnes des Arduinos laide de
NodeJS, mais il sest rapidement avr que ce langage et la mise en place dun serveur NodeJS tait trop
importante par rapport la simple tche ralise. Nous nous sommes donc tourns vers un langage plus
robuste et plus simple mettre en place : Python. En effet les distributions Linux sont presques toutes
en possession dun interprteur Python et les librairies sont aussi faciles installer.
En ce qui concerne la partie Web, nous avons pens le faire en Java, mais nous voulions dcouvrir de
nouveaux outils (et pourquoi pas un nouveau langage). Cest trs rapidement que nous avons vu que
Ruby et le framework Ruby On Rails taient trs populaires. Dune part, car ce langage une syntaxe
allg et dautre, car Ruby dispose dun gestionnaire de paquet trs puissant et trs important. Rails est
Page 17 sur 46
AGI 2014-2015 - Istia
aussi un framework assez reconnu et utilis par de nombreuses entreprises : Groupon, SoundCloud,
Heroku, Github et qui propose un service web intgr au site web...
3.3 DEVELOPPEMENT
Cette partie fera lobjet dun chapitre entier, car, comme mentionn dans la partie 5 de ce document, le
dveloppement nous a occups environ les trois quarts de notre projet. Donc, dans un souci
dquilibrage de nos parties et de clart, cette partie sera ne sera pas dtaille ici.
3.4. DEPLOIEMENT
Le dploiement dun environnement fonctionnant sur Ruby On Rails est assez dlicat, en effet dun ct
Ruby est un langage interprt disposant de plusieurs versions et ncessitant de compiler linterprteur
depuis les sources et dun autre on dispose dune Raspberry Pi aux performances limits avec systme
dexploitation aux fonctionnalits restreintes. Ce qui rend l'opration difficile car le dploiement dune
application Ruby On Rails ncessite beaucoup de ressources processeur, dans notre cas la Raspberry Pi
mettait plus dune demi-journe pour installer l'environnement de dploiement. Il ne fallait donc faire
aucune erreur sous peine de devoir perdre encore une demi-journe.
En ce qui concerne le python, le dploiement a t trs rapide, car les distributions linux classiques
dispose toute dun interprteur Python. Il suffit de lancer le programme automatiquement au
dmarrage de la Raspberry.
Le HotSpot Wifi pour se connecter depuis mobile a t galement assez difficile mettre en place car la
Raspberry ne disposait pas des drivers adquats pour le dongle Wifi, nous avons donc d recompiler le
driver pour permettre le bon fonctionnement de celui-ci.
3.5. TESTS ET AMELIORATIONS

Pour les tests tout a t fait en local ayant des problmes avec la porte de lmetteur haute frquence.
Quelques amliorations ont ensuite t ralises, en particulier au niveau nergique.
3.6 BILAN DU TRAVAIL REALISE

Notre objectif de dpart est ralis, savoir donner la possibilit un utilisateur de consulter dtat
dune ou plusieurs ruches en temps rel et pouvoir visualiser un historique sur ces donnes. Le cahier
des charges initialement rdig est compltement respect.
Page 18 sur 46
AGI 2014-2015 - Istia
4. DEVELOPPEMENT
Avant daborder cette partie, il serait bon de rappeler deux points :
4.1. ACQUISITION DES DONNEES - ELECTRONIQUE

Pour acqurir les informations relatives la ruche, nous disposons de plusieurs capteurs. Lun dentre
eux est le DHT11, un capteur bon march qui permet de mesurer la temprature et lhumidit. Pour
lutiliser nous devons utiliser la librairie DHT pour Arduino permettant de communiquer facilement avec
ce type de capteur. Une fois librairie installe nous navons plus qu utiliser quelques fonctions pour
rcuprer les donnes.
DHT.read22(DHT22_PIN);
sensorsValue[0][i] = DHT.temperature;
sensorsValue[1][i] = DHT.humidity;
FIGURE 24 : FONCTION DE RECUPERATION DES DONNES DES CAPTEURS
Pour conomiser un maximum dnergie nous avons dcid de faire hiberner lArduino entre chaque
acquisition. Pour cela nous avons encore une fois utilis une librairie : LowPower, elle permet de passer
lArduino dans un mode o elle ne consomme presque plus dnergie. Elle fonctionne de faon analogue
la fonction sleep :
LowPower.powerDown(SLEEP_8S, ADC_OFF, BOD_OFF);
FIGURE 25 : MISE EN MODE "ECONOMIE ENERGIE" DE L'ARDUINO
En utilisant cette mthode on peut faire chuter la consommation de 40mA 6.5mA. Ce qui nest pas
ngligeable puisque lArduino ne fonctionne pas pendant plus de 99% du temps. On passe dune
consommation journalire de 960mAh 156mAh soit une rduction de 83% de la consommation
nergique.
4.2. TRAITEMENT DES DONNEES - ARDUINO

Une fois les donnes enregistres il est ncessaire de les envoyer la Raspberry Pi, pour cela nous avons
dcid de ne pas envoyer les donnes une par une, mais par bloc. Cette mthode prsente lavantage de
consommer moins dnergie. En effet, il nest pas ncessaire dallumer lmetteur plusieurs fois par jour
mais seulement une fois (dans notre cas). La consommation dnergie est un point important tant
donn que nous nutilisons quune unique source dnergie : le soleil. Il faut donc faire le maximum pour
lconomiser.
Page 19 sur 46
AGI 2014-2015 - Istia
La communication entre lArduino et la Raspberry se fait par une liaison srie avec le protocole JSON. En
voici un exemple :
{"sensors":[{"serial":1,"values":[22,23,22,21,23,22]},{"serial":2,"values":[84,86,86,85
,81,82,83,87,85]},{"serial":3,"values":[0.00000,1.00000,2.00000,3.00000,4.00000,5.00000,6.0000
0,7.00000,8.00000,9.00000,10.00000,11.00000,12.00000,13.00000,14.00000,15.00000,16.00000,17.00
000,18.00000,19.00000,20.00000,21.00000,22.00000,23.00000]}],"arduino":{"serial":1}}
FIGURE 26 : EXEMPLE DE TRAME ENTRE ARDUINO ET RASPBERRY
Si on regarde dun peu plus prs la trame on saperoit quil est donn un serial pour chaque capteur
et Arduino. Ce sont les identifiants uniques qui sont ncessaires pour faire le traitement en base de
donnes. Nous devons en disposer pour pouvoir facilement installer de nouveaux capteurs.
Prenons lexemple de deux ruches organises comme sur la figure 27:
FIGURE 27 : EXEMPLE D'ORGANISATION DE DEUX RUCHES
Avec un systme d'identifiant unique pour chaque Arduino, il nest pas ncessaire que celui des capteurs
soit diffrent. Nous pouvons donc facilement avoir des pairs Arduino/Capteur ce qui simplifie la
modularit lorsquon a besoin dajouter de nouvelles ruches.
Pour ajouter une nouvelle ruche on ajoute une nouvelle Arduino avec un nouveau serial et on peut
grader la mme configuration de capteurs sans avoir faire de modifications (voir image).
Page 20 sur 46
AGI 2014-2015 - Istia
4.3 ACQUISITION DES DONNEES - RASPBERRY PI

Les valeurs sont reues en lisant les donnes arrivant sur le port srie de la Raspberry Pi. Pour cela, nous
avons dans un premier temps utilis nodeJS qui permet de facilement traiter les donnes JSON mais qui
manque de modularit en termes de rception srie et de performance. Cest aprs avoir rapidement
fait une bauche en Javascript que nous nous sommes rendu compte que ce ntait pas forcement le
meilleur choix de prendre ce langage, car il est assez lourd dployer par rapport la simple tche
denregistrer des donnes dans une base de donnes quil ralisait. Nous avons donc opt pour le
Python. En effet ce langage est dj prsent sur de nombreuses distributions Linux (notamment celle de
Raspbian) ce qui nous a permis de lutiliser directement sans avoir installer de nombreuses
dpendances. Nous avons alors install une librairie qui permet de lire et de traiter du JSON puis nous
avons procd de la mme manire quavec NodeJS mais en Python.
Dans un premier temps lapplication attend l'arrive de message sur le port srie. Quand un paquet
arrive, il fait la correspondance entre les serials des diffrents capteurs et lID du capteur en base de
donnes pour ensuite enregistrer les valeurs dans la base de donnes MySQL. Ce procd est assez
simple, mais besoin dtre fait valeur par valeur puisquil faut reconstruire la date de chaque
acquisition en fonction de leur ordre dans le message. Ainsi la dernire valeur date de la rception du
message alors que la 24ieme valeur a t prise il y 24h.
4.4. SERVICE WEB - RASPBERRY PI

Le site web a t ralis laide du langage Ruby et le framework Ruby On Rails. Ce framework dispose
dune architecture MVC et dune API REST. Cest un grand avantage, en effet lAPI et les vues se basent
sur le mme contrleur, nous navons donc pas besoin de faire deux fois le travail pour raliser les
mmes fonctions.
On voit sur la figure 21 lorganisation des classes de lapplication. Tout soriente autour de la classe
Ruche, une ruche dispose dune ou plusieurs arduinos, qui elles-mmes disposent dun ou plusieurs
capteurs. Ces classes sont analogues la configuration physique de la ruche. Ainsi il est beaucoup plus
facile dinstaller des nouveaux capteurs. Il suffit de faire virtuellement la mme installation.
GESTION DES COMPTES

La classe utilisateur est cr laide de la gem devise, les vue associes la gestion des utilisateurs
(cration, modification, oublie de mot de passe ) sont galement gnres automatiquement par cette
librairie laide de loutil de scaffolding. Pour grer les droits de chaque utilisateur nous avons utilis la
gem : cancan, celle-ci apporte des mthodes qui permettent de dfinir trs simplement les droits dun
utilisateur sur les modles de Rails. Ainsi on peut autoriser un utilisateur modifier une ruche, un autre
Page 21 sur 46
AGI 2014-2015 - Istia
seulement les afficher quant au dernier on peut lui interdire tout accs. Dans notre cas nous avons
cr quatre rles (figure 28):
Administrateur, qui est le propritaire de lapplication et qui dispose de tous les droits.
Modrateur qui dispose galement de tous les droits, mais qui nest pas le propritaire de
lapplication.
Enregistr, qui peut seulement visualiser les ruches, mais qui ne peut pas administrer le site
Banni qui ne peut rien faire sur le site.
Droits \ Utilisateur
Administrateur
Modrateur
Enregistr / Anonyme
Voir
Modifier
Banni
FIGURE 28 : GESTION DES DROITS DES UTILISATEURS SUR L'APPLICATION WEB
Pour des raisons daccessibilit, les utilisateurs non enregistrs peuvent quand mme visualiser les
ruches. Mais on peut tout moment modifier la configuration pour rendre obligatoire linscription. On
peut noter que la gem devise propose des moyens dauthentification pousss comme OmniAuth qui
permet de se connecter avec son compte Google, Facebook, Twitter
Le service web a t ralis en mme temps que lapplication web. En effet Rails implmente
automatiquement une API REST dans ses contrleurs. Avec une simple configuration on peut obtenir les
mmes routes que pour lapplication web. Il faut seulement rajouter .json la fin de lurl pour passer
par lAPI. Les vue du service web son ralis laide de JSON Builder, il permet dexposer les
proprits des objets en JSON de manire assez simple, comme on peut le voir en figure 29
json.extract! @sensor_type, :id, :name, :unit, :image, :created_at, :updated_at
FIGURE 29 : EXPOSITION D'OBJETS JSON
Page 22 sur 46
AGI 2014-2015 - Istia
ARCHITECTURE
Larchitecture dune application Ruby On Rails est
assez classique. On retrouve un dossier App
contenant les vues, les contrleurs et les modles
(MVC), on dispose aussi dun dossier assets qui
comporte les feuilles de styles, le javascript, les
images et les polices.
Le dossier de config regroupe toutes les informations

relatives au dploiement et au lancement de
lapplication (base de donnes, boot, tche avant
lancement).
Le fichier Gemfile liste toutes les dpendances du

projet ( la manire dun package.json en NodeJS), de
cette manire on peut installer un serveur assez
rapidement
en
tlchargeant
les
librairies
automatiquement.
Nous nallons pas expliquer le rle des autres dossiers
pour une question de pertinence, mais il faut savoir
que le dossier test permet de faire des tests unitaires.
FIGURE 30 : ARCHITECTURE DE L'APPLICATION WEB
4.4. CLIENT WEB
La partie front office se base sur le framework

Bootstrap, trs connu, dvelopp et utilis par Twitter. Nous avons utilis les composants de base
comme le menu latral, les champs de formulaire ( laide de la gem bootstrap_form) ce qui a simplifi
le dveloppement. Les couleurs de bases ont t remplaces par nos couleurs (orange et noir) avec
quelques rcritures de feuille de style. Nous avons rajout des transitions en CSS3 afin de donner un
peu de dynamisme au site : par exemple quand le pointeur se trouve sur licne dune ruche, celle-ci
change de couleur et devient plus grosse, cest une animation assez simple raliser et trs efficace
pour le confort lutilisateur. On retrouvera une screen de lapplication en figure 31.
Page 23 sur 46
AGI 2014-2015 - Istia
FIGURE 31 : CAPTEUR DECRAN DE L'APPLICATION WEB
Pour afficher des graphiques, la librairie highstock a t importe dans Rails laide de sa gem. Avec
cette librairie nous pouvions directement utiliser Ruby pour afficher les graphiques (or nous devrions
utiliser Javascript sans celle-ci), ceci nous a permis de garder une homognit dans le codage, il ny
avait que trs peu de code Javascript (et JQuery) pour grer la partie mtier.
@chart = LazyHighCharts::HighChart.new('graph') do |f|

f.title :text => @sensor.name
f.series :name=>@sensor.sensor_type.name, :data=>@point, :color => '#ebbc14'
f.xAxis :type => 'datetime', :maxZoom => 14 * 24 * 3600000 # fourteen days
f.chart :zoomType => 'x'
f.tooltip :valueSuffix => @sensor.sensor_type.unit
f.yAxis
:title
@sensor.sensor_type.unit + ")"}
=>
{:text
=>
Page 24 sur 46
@sensor.sensor_type.name
"
("
AGI 2014-2015 - Istia
f.rangeSelector
:enabled
=>
'true',
:buttons
=>
[{type:'week',count:1,text:'1s'},{type:'month',count:1,text:'1m'},{type:'month',count:6,text:'
6m'},{type:'year',count:1,text:'1an'},{type:'all',text:'Tout'}],
:buttonSpacing => 10, :inputDateFormat => '%e %b %Y', :inputEditDateFormat =>
'%d-%m-%Y'
f.scrollbar :enabled => 'true', :minWidth => 30
FIGURE 32 : EXEMPLE D'UTILISATION DE LA LIBRAIRIE HIGHSTOCK
4.5. BILAN DE LAPPLICATION

Au final lapplication apporte les fonctions suivantes :
Fonctionnalit
Dtail
Gestion de compte
Enregistrement dun utilisateur
Cration dun compte la demande avec login + mdp
Modification du compte dun utilisateur
Modification mot de passe, email, suppression du

compte
Suppression dun compte utilisateur
Suppression dun compte la demande de lutilisateur

ou un admin
Connexion / dconnexion un compte
Connexion un compte avec le couple login / mdp
Gestion de loublie du mot de passe
Une fois compte mail configur, envoi dun formulaire

pour que lutilisateur puisse saisie un nouveau mot de
passe
Gestion de ruches
Affichage dune ruche
Affichage de toutes les informations des ruches
Modification dune ruche
Modification de la valeur des attributs dune ruche
Page 25 sur 46
AGI 2014-2015 - Istia
Gestion de capteurs
Affichage dun capteur
Affichage de toutes les informations dun capteur
Modification dun capteur
Modification de la valeur des attributs dun capteur
Comparaison entre plusieurs capteurs
Comparaison de la valeur des attributs dun capteur
Modification dun type de capteur
Modification du type partir dun type dans une liste
Image personnalis pour chaque capteur

Autre
Tableau dadministration
Tableau de bord pour la visualisation des informations

:
Ruche
Capteur
Type de capteur
Valeur des capteurs
Utilisateur
Arduino
Modification dune Arduino

FIGURE 33 : BILAN DES FONCTIONNALITES FINALES DU PROJET
4.6. CONCLUSION SUR LE TRAVAIL EFFECTUE

Au final le framework Ruby On rails apporte de nombreuses gem trs utiles pour allger le travail du
dveloppeur. La plupart des librairies que nous avons utilises permettent de remplacer une librairie
Javascript par une interface en Ruby. Highstock aurait pu tre utilis en Javascript mais son
implmentation aurait t plus complique. Les formulaires adapts Bootstrap auraient pu tre
raliss manuellement en Ruby, mais la librairie Bootstrap_form permet dautomatiser cette tche. On
peut dire que la philosophie de Ruby On Rails a t, nous avons utilis les gem pour viter de faire des
rptitions et nous avons utilis les conventions de Ruby On Rails pour pouvoir dployer rapidement
Page 26 sur 46
AGI 2014-2015 - Istia
une application fonctionnelle. LAPI pour le groupe sur lapplication Android a t implmente trs
facilement tant donn que les conventions de Ruby On Rails ont t suivies scrupuleusement.
Au terme des ce projet, lapplication fonctionnait bien. Il ne manque aucune option qui nous avait t
demand. Nous pouvons peut tre regrett que la liaison radio ne soit pas effective, mais nous avons
rempli le contrat de base de faire un client web pour la ruche.
Page 27 sur 46
AGI 2014-2015 - Istia
5. GESTION DE PROJET
5.1. CYCLE DE VIE
Ayant un projet mlant lectronique, carte programmable et service web, le cycle de vie du projet peut
tre dcoup en deux sections : acquisition / traitement des donnes (arduino/raspberry) et
consultation des donnes (site web).
Pour cette premire partie, le plus logique fut de dvelopper en partant du plus bas niveau
(lectronique), pour ensuite coder la partie pour lire les donnes des capteurs, les envoyer la
Raspberry Pi, les stocker dans la base de donnes.
FIGURE 34 : ORDRE DE DEVELOPPEMENT DE PARTIE BAS NIVEAU
Pour la deuxime partie, axe logiciel, un

cycle de dveloppement en spirale fut
adopte (voir figure 35)
En effet, chaque fonctionnalit fut tudie,

implmente et teste. Une fois valide, le
dveloppement vers la fonctionnalit
suivante pouvait commencer. Ce cycle de
dveloppement permet un dveloppement
plus souple, o diffrentes fonctionnalits
peuvent tre ralises en parallle. De
plus, on dispose dune meilleure vue
densemble
sur
lavancement
de
lapplication.
FIGURE 35 : CYCLE DE VIE EN SPIRALE
Page 28 sur 46
AGI 2014-2015 - Istia
Analyse / Spcification
Cette phase est lanalyse des besoins du client, et la spcification des fonctionnalits de lapplication.
Mots cls de cette priode : imagination et pragmatisme.
Conception
Phase primordiale, elle permet de rflchir et de concevoir notre future application avant de se jeter
corps perdu dans la programmation. Cette phase, souvent nglig dans les petits projets, reste une
phase importante, car elle permet de bien dfinir les diffrents objets de lapplication, larchitecture,
ainsi que les maquettes des interfaces graphiques.
Cest un peu comme larchitecte qui dessine les plans de la maison en veillant bien respecter le cahier
des charges, afin que louvrier nait pas rflchir comment faire, mais simplement faire. Lide de la
phase de conception est l : rflchir et dfinir avant de construire, afin de savoir par o commencer,
mais galement pour viter les risques de devoir tout refaire, car on navait pas pens un dtail
(imaginez-vous vouloir mettre une salle de bain au deuxime tage de votre maison alors que la
plomberie ne se limite quau rez-de-chausse Jaurais d y penser avant, diriez-vous).
Mots cls de cette priode : comprhension et rflexion.
Test / Validation
La plus longue priode, mais galement la plus enrichissante. Globalement, cette phase runie
proportionnellement trois activits : apprentissage, recherche de solutions et criture du code.
Cette dernire devait tre effectue avec rigueur, en prenant garde respecter les rgles dfinies en
conception et en faisant leffort de conserver un code propre. Laissez toujours le code plus propre que
vous ne lavez trouv.
Mots cls de cette priode : rigueur et rflexion.
5.2. MACRO-PLANNING ET REPARTITION DES ACTIVITES

Le projet peut tre dcompos en diffrentes phases:
Electronique et codage de lArduino

Paramtrage de la Raspberry
Codage du serveur de donnes (x2 car nous avons utilis deux technologies)
Codage du serveur web
Codage du client web (interfaces graphiques)
Mise en place de la base de donnes
Page 29 sur 46
AGI 2014-2015 - Istia
On retrouvera ces phases sur le macro-planning en figure 36. On retrouvera ce planning en pleine page
en annexe 4.
FIGURE 36 : MACRO PLANNING DU PROJET
Le projet fut compos de diffrentes activits :
Electronique (branchement et configuration des capteurs)

Etude (tude des diffrentes technologies)
Conception
Codage (criture du code)
Tests
La rpartition du temps consacr chaque activit est prcis en figure 37.
FIGURE 37 : REPARTITION EN TEMPS DES DIFFERENTES TACHES
5.3. GESTION DES SOURCES AVEC BITBUCKET

Durant le dveloppement en quipe, nous tions obligs davoir un lieu o centraliser toutes nos
sources. Nous avons donc choisi le site web Bitbucket.org pour cela. Cest un service web
Page 30 sur 46
AGI 2014-2015 - Istia
d'hbergement et de gestion de dveloppement de logiciels, utilisant le programme Git, qui permet aux
dveloppeurs travaillant sur le projet, de tlcharger la dernire version du code et denvoyer leurs
modifications du code. Le site fournit galement des fonctionnalits de type rseaux sociaux : flux, suivi
de personnes ou de projets, graphes de rseau pour les dpts, etc.
Durant le dveloppement, lorsquun fichier est cr ou mis jour, par un dveloppeur il est donc
commit puis envoy au serveur par lintermdiaire de la commande git push. Puis, une fois connect
au site du dpt, les membres peuvent consulter les logs afin de voir ce que chacun a fait.
FIGURE 38 : ECRAN DES COMMITS DE BITBUCKET
5.4. SEPARATION DU TRAVAIL

La sparation du travail est un concept indispensable lors du travail en quipe. Participant un projet
regroupant diffrents technologies, avons donc opt pour ce dcoupage du travail, selon les envies, les
comptences et gots des personnes :
Arduino (rcupration des donnes des capteurs) : Florian
Raspberry (traitement des donnes en temps rel) : Florian / Thomas
Service web : Florian / Thomas / Johan
Vues : Florian / Thomas / Johan
Rapport final : Thomas / Johan
On remarque que finalement, nous tions trois sur le service web et les vues. Cela est d la rapidit de
la mise en place dun code Arduino et Raspberry fonctionnel.
Bien entendu, tout ntait pas rigide, et un peu de souplesse permettait d'acclrer le dveloppement.
Cela signifie que nimporte qui pouvait toujours travailler sur la partie dun autre pour rsoudre une
Page 31 sur 46
AGI 2014-2015 - Istia
erreur, ou encore implmenter de lui-mme une partie de programme afin de tester son code. Le seul
risque faire cela est la cration dun conflit, mais qui tait souvent relativement simple et rapide
rsoudre.
5.5. GESTION DES TACHES

Toutes les tches durant le projet ont t gres de manire agile. Ici, pas de chef de projet, chacun
tait libre de crer une tche raliser et la poster sur BitBucket (voir figure 39). Ensuite, chacun
indiquait la tche quil avait choisi de raliser, et notifia le site lors que la tche fut ralise et poste sur
le serveur.
FIGURE 39 : GESTION DES TACHES DE BITBUCKET
5.6. BILAN DE CETTE GESTION

Le point le plus important est que les dlais ont t respects. A partir de l, cette gestion peut tre
considre comme une russite. Au-del de a, la charge de travail na jamais trop varie, les semaines
taient assez quilibres et nous navons jamais d quadrupler notre temps de travail en approche des
deadlines. La gestion est reste agile et le plus important fut la communication entre les diffrents
membres.
Le systme de to-do list est vraiment efficace, qui permet de dcouper le travail en un ensemble de
tches simples. De plus, cela permet de rien oublier durant le dveloppement du projet.
Page 32 sur 46
AGI 2014-2015 - Istia
6. BILAN GLOBAL
6.1. IDEES DAMELIORATION
Avec un projet tel que celui l, beaucoup de fonctionnalits pourraient tre ajoutes. Nous en
proposerons ici que quelques-unes :
Authentification avec Facebook, Google

Gestion de plusieurs ruches pour plusieurs apiculteurs (droits, visibilit )
Site disponible depuis lInternet.
Personnalisation du thme
Changement de langue
Envoi demails et dalertes
6.2. ASPECTS PEDAGOGIQUES

Nous avons beaucoup appris, tout dabord un plan technique, car les enseignements proposs par lIstia
nont pas ports sur tous les domaines utiliss. Nous avons pu redcouvrir le fonctionnement
vnementiel et asynchrone de Node.js, mme si nous navons finalement pas conserv cette
technologie. Nous avons galement appris programmer en Ruby et utiliser un framework Ruby On
Rails. Certes, plusieurs connaissances que lon nous a enseignes nous furent utiles, comme la
programmation objet, quelques principes de conception logiciel, lalgorithmique ou encore le
dveloppement de scripts pour Linux, mais pour ce qui est du Ruby ou encore la programmation
asynchrone, nous avons d apprendre seul.
Nous avons galement appris sur un plan managrial (dveloppement en quipe, sparation du code).
Puis, pour finir, nous avons galement appris sur le plan humain, o nous constatons quil faut faire
preuve dhumilit, dcoute, dentraide et de patience pour bien travailler en quipe. Le mtier de
dveloppeur ne se rsume pas simplement taper du code. Il faut tre patient, rigoureux et un
minimum sociable pour pouvoir travailler en quipe efficacement et avec plaisir.
6.3. DIFFICULTES RENCONTREES

La plus grosse difficult que nous ayons rencontre a t celle de configurer la Raspberry Pi pour quelle
puisse fonctionner avec Ruby. En effet- il est ncessaire, dinstaller le SDK de Ruby avant de pouvoir
dployer une application Ruby. Pour cela nous avons utilis Passenger, cest un outil qui automatise le
dploiement d'applications Ruby (NodeJS) sur Apache et sur NGinx.
Page 33 sur 46
AGI 2014-2015 - Istia
Il a t galement assez difficile de configurer le Wifi de la Raspberry, le CPU est assez faible et ne
permet pas davoir de bonnes performances pour compiler nos sources (de mme pour celle de Ruby et
Rails).
Les modules ARF-53 ont t compliqus prendre en main tant donn que nous ne disposions pas
de la documentation (seulement au dbut) et que leur mise en place est assez difficile, il faut
regarder ce qu'envoie les modules sur le port srie pour pouvoir les dboguer. Dans notre cas, les
vitesses de communication ntaient pas les bonnes, nous ne pouvions mme pas savoir ce qui ne
fonctionnait pas. Cest aprs de nombreuses tentatives que nous avons trouv la bonne
combinaison.
Page 34 sur 46
AGI 2014-2015 - Istia
6.4. AVIS PERSONNELS

Johan
Pour ma part, ce fut une exprience assez enrichissante, que ce soit en termes de dveloppement que
de gestion de projet. Le travail en quipe a vraiment du bon, car il nous apprend lhumilit, lcoute et la
comprhension. On apprend de lautre, qui saura toujours quelque chose que vous ne savez pas. Niveau
technique, jai pu perfectionner mes comptences en dveloppement, en algorithmique mais
lectronique que jai pu suivre de loin.
Ce projet fut trs instructif pour moi, de par sa large diversit en technologies. Les tches furent
distribues au dbut du projet, selon les gots et les comptences de chacun.
Florian
Au cours de ce projet, jai pu dune part utiliser et approfondir mes connaissances de dveloppement et
de gestion de projet et dautre part dcouvrir de nouvelles technologies, notamment le Ruby et son
framework Ruby On Rails. Le fait davoir travaill sur un projet trs complet (de ltude jusqu la
ralisation finale) ma permis de bien comprendre le cycle de cration dune solution technologique
complexe. Du fait du travail dquipe sous Git, jai d durant ce projet apprendre bien grer mon code
ainsi que sa documentation pour ne pas pnaliser les autres dveloppeurs. Ce projet, en plus dune
aventure technologique a t pour moi une aventure humaine plaisante et instructive tant
personnellement que professionnellement.
Thomas
Ce projet ma permis de dcouvrir un nouveau langage : Ruby et le framework Rails qui lui est la plupart
du temps associ, Ce nest pas en soi une dcouverte, mais plutt lapprentissage dune nouvelle
syntaxe. En effet Ruby comme tout langage orient objet reprend les grandes lignes de Java ou bien de
C# mais avec une forme diffrente. Cest un essayant de nouveaux langages comme celui-ci, quon
apprend de nouvelles astuces et quon peut conforter ses choix technologiques futurs. Jai aim la partie
communication avec la ruche, puisque que cette tape impliquait de devoir toucher pas mal de
domaines, llectronique, ladministration rseau, la mise en production dapplication Lorganisation et
la gestion du projet (notamment avec git) et le travail en quipe ont t des points importants quil ne
fallait pas ngliger. La gestion des bugs et des amliorations nous ont appris formaliser nos besoins et
communiquer de manire plus efficace.
Page 35 sur 46
AGI 2014-2015 - Istia
CONCLUSION
Pour conclure ce projet, on pourrait commencer par dire que nous avons beaucoup appris,
techniquement comme humainement. Dans ce premier cas, nous avons dcouvert la technologie Ruby
on Rails qui commence tre de plus en plus populaire dans le monde du dveloppement Web, et qui
sera de plus en plus utilis et apporte donc une vrai valeur ajout notre capital de connaissances. Il en
est de mme pour Bootstrap. Nous avons conduit un projet du bas niveau au haut niveau et donc pu
couvrir un large panel de comptences.
Et dans le deuxime cas, le travail en quipe fait beaucoup appel nos qualits sociales : lhumilit,
la patience, lentraide. Cest important dans un travail en quipe, et cest durant ce genre de projet que
lon sen rend compte. La cohsion sociale du groupe est le pilier du projet, qui ne peut aboutir sans
cela.
Notre projet est la hauteur du cahier des charges prvu. Cependant, les diffrents problmes
rencontrs nous ont beaucoup ralentis et mme avec beaucoup de travail, il faut toujours du temps
pour apprendre, comprendre et bien utiliser de nouvelles technologies.
Si ctait refaire, nous garderions larchitecture mise en place, car nous la trouvons robuste et bien
organise.
Intelligence is the ability to avoid doing work, yet getting the work done.
Linus Torvald
Page 36 sur 46
AGI 2014-2015 - Istia
GLOSSAIRE
API (Application Programming Interface) : Ensemble de classes et de fonctions qui servent dinterface
une bibliothque (library en Anglais). Il fait la communication entre le logiciel et le contenu de cette
bibliothque.
Auto-compltion : Cest le fait que le logiciel de dveloppement propose au dveloppement des noms
de fonction / variable lorsque quil est en train dcrire le code.
Base de donnes : Outil permettant de stocker des donnes. Les donnes peuvent tre de diffrentes
natures, et desfois lies entre elles.
Client-serveur : architecture trs utilise sur le web. Dsigne un mode de communication travers un
rseau entre plusieurs programmes ou logiciels : le client, envoie des requtes ; le ou les serveur(s)
attend(ent) les requtes des clients et y rpond(ent).
Design pattern : cest un patron utilis en conception. Il permet de rsoudre des problmes en imposant
une structure. Par exemple, le pattern Observer permet de mettre jour une vue chaque changement
des donnes sans que la couche traitement nait rfrenc la couche vue.
Framework : ensemble de composants qui servent crer les fondations, l'architecture et les grandes
lignes d'un logiciel. L'objectif premier d'un framework est d'amliorer la productivit des dveloppeurs
qui l'utilisent.
IDE : pour Integrated Development Environment , logiciel disposant de multiples outils embarqus
afin daider et dassister le dveloppeur dans le dveloppement dun logiciel.
JSON : Format de donnes de plus en plus utilis pour la communication entre diffrents programmes
informatiques.
Langage de programmation : un langage qui permet aux dveloppeurs d'crire des instructions qui
seront analyses et traites par l'ordinateur.
Langage interprt : langage non compil, cest--dire quaucun fichier excutable (.exe) nest cr, le
code source reste tel quel. Si lon veut excuter ce code, on doit le fournir un interprteur qui se
chargera de le lire et de raliser les actions demandes.
Langage multi-paradigme : Cest un langage pouvant utiliser plusieurs principes, comme par exemple la
programmation orient objet ou la programmation imprative.
Liaison srie : La communication srie consiste transmettre des informations aprs les avoir
pralablement dcoupes en plusieurs morceaux de taille fixe (cette taille est le nombre de lignes de
Page 37 sur 46
AGI 2014-2015 - Istia
communication disponibles). Elle s'oppose la communication parallle o les informations

transmettre n'ont pas tre dcoupes avant d'tre envoye.
Open-source : La dsignation open source, ou code source ouvert , s'applique aux logiciels dont la
licence respecte des critres prcisment tablis par l'Open Source Initiative, c'est--dire les possibilits
de libre redistribution, d'accs au code source et de cration de travaux drivs.
Programmation imprative : En informatique, la programmation imprative est un paradigme de
programmation qui dcrit les oprations en squences d'instructions excutes par l'ordinateur pour
modifier l'tat du programme.
Moteur V8 de Google Chrome : fait ce qu'on appelle de la compilation JIT (Just In Time). Il transforme le
code JavaScript trs rapidement en code machine et l'optimise mme, grce des procds complexes.
MVC : Le patron modle-vue-contrleur (en abrg MVC, de l'anglais model-view-controller), tout
comme les patrons modle-vue-prsentation ou Prsentation, abstraction, contrle, est un modle
destin rpondre aux besoins des applications interactives en sparant les problmatiques lies aux
diffrents composants au sein de leur architecture respective.
MySQL : Cest un systme de gestion de bases de donnes. Il soppose MongoDb, car il utilise le
langage SQL
Navigateur web : logiciel servant afficher des pages au format html se trouvant sur le web. Plus
techniquement, cest un client http.
Programmation vnementielle : logique de programmation raisonnant sur des vnements, cest-dire que quand il se passe telle chose, alors on fait cela. Elle s'oppose la programmation squentielle.
Programmation orient objet : Un langage de programmation orient objet sinspire de ce qui nous
entoure. Par exemple, nous pouvons disposer dun objet voiture, qui est compos de 4 objets roues, 1
objet moteur une voiture est galement un objet vhicule (objet parent). Ces diffrents objets
possdent des caractristiques spcifiques.
REST : REST (Representational State Transfer) est un style darchitecture pour les systmes hypermdia
distribus, cr par Roy Fielding en 2000 dans le chapitre 5 de sa thse de doctorat.
Scaffolding : L'chafaudage ou scaffolding en anglais est une manire de concevoir des logiciels lis
une base de donnes. Cette technique est souvent fournie avec le patron de conception Modle-VueContrleur, dans lequel le programmeur crit une spcification dcrivant comment la base de donnes
sera utilise.
Page 38 sur 46
AGI 2014-2015 - Istia
Service web : Un service web (ou service de la toile) est un programme informatique de la famille des
technologies web permettant la communication et l'change de donnes entre applications et systmes
htrognes dans des environnements distribus
Socket : Canal rseau permettant la communication entre deux programmes informatiques.
Page 39 sur 46
AGI 2014-2015 - Istia
TABLE DES ILLUSTRATIONS

Figure 1 : Logo HTML .....................................................................................................................................................7
Figure 2 : Logo css ..........................................................................................................................................................7
Figure 3 : Logo js ............................................................................................................................................................7
Figure 4 : Logo ruby .......................................................................................................................................................7
Figure 5 : Logo python ...................................................................................................................................................8
Figure 7 : Utilisation des langages .................................................................................................................................9
Figure 6 : Logo c++ .........................................................................................................................................................8
Figure 8 : Logo NodeJS ...................................................................................................................................................9
Figure 9 : Logo ruby on rails...........................................................................................................................................9
Figure 10 : Logo bootstrap ...........................................................................................................................................10
Figure 11 : Logo jquery ................................................................................................................................................10
Figure 12 : Logo de git .................................................................................................................................................10
Figure 13 : Logo sublime text.......................................................................................................................................11
Figure 14 : Ruby on mine .............................................................................................................................................11
Figure 15 : Fonctionnalits de base du projet .............................................................................................................12
Figure 16 : Schema de l'architecture du projet ...........................................................................................................13
Figure 17 : Differentes parties du projet .....................................................................................................................13
Figure 18 : Composition de la raspberry pi ..................................................................................................................14
Figure 19 : Details de la composition de la raspberry pi..............................................................................................15
Figure 20 : Fonctionnement client <-> serveur............................................................................................................15
Figure 21 : Diagramme de classe de l'application web ................................................................................................16
Figure 22 : Details sur les objets de l'application web .................................................................................................17
Figure 23 : Schema de l'architecture mvc....................................................................................................................17
Figure 24 : Fonction de recuperation des donnes des capteurs ..................................................................................19
Figure 25 : Mise en mode "economie energie" de l'arduino .......................................................................................19
Figure 26 : Exemple de trame entre arduino et Raspberry .........................................................................................20
Figure 27 : Exemple d'organisation de deux ruches ....................................................................................................20
Figure 28 : Gestion des droits des utilisateurs sur l'application web ..........................................................................22
Figure 29 : Exposition d'objets JSON ...........................................................................................................................22
Figure 30 : Architecture de l'application web ..............................................................................................................23
Figure 31 : Capteur dcran de l'application web ........................................................................................................24
Figure 32 : Exemple d'utilisation de la librairie highstock ...........................................................................................25
Figure 33 : Bilan des fonctionnalites finales du projet ................................................................................................26
Figure 34 : Ordre de developpement de partie bas niveau .........................................................................................28
Figure 35 : Cycle de vie en spirale................................................................................................................................28
Figure 36 : Macro planning du projet ..........................................................................................................................30
Figure 37 : Repartition en temps des differentes taches.............................................................................................30
Figure 38 : Ecran des commits de bitbucket ................................................................................................................31
Figure 39 : Gestion des taches de bitbucket................................................................................................................32
Page 40 sur 46
AGI 2014-2015 - Istia
BIBLIOGRAPHIE
Cycle de vie :
laboiteaprog.com
Ruby :
rvm.io/
andrewberls.com/blog/post/api-versioning-with-rails-4
collectiveidea.com/blog/archives/2013/06/13/building-awesome-rails-apis-part-1/
Architecture MVC :
opeclassrooms.com
Raspberry Pi :
http://hardware-libre.fr/2014/02/raspberry-pi-creer-un-point-dacces-wifi/
Informations sur les diffrents langages :
wikipedia.org
siteduzero.com
developpez.com
ruby-lang.org
rubyonrails.org
python.org
cpp.developpez.com
API :
wikipedia.org/wiki/Interface_de_programmation
Page 41 sur 46
AGI 2014-2015 - Istia
SOURCE DES ILLUSTRATIONS

Logo de Ruby :
www.tutorialspoint.com/images/ruby-mini-logo.png
Logo de C++ :
buzness.com/wp-content/uploads/2013/11/c++.png
Logo de Python :
screenshots.en.sftcdn.net/en/scrn/69000/69838/python-16.jpg
Logo de Rails :
upload.wikimedia.org/wikipedia/en/thumb/e/e9/Ruby_on_Rails.svg/791px-Ruby_on_Rails.svg.png
Logo Bootstrap
http://audricmas.olympe.in/
Logo jQuery
http://zenika.github.io/Presentations/20130926_ptidej_angularjs/#/7
Logo SublimeText
http://fr.wikipedia.org/wiki/Fichier:Sublime_Text_%28logo%29.png
Logo Git
http://devopsangle.com/2013/05/31/git-1-8-3-releases-with-better-triangular-work-flow-support/
Logo Node.js
http://www.redbubble.com/shop/free+stickers
Logo HTML5
http://www.w3.org/html/logo/
Logo CSS3
http://www.indigotheory.com/img/logo_css3.pn
Logo Javascript
http://imgarcade.com/1/javascript-logo/
Page 42 sur 46
AGI 2014-2015 - Istia
TABLE DES ANNEXES

ANNEXE 1 : MISE EN PLACE DU SERVEUR RUBY SUR RUBYMINE
GEM :
Cancan : https://github.com/ryanb/cancan/wiki/Role-Based-Authorization
Devise : https://github.com/plataformatec/devise
MySQL2 : http://dev.mysql.com/downloads/connector/c/
Bootstrap Form : https://github.com/bootstrap-ruby/rails-bootstrap-forms
Tlcharger le connecteur de la mme version que rails (32/64bit) Extraire le fichier dans C:
gem install mysql2 --platform=ruby -- '--with-mysql-lib="C:\mysqlconnector\lib" --with-mysql-include="C:\mysql-connector\include" --withmysql-dir="C:\mysql-connector"'
En cas d'erreur tlcharger le connecteur de la bonne version (6.0.2, 6.1.5 ...).
MISE EN PLACE :
bundle install
rake {db:drop} db:create db:migrate {RAILS_ENV=production}
rails s {-e production}
Pour dmarrer le wifi sil fonctionne mal :

sudo service hostapd start
sudo service dnsmasq start
Pour redmarrer le serveur Rails :

cd /path/to/rails/project/tmp
touch restart.txt
Page 43 sur 46
AGI 2014-2015 - Istia
ANNEXE 2 : MISE EN PLACE DU SERVEUR DACQUISITION DES DONNEES ARDUINO
PROCEDURE
Pour mettre en place le service sur l'Arduino au sein de la ruche, il faut diter le code afin de le
configurer.
Dans un premier temps, il faut dfini les ID de l'Arduino, de la ruche dans laquelle elle est place ainsi
que ceux des capteurs et leur type. Il faut galement configurer le principe d'acquisition des donnes et
l'adapter un ventuel nouveau priphrique.
Une fois configur, on peut dans un deuxime temps crire le programme dans le code de l'Arduino
grce l'IDE Arduino et on peut procder au branchement des diffrents priphriques sur les ports
dfinis dans le code.
Enfin, une fois dmarre et les priphriques branchs, le systme est autonome et se charge d'envoyer
les donnes intervalle rgulier.
EXEMPLE DE CODE
# for each sensor
for sensor in jsonDecoded["sensors"] :
# get sensor serial
sensorSerial = sensor["serial"]
querySensorId = "SELECT sensors.id from sensors LEFT JOIN arduinos ON
sensors.arduino_id = arduinos.id WHERE sensors.serial = " + str(sensorSerial)
+ " and arduinos.id = " + str(arduinoSerial) + " LIMIT 1"
cur.execute(querySensorId)
# get sensor id
sensorId = cur.fetchone()
if sensorId is not None:
sensorId = sensorId[0]
now = time.time();
len = len(sensor["values"])
# for each value (i => index, e => value)
for i, e in list(enumerate(sensor["values"])):
index = len-i-1
value = e
TIME_BETWEEN_ACQUISITION = 3600 # seconds
time = datetime.datetime.utcfromtimestamp(now - 3600 *
index).strftime('%Y-%m-%d %H:%M:%S')
queryDb = "INSERT INTO data(value,sensor_id,created_at,updated_at)
VALUES("+str(value)+","+str(sensorId)+",'"+str(time)+"','"+str(time)+"')"
cur.execute(queryDb)
db.commit()
Page 44 sur 46
AGI 2014-2015 - Istia
ANNEXE 3 : EXEMPLE DE CODE DU SERVEUR DACQUISITION DES DONNEES RASPBERRY
PROCEDURE
Il faut d'une part brancher le convertisseur USB/Serial afin de brancher le rcepteur HF la Raspberry.
Une fois branche, il faut vrifier sur quel port le systme est reconnu et le configurer dans le code
source.
Une fois la base de donnes cr grce au Ruby, on peut lancer le programme d'acquisition qui
rcuprera les informations pour les stocker dans la base de donnes. Le service Python est autonome
et ne ncessite aucune intervention une fois lanc et configur.
EXEMPLE DE CODE
// Arduino initialisation
void setup(void)
{
// Start software serial port
mySerial.begin(4800);
// Put emitter pin in output and low level
pinMode(EMITTER_PIN,OUTPUT);
digitalWrite(EMITTER_PIN, LOW);
// Initialize fictive bee Count
beeCount = 0;
// Init value 2d array
sensorsValue = (double **) (malloc(sensorsCount * sizeof(double)));
for(int i = 0; i < sensorsCount; i++)
{
sensorsValue[i] = (double*) (malloc(MAX_VALUES * sizeof(double)));
}
}
// Get data value For each sensor
for(int i=0; i<sensorsCount; i++)
{
// Local copies of data
sensor = aJson.createObject();
values = aJson.createArray();
// Add sensor serial number
aJson.addNumberToObject(sensor,"serial",sensorsSerial[i]);
// Add each value
for(int j=0;j<MAX_VALUES;j++)
{
if(sensorsValue[i][j] != -999)
{
value = aJson.createItem(sensorsValue[i][j]);
aJson.addItemToArray(values,value);
}
}
Page 45 sur 46
ANNEXE 4 : MACRO PLANNING VERSION PLEINE PAGE
Page 46 sur 46
AGI 2014-2015 - Istia
Ruche Intelligente
Projet ralis par : BRUN JOHAN, LIGNEUL FLORIAN ET MAUGIN THOMAS
Projet encadr par : M. LAGRANGE SEBASTIEN
RESUME
La diminution de la population d'abeille dans le monde est un vritable flau pour la nature et lhumanit.
Pour le combattre, de plus en plus de systmes se dveloppent grce l'informatique, afin d'assister et
soutenir les apiculteurs dans leur travail. Ce fut alors la thmatique de notre projet, crer un systme dans le
but de superviser l'tat de plusieurs ruches.
Ce projet de six mois fut trs large et couvrait un large panel de connaissances. De l'lectronique au site
Internet, tout tait faire. Pour ce faire, des capteurs ont t installs et connects une carte Arduino.
Ensuite venu la programmation d'un Rapberry Pi afin de traiter et stocker les donnes. De lArduino. Enfin, un
serveur web a t mis en place sur cette carte pour hberger notre site web et rendre les donnes rcoltes
consultables.
Pour ce faire, des recherches sur les diffrentes technologies ont t ncessaires afin de mettre en place
l'architecture du projet. Ce dernier fut dcoup en plusieurs parties, donc les diffrentes tches ont t
spares entre les membres du groupe. Un cycle de dveloppement en spirale a souvent t utilis, en
ajoutant les fonctionnalits une par une.
A la fin du projet, les fonctionnalits furent ralises. Plusieurs ruches pouvaient tre surveilles par
diffrents utilisateurs l'aide d'un ordinateur / mobile et un navigateur web.
Mots-cls : Arduino, Raspberry, Ruby, Web, Ruche
SUMMARY
The reduction of the number of bees in the world is a real problem for the nature and even for the humanity.
To fight against it, more and more systems are developed thanks to computer-science to assist beekeepers in
their work. It was the subject of our project; create a system to monitor several hives.
This 6-month project was very large, and covers a lot of knowledge. From electronic to website, all was left to
do. To begin, sensors were connected to an Arduino card. Next, the Raspberry was configured to process and
store data from Arduino. To finish, a web server has been set up to host our website, in order to display data.
For that purpose, some searches on different technologies were needed to set up the project architecture.
The latter was cut in several parts, so different tasks were separated between project members. A systems
development life cycle in spiral was often used, by adding features separately.
At the end of the project, all features were performed. Several hives could be monitored by different user
with a computer / mobile and a web browser.
Keywords: Arduino, Raspberry, Ruby, Web, Hive

Rapport Projet EI5 - Ruche Intelligente

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Rapport Projet EI5 - Ruche Intelligente

Încărcat de

Drepturi de autor:

Formate disponibile

Rapport de Projet Ruche Intelligente

AGI 2014-2015 - Istia

Projet encadr par

Rapport de Projet Ruche Intelligente

AGI 2014-2015 - Istia

ENGAGEMENT DE NON PLAGIAT

Je, soussign , dclare

Je, soussign , dclare

Rapport de Projet Ruche Intelligente

AGI 2014-2015 - Istia

Rapport de Projet Ruche Intelligente

AGI 2014-2015 - Istia

TABLE DES MATIERES

Rapport de Projet Ruche Intelligente

AGI 2014-2015 - Istia

4.4. Client web ........................................................................................................................................ 23

Rapport de Projet Ruche Intelligente

AGI 2014-2015 - Istia

Rapport de Projet Ruche Intelligente

AGI 2014-2015 - Istia

1.2. OBJECTIFS PEDAGOGIQUES

1.3. IDEE GENERALE DU PRODUIT

Rapport de Projet Ruche Intelligente

AGI 2014-2015 - Istia

2. TECHNOLOGIES ET OUTILS UTILISES

FIGURE 2 : LOGO CSS

En rsum, le HTML dfinit le contenu. Le CSS permet, d'arranger ce contenu et de dfinir

2.1.2. LANGAGES INTERPRETES

Rapport de Projet Ruche Intelligente

AGI 2014-2015 - Istia

Ce langage de nombreux avantages : il ne ncessite ni compilateur, ni logiciel de

2.1.3 LANGAGES COMPILES

FIGURE 6 : LOGO C++

2.1.4 UTILISATION DES LANGAGES

Site web (cot client)

Site web (cot client)- Ancien serveur dacquisitions des

Site web (cot serveur)

Rapport de Projet Ruche Intelligente

Serveur dacquisitions des donnes

AGI 2014-2015 - Istia

FIGURE 7 : UTILISATION DES LANGAGES

2.2. PLATEFORMES, LIBRAIRES ET FRAMEWORKS

2.2.2 RUBY ON RAILS

Rapport de Projet Ruche Intelligente

AGI 2014-2015 - Istia

2.3. OUTILS DAIDE AU DEVELOPPEMENT

git clone : permet de cloner le contenu dun serveur Git.

Rapport de Projet Ruche Intelligente

AGI 2014-2015 - Istia

2.3.2 SUBLIME TEXT 2

Rapport de Projet Ruche Intelligente

AGI 2014-2015 - Istia

Analyse et dfinitions des fonctionnalits

3.1. ANALYSE - FONCTIONNALITES

Visualiser le nombre dabeille dans

Visualiser le taux de temprature et

Visualiser un historique des donnes

Ajouter / modifier / supprimer une

Ajouter / modifier / supprimer un

Rapport de Projet Ruche Intelligente

AGI 2014-2015 - Istia

FIGURE 16 : SCHEMA DE L'ARCHITECTURE DU PROJET

Tout simplement la ruche contenant les abeilles et les capteurs