Rapport Projet EI5 - Ruche intelligente

Rapport de Projet « Ruche Intelligente »

AGI 2014-2015 - Istia

Ruche Intelligente Supervision de ruches en ligne Projet réalisé par Johan BRUN Florian LIGNEUL Thomas MAUGIN

Projet encadré par Sébastien LAGRANGE

Rapport de Projet « Ruche Intelligente »

AGI 2014-2015 - Istia

ENGAGEMENT DE NON PLAGIAT Je, soussigné …………………………………………………………………………………………………………………………, déclare être pleinement conscient(e) que le plagiat de documents ou d’une partie d’un document publiés sur toutes formes de support, y compris l’internet, constitue une violation des droits d’auteur ainsi qu’une fraude caractérisée. En conséquence, je m’engage à citer toutes les sources que j’ai utilisées pour écrire ce rapport ou mémoire.

Signature :

Je, soussigné …………………………………………………………………………………………………………………………, déclare être pleinement conscient(e) que le plagiat de documents ou d’une partie d’un document publiés sur toutes formes de support, y compris l’internet, constitue une violation des droits d’auteur ainsi qu’une fraude caractérisée. En conséquence, je m’engage à citer toutes les sources que j’ai utilisées pour écrire ce rapport ou mémoire.

Signature :

Je, soussigné …………………………………………………………………………………………………………………………, déclare être pleinement conscient(e) que le plagiat de documents ou d’une partie d’un document publiés sur toutes formes de support, y compris l’internet, constitue une violation des droits d’auteur ainsi qu’une fraude caractérisée. En conséquence, je m’engage à citer toutes les sources que j’ai utilisées pour écrire ce rapport ou mémoire.

Signature :

Page 1 sur 46

Rapport de Projet « Ruche Intelligente »

AGI 2014-2015 - Istia

REMERCIEMENTS Avant tout, il nous semble important de commencer ce rapport en remerciant M. Sébastien LAGRANGE, notre encadrant, qui nous a suivi durant ce projet et qui s’est toujours montré disponible pour répondre à nos questions. Nous tenons à remercier l’Istia et toute son équipe pédagogique 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 près ou de loin au développement de cette application.

Page 2 sur 46

Rapport de Projet « Ruche Intelligente »

AGI 2014-2015 - Istia

TABLE DES MATIERES Engagement de non plagiat ...................................................................................................................... 1 Remerciements ......................................................................................................................................... 2 Présentation du document ....................................................................................................................... 5 Contexte d’écriture ................................................................................................................................... 5 Présentation de l’équipe ........................................................................................................................... 5 1. Présentation du projet .............................................................................................................................. 6 1.1. Contexte ............................................................................................................................................. 6 1.2. Objectifs pédagogiques ...................................................................................................................... 6 1.3. Idée générale du produit ................................................................................................................... 6 1.4. Contraintes ......................................................................................................................................... 6 2. Technologies et outils utilisés ................................................................................................................... 7 2.1. Langages de développement ............................................................................................................. 7 2.2. Plateformes, Libraires et Frameworks ............................................................................................... 9 2.3. Outils d’aide au développement ...................................................................................................... 10 3. Travail réalisé .......................................................................................................................................... 12 3.1. Analyse - Fonctionnalités ................................................................................................................. 12 3.2. Conception ....................................................................................................................................... 13 3.3 Développement ................................................................................................................................ 18 3.4. Déploiement .................................................................................................................................... 18 3.5. Tests et améliorations ...................................................................................................................... 18 3.6 Bilan du travail réalisé ....................................................................................................................... 18 4. Développement....................................................................................................................................... 19 4.1. Acquisition des données - Electronique........................................................................................... 19 4.2. Traitement des données - Arduino .................................................................................................. 19 4.3 Acquisition des données - Raspberry Pi ............................................................................................ 21 4.4. Service web - Raspberry Pi ............................................................................................................... 21

Page 3 sur 46

Rapport de Projet « Ruche Intelligente »

AGI 2014-2015 - Istia

4.4. Client web ........................................................................................................................................ 23 4.5. Bilan de l’application ........................................................................................................................ 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 répartition des activités .................................................................................... 29 5.3. Gestion des sources avec Bitbucket ................................................................................................. 30 5.4. Séparation du travail ........................................................................................................................ 31 5.5. Gestion des tâches ........................................................................................................................... 32 5.6. Bilan de cette gestion....................................................................................................................... 32 6. Bilan global .............................................................................................................................................. 33 6.1. Idées d’amélioration ........................................................................................................................ 33 6.2. Aspects pédagogiques ..................................................................................................................... 33 6.3. Difficultés rencontrées ..................................................................................................................... 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 d’acquisition des données – Arduino .............................................. 44 Procedure ................................................................................................................................................ 44 Exemple de code ..................................................................................................................................... 44 Annexe 3 : Exemple de code du serveur d’acquisition des données – Raspberry...................................... 45 Procedure ................................................................................................................................................ 45 Exemple de code ..................................................................................................................................... 45 Annexe 4 : Macro planning version pleine page ......................................................................................... 46 Résumé ................................................................................................................................................... 47 Summary ................................................................................................................................................. 47

Page 4 sur 46

Rapport de Projet « Ruche Intelligente »

AGI 2014-2015 - Istia

INTRODUCTION PRESENTATION DU DOCUMENT Ce document fut conçu dans le cadre du projet tuteuré de la troisième année de cycle ingénieur dispensé pour le diplôme d’ingénieur par l’Istia à Angers (Institut des Sciences et Techniques de l’Ingénieur d’Angers). Il fut rédigé en deux semaines et clôt le projet. Ce document est le rapport récapitulant tout ce qui a été élaboré par notre équipe durant les 24 semaines de projet, sur une période allant du 22 Septembre 2014 au 11 Février 2015. Il présente la façon dont nous avons géré ce projet, les technologies utilisées, le travail réalisé puis établit un bilan de ce projet.

CONTEXTE D’ECRITURE Le présent document a pour but d’informer l’équipe pédagogique de toute l’organisation de notre projet, ce que l’on a produit, ce que l’on a appris, les outils utilisés, ainsi que les difficultés rencontrées. Remarque : Ce document pouvant être par moment technique, un glossaire a été rédigé en fin de ce document afin d’expliquer 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 3èmes année du cycle ingénieur (EI5), suivant le parcours Automatique et Génie Informatique (AGI) de l’Istia d’Angers. En voici les membres : ●

Johan BRUN

●

Florian LIGNEUL

●

Thomas MAUGIN

Nous étions encadrés tout au long de ce projet par M. Sébastien LAGRANGE, enseignant-chercheur à l’Istia.

Page 5 sur 46

Rapport de Projet « Ruche Intelligente »

AGI 2014-2015 - Istia

1. PRESENTATION DU PROJET 1.1. CONTEXTE Ce projet fut réalisé dans le cadre des projets tuteurés d’EI5. Le but est d’utiliser nos compétences, l’esprit de travail d’équipe et notre capacité à travailler en autonomie dans un projet innovant. Nous voulions un projet mélangeant différentes technologies, c‘est pourquoi nous avons choisi ce projet.

1.2. OBJECTIFS PEDAGOGIQUES Ce projet s’inscrit dans le cadre de notre formation en utilisant les connaissances et compétences en développement logiciel apprises durant les cours dispensés par l’Istia, et a pour objectifs de nous faire découvrir de nouvelles technologies, de mettre en œuvre nos capacités en gestion de projet à travers un travail en équipe, ainsi que de renforcer nos compétences en développement logiciel, à travers l’utilisation de langages de programmation.

1.3. IDEE GENERALE DU PRODUIT Le déclin des abeilles en France peut devenir un vrai problème 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 récupérer différentes données, qui seront enregistrées et archivées par un serveur web. De plus, le produit final sera pourvu d’une interface web (consultable à l’aide d’un navigateur web tel que Mozilla Firefox ou Google Chrome) afin de pouvoir configurer la supervision des ruches et consulter les données.

1.4. CONTRAINTES Ce projet n’a que peu de contraintes, mis à part les celles de temps. Nous n’avions pas besoin d’acheter de matériel, ayant déjà tout de fourni par l’Istia. Nous étions complètement libre vis-à-vis des technologies à utiliser.

Page 6 sur 46

Rapport de Projet « Ruche Intelligente »

AGI 2014-2015 - Istia

2. TECHNOLOGIES ET OUTILS UTILISES 2.1. LANGAGES DE DEVELOPPEMENT 2.1.1. LANGAGES WEB Afin d’afficher le site web, nous avons utilisé plusieurs langages web. Ceux-ci, bien qu’ayant des rôles différents, sont complémentaires. HTML (HyperText Markup Language) : créé en 1993, ce langage gère et organise le contenu du site. C’est un langage de balises (définies par < >, les plus connues sont et ). Chaque balise à sa signification et son utilité (par exemple, écrire Mon mot 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 appelées Feuilles de style) : créé en 1996, il gère l'apparence de la page (agencement, positionnement, décoration, couleurs, taille du texte…). Un fichier CSS est composé de plusieurs règles de présentation qui permettent d’appliquer des styles aux balises HTML.

FIGURE 2 : LOGO CSS

En résumé, le HTML définit le contenu. Le CSS permet, d'arranger ce contenu et de définir la présentation : couleurs, image de fond, marges, taille du texte… Javascript : Souvent abrégé JS, le JavaScript fut créé en 1995 par Brendan Eich. C’est un langage de programmation interprété, principalement utilisé dans les pages web dynamiques. C’est l’interpréteur du navigateur internet qui interprète le code afin de le faire fonctionner. Le JavaScript est un à l’origine un langage dit côté client, c'est-à-dire que les scripts sont exécutés par le navigateur de l’utilisateur. Cela diffère des langages de scripts dits côté FIGURE 3 : LOGO JS serveur qui sont exécutés par le serveur web. Mais désormais, grâce à nodeJs (voir plus bas), il est possible de développer des serveurs avec ce langage.

2.1.2. LANGAGES INTERPRETES Un langage interprété est un langage qui est lu par un interpréteur. Il exécute le programme au fur et à mesure de l’exécution. L’avantage 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 interprétés. Ruby : Ruby est un langage de programmation libre. Il est interprété 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

Rapport de Projet « Ruche Intelligente »

AGI 2014-2015 - Istia

concurrents Java et C# car il dispose lui aussi d’un “garbage collector” chargé de libérer de la mémoire au fur et à mesure de l’exécution du programme. Python : Le python est un langage orienté objet inventé dans les années 1990 par Guido van Rossum. La prochaine version publique créée en 1991. Il est multi-plateforme et multiparadigme. C’est un langage très largement utilisé pour la programmation impérative. Il est aussi adapté à la programmation d’un petit programme ou un plus gros projet.

FIGURE 5 : LOGO PYTHON

Ce langage à de nombreux avantages : il ne nécessite ni compilateur, ni logiciel de développement (IDE) particulier, l’interpréteur Python est souvent installé sur les machines, Windows comme Linux / Mac OS, il jouit de centaines de bibliothèques fiables et puissantes et il est souvent plus lisible que dans d’autres langages.

2.1.3 LANGAGES COMPILES Un langage compilé est un langage qui est transcrit en langage machine par le développeur à l’aide d’un compilateur. Il a l’avantage d’être exécuté plus rapidement, mais oblige le développeur à 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 spécificité d’être complètement libre (il n’appartient à personne) et compatible avec tous les systèmes (Linux, Windows…). C’est un des langages les plus utilisés dans le monde, de par son ancienneté mais également sa richesse de différentes librairies. De plus, être un langage compilé lui donne l’avantage d’être plus rapide que les langages interprétés, sachant que son code est transcrit en langage machine. Il est utilisé dans ce projet pour programmer l’Arduino.

FIGURE 6 : LOGO C++

2.1.4 UTILISATION DES LANGAGES L’utilisation de ces langages est renseignée dans la figure 7 ci-dessous : Langage

But

HTML / CSS

Site web (coté client)

Javascript

Site web (coté client)- Ancien serveur d’acquisitions des données

Ruby

Site web (coté serveur)

Page 8 sur 46

Rapport de Projet « Ruche Intelligente »

Python

Serveur d’acquisitions des données

C++

Programmation de l’Arduino

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. C’est une plate-forme logicielle construite sur l'exécution JavaScript de Chrome (avec le moteur V8) pour construire facilement des applications de réseau rapides et évolutives.

FIGURE 8 : LOGO NODEJS

Node.js utilise un modèle non-bloquant (par exemple, quand il demande une donnée à la base de données, le temps de recevoir la réponse, il va exécuter le code suivant et revenir une fois la réponse reçue), événementiel (son code n’est composé que de fonctions directement appelées par le client), ce qui le rend léger et efficace. Il est idéal pour les applications en temps réel requérant un grand nombre de données. La nouveauté de Node.js est qu’il rend désormais possible le développement de serveur à l’aide de JavaScript, qui n’est de ce fait plus seulement un simple langage côté client. Node.js intègre une bibliothèque de serveur HTTP qui permet de faire tourner un serveur web sans avoir besoin de logiciel externe. Cela permet également de contrôler la façon dont le serveur web fonctionne (directement dans le code). Pour assurer la communication client-serveur, Node.js utilise un système de socket (grâce à la librairie Node.js socket.io). Pour le reste, c’est la puissance du langage JavaScript qui s’exprime, un langage simple, enrichissable par des librairies externes et pouvant être utilisé en tant que langage objet. Node.js peut être enrichi, comme JavaScript, à l’aide de diverses librairies (appelées également packages), comme par exemple Node-schedule qui permet de programmer un événement à une date/heure précise.

2.2.2 RUBY ON RAILS Ruby on Rails est un framework open-source pour le langage Ruby. Suivant, le modèle MVC, il propose au développeur une architecture bien précise permettant de développer plus vite et plus intuitivement. Il ajoute également beaucoup de fonctions internes afin d’ajouter plus d’abstraction, c’est à dire permettre au développeur de développer de manière à s’occuper moins du code et plus des fonctionnalités du programme. FIGURE 9 : LOGO RUBY ON RAILS

Page 9 sur 46

Rapport de Projet « Ruche Intelligente »

AGI 2014-2015 - Istia

Nous avons décidé d’utiliser le langage Ruby avec le framework Ruby On Rails, car ce dernier propose une architecture MVC et un outil de scaffolding très utile pour débuter un projet et organiser son code de manière uniforme. La philosophie du framework est la suivante : “Ne vous répétez pas” et “Convention plutôt que configuration”, c’est pour cela qu’il dispose aussi d’une API REST en parallèle des contrôleurs et des vues “normales” du site ce qui était nécessaire pour le groupe travaillant sur l’application Android et qui permet de faire le travail beaucoup plus rapidement étant donné qu’il n’y a pas à refaire un projet pour le service web. Ruby dispose d’un gestionnaire de packet : RubyGem (équivalent de npm pour nodeJS). Il est très pratique pour installer et déployer des librairies, nous avons utilisé pas moins d’une vingtaine de gem pour ce projet (gestion des utilisateurs, des droits, déploiement …).

2.2.3. BOOTSTRAP Twitter Bootstrap, est une collection d’outils utiles à la création de sites web et applications web. C'est un ensemble qui contient des codes HTML et CSS, des formulaires, boutons, et autres éléments interactifs, ainsi que des extensions JavaScript en option. On y obtient, grâce à son utilisation, un site ergonomique et esthétique.

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 très simple à utiliser, et de ce fait est intégré dans 80 % des 10.000 sites web les plus visités sur l’Internet.

2.3. OUTILS D’AIDE AU DEVELOPPEMENT 2.3.1 GIT Git est un logiciel de gestion de sources, crée par Linus Torvalds, permettant un travail collaboratif entre plusieurs développeurs sur les mêmes sources. C’est un petit logiciel, créé à l’origine pour Linux puis adapté à Windows, facile à mettre en place (l’installation d’un serveur Git ne nécessite que quelques commandes sur le serveur de développement, ainsi que pour le client sur nos machines personnelles). Les commandes sont simples à retenir et peu d’entre elles nous sont vraiment utiles. Exemple des plus utilisées: ● ● ● ● ●

FIGURE 11 : LOGO JQUERY

FIGURE 12 : LOGO DE GIT

git clone : permet de cloner le contenu d’un serveur Git. git commit –a : insérer nos mises à jour dans un « paquet ». git status : voir l’état des sources (voir si elles ont été enregistrées dans des commits, combien de commits qui n’ont pas encore été envoyés au serveur). git push : envoyer les mises à jour au serveur. git pull : télécharger les dernières mises à jour.

Page 10 sur 46

Rapport de Projet « Ruche Intelligente »

● ●

AGI 2014-2015 - Istia

git clone : première à être utilisée sur nos postes afin de pouvoir cloner le dépôt Git créé sur le serveur. git checkout . : réinitialise l’espace de travail au dernier commit effectué ou téléchargé

Et pourquoi spécialement Git ? Il existe d’autres outils de gestion de sources, par exemple SVN. Mais Git était le seul outil de gestion déjà connu par plusieurs des membres du groupe. De plus, il existe sur le net Bitbucket qui permet de créer un dépôt 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 d’écriture par le développeur, ainsi que l’auto-complétion. Son interface simple et sa coloration efficace en fait un éditeur de code pratique. De plus, il peut être complété par différents plugins (par exemple, il est possible de rajouter un module pour la reconnaissance des différentes fonctions d’une librairie en cours d’utilisation).

FIGURE 13 : LOGO SUBLIME TEXT

2.3.3 RUBYMINE RubyMine est l’IDE pour Ruby édité par Jetbrains qui réalise toutes les fonctions de base d’un IDE (comme IntelliJ) et permet de lancer directement un serveur Rails. Il est à privilégier face au simple éditeur de texte, car la complexité d’un projet sur Ruby On Rails implique de nombreux fichiers et oblige l’utilisateur à disposer d’une auto-complétion efficace (ce que ne propose pas Sublime Text dans ce cas).

Page 11 sur 46

FIGURE 14 : RUBY ON MINE

Rapport de Projet « Ruche Intelligente »

AGI 2014-2015 - Istia

3. TRAVAIL REALISE Durant tout le projet, le travail réalisé fut composé de six grandes activités : ● ● ● ● ●

Analyse et définitions des fonctionnalités Conception Développement Déploiement Test et améliorations

3.1. ANALYSE - FONCTIONNALITES Le but du projet était de créer une “ruche intelligente”, c’est-à-dire de pouvoir superviser la ruche à distance à l’aide d’un système informatique tel qu’un ordinateur ou un mobile. La liste des fonctionnalités de ce projet est précisée en figure 15 : Numéro fonctionnalité

de Nom de la fonctionnalité

FT01

Visualiser le nombre d’abeille dans la ruche

FT02

Visualiser le taux de température et d’humidité dans la ruche

FT03

Visualiser un historique des données

FT04

Ajouter / modifier / supprimer une ruche à surveiller

FT05

Ajouter / modifier / supprimer un capteur d’une ruche FIGURE 15 : FONCTIONNALITES DE BASE DU PROJET

Page 12 sur 46

Rapport de Projet « Ruche Intelligente »

AGI 2014-2015 - Istia

3.2. CONCEPTION Le but de cette phase est de définir une architecture de notre projet, afin de réaliser les “plans” et que chacun puisse travailler dessus. Ce projet est un mélange d’électronique et d’informatique. On retrouve plus que le développement d’un logiciel. Ces différentes 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

Rôle

Ruche

●

Tout simplement la ruche contenant les abeilles et les capteurs

Arduino

● ●

Collecter les données des capteurs de la ruche Envoyer les données à la Raspberry grâce à un émetteur HF (Haute Fréquence)

ARF-53

●

Emetteur / Récepteur HF (Haute Fréquence). Utilise la liaison série

Raspberry Pi

● ● ● ●

Hébergement de la base de données Réception des données de l’Arduino Stockage de ses données dans la base de données Hébergement du service web

Wifi

●

Le wifi permet à un mobile ou un ordinateur de consulter les données mise à disposition par la Raspberry Pi

●

Interface de l’utilisateur permettant de visualiser les données à travers le wifi de la Raspberry Pi.

Smartphone Ordinateur

/

FIGURE 17 : DIFFERENTES PARTIES DU PROJET

Page 13 sur 46

Rapport de Projet « Ruche Intelligente »

AGI 2014-2015 - Istia

DETAILS SUR LA RASPBERRY PI Cette carte programmable est le cœur du projet. En effet, elle effectue un grand nombre d’actions. Elle est alors décomposée en plusieurs parties (voir figure 18 et figure 19 pour les détails).

FIGURE 18 : COMPOSITION DE LA RASPBERRY PI

Nom de la partie

Fonction

Interface Série

Entrée / Sortie série de la Raspberry. Sert à la réception des données de l’Arduino

Serveur Python

Réception des données de l’Arduino et stockage dans la base de données

Base de données

Stockage des données des capteurs des ruches, les configurations utilisateurs et des comptes sur site web

Page 14 sur 46

Rapport de Projet « Ruche Intelligente »

AGI 2014-2015 - Istia

Serveur Ruby

Serveur web qui héberge le site web.

Interface Web

Interface web où les utilisateurs pourront se connecter au serveur Ruby et consulter les données 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 à l’utilisateur des interfaces web. Il héberge alors un site web. On peut découper ce dernier en trois parties (voir figure 20) : ●

Le client, contenant l’ensemble des interfaces graphiques. Elles permettront à l’utilisateur de consulter les données récoltées par le serveur Python. ● Le serveur, qui traite et restitue les données ● La base de données, qui stocke les données. On rappelle que dans notre cas, le serveur et la base de données se trouve au même endroit, sur la carte Raspberry Pi. On se retrouve avec une application de type client serveur, très utilisé dans le web, où généralement le client demande une information, le serveur traite la demande et renvoie l’information sous forme d’une page contenant du HTML, du CSS et du Javascript. Le navigateur de l’utilisateur se contente alors d’afficher cette page.

FIGURE 20 : FONCTIONNEMENT CLIENT SERVEUR

Page 15 sur 46

Rapport de Projet « Ruche Intelligente »

AGI 2014-2015 - Istia

D IAGRAMME DE CLASSE Le service web étant un logiciel, une conception préliminaire est nécessaire afin de tracer les plans créer un projet propre et organisé. Pour ce faire, nous avons alors réalisé un diagramme de classe afin que chacun puisse se baser dessus (voir figure 21)

FIGURE 21 : DIAGRAMME DE CLASSE DE L'APPLICATION WEB

Les différents objets sont précisés dans le tableau en figure 22. Nom de l’objet

Description

User (Utilisateur)

Représente un utilisateur de l’application.

Hive (Ruche)

Représente une ruche. Elle est reliée à une Arduino

Sensor (Capteur)

Représente un capteur. Il a relié à une Arduino et dispose d’un Type.

SensorType (Type capteur)

Représente le type d’un capteur (humidité, température…)

Page 16 sur 46

Rapport de Projet « Ruche Intelligente »

Arduino

Représente 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 créer un site web maintenable, l’utilisation de l’architecture MVC (figure 23) est un bon choix.

Qu’est-ce que MVC ? MVC, pour “Modèle Vue Controller” est une méthode d’organisation du code qui réalise un découpage en trois parties. Le principe est simple : on isole la partie qui contient les données (Model) et la partie qui affiche les données (Vue). Le contrôleur (Controller) fait office de “routeur”. Une analogie intéressante est celle de la télévision : ● Le fournisseur des chaînes est le Model. Il contient toutes les données mais ne gère pas l’affichage La vue est la télévision. Il reçoit des données du fournisseur et les affiches à l’utilisateur. La télécommande de l’utilisateur est le contrôleur : il choisit quelle donnée afficher.

FIGURE 23 : SCHEMA DE L'ARCHITECTURE MVC

● ●

NOTES SUR LE CHOIX DES TECHNOLOGIES Nous avons dans un premier temps choisi de faire l’acquisition des données des Arduinos à l’aide de NodeJS, mais il s’est rapidement avéré que ce langage et la mise en place d’un serveur NodeJS était trop importante par rapport à la simple tâche réalisée. Nous nous sommes donc tournés vers un langage plus robuste et plus simple à mettre en place : Python. En effet les distributions Linux sont presques toutes en possession d’un interpréteur 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 découvrir de nouveaux outils (et pourquoi pas un nouveau langage). C’est très rapidement que nous avons vu que Ruby et le framework Ruby On Rails étaient très populaires. D’une part, car ce langage à une syntaxe allégé et d’autre, car Ruby dispose d’un gestionnaire de paquet très puissant et très important. Rails est

Page 17 sur 46

Rapport de Projet « Ruche Intelligente »

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 intégré au site web...

3.3 DEVELOPPEMENT Cette partie fera l’objet d’un chapitre entier, car, comme mentionné dans la partie 5 de ce document, le développement nous a occupés environ les trois quarts de notre projet. Donc, dans un souci d’équilibrage de nos parties et de clarté, cette partie sera ne sera pas détaillée ici.

3.4. DEPLOIEMENT Le déploiement d’un environnement fonctionnant sur Ruby On Rails est assez délicat, en effet d’un côté Ruby est un langage interprété disposant de plusieurs versions et nécessitant de compiler l’interpréteur depuis les sources et d’un autre on dispose d’une Raspberry Pi aux performances limités avec système d’exploitation aux fonctionnalités restreintes. Ce qui rend l'opération difficile car le déploiement d’une application Ruby On Rails nécessite beaucoup de ressources processeur, dans notre cas la Raspberry Pi mettait plus d’une demi-journée pour installer l'environnement de déploiement. Il ne fallait donc faire aucune erreur sous peine de devoir perdre encore une demi-journée. En ce qui concerne le python, le déploiement a été très rapide, car les distributions linux classiques dispose toute d’un interpréteur Python. Il suffit de lancer le programme automatiquement au démarrage 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 adéquats 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 problèmes avec la portée de l’émetteur haute fréquence. Quelques améliorations ont ensuite été réalisées, en particulier au niveau énergique.

3.6 BILAN DU TRAVAIL REALISE Notre objectif de départ est réalisé, à savoir donner la possibilité à un utilisateur de consulter d’état d’une ou plusieurs ruches en temps réel et pouvoir visualiser un historique sur ces données. Le cahier des charges initialement rédigé est complètement respecté.

Page 18 sur 46

Rapport de Projet « Ruche Intelligente »

AGI 2014-2015 - Istia

4. DEVELOPPEMENT Avant d’aborder cette partie, il serait bon de rappeler deux points :

4.1. ACQUISITION DES DONNEES - ELECTRONIQUE Pour acquérir les informations relatives à la ruche, nous disposons de plusieurs capteurs. L’un d’entre eux est le DHT11, un capteur bon marché qui permet de mesurer la température et l’humidité. Pour l’utiliser nous devons utiliser la librairie DHT pour Arduino permettant de communiquer facilement avec ce type de capteur. Une fois librairie installée nous n’avons plus qu’à utiliser quelques fonctions pour récupérer les données. 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 d’énergie nous avons décidé de faire hiberner l’Arduino entre chaque acquisition. Pour cela nous avons encore une fois utilisé une librairie : LowPower, elle permet de passer l’Arduino dans un mode où elle ne consomme presque plus d’énergie. Elle fonctionne de façon 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 méthode on peut faire chuter la consommation de 40mA à 6.5mA. Ce qui n’est pas négligeable puisque l’Arduino ne fonctionne pas pendant plus de 99% du temps. On passe d’une consommation journalière de 960mAh à 156mAh soit une réduction de 83% de la consommation énergique.

4.2. TRAITEMENT DES DONNEES - ARDUINO Une fois les données enregistrées il est nécessaire de les envoyer à la Raspberry Pi, pour cela nous avons décidé de ne pas envoyer les données une par une, mais par bloc. Cette méthode présente l’avantage de consommer moins d’énergie. En effet, il n’est pas nécessaire d’allumer l’émetteur plusieurs fois par jour mais seulement une fois (dans notre cas). La consommation d’énergie est un point important étant donné que nous n’utilisons qu’une unique source d’énergie : le soleil. Il faut donc faire le maximum pour l’économiser.

Page 19 sur 46

Rapport de Projet « Ruche Intelligente »

AGI 2014-2015 - Istia

La communication entre l’Arduino et la Raspberry se fait par une liaison série 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 d’un peu plus près la trame on s’aperçoit qu’il est donné un “serial” pour chaque capteur et Arduino. Ce sont les identifiants uniques qui sont nécessaires pour faire le traitement en base de données. Nous devons en disposer pour pouvoir facilement installer de nouveaux capteurs. Prenons l’exemple de deux ruches organisées comme sur la figure 27:

FIGURE 27 : EXEMPLE D'ORGANISATION DE DEUX RUCHES

Avec un système d'identifiant unique pour chaque Arduino, il n’est pas nécessaire que celui des capteurs soit différent. Nous pouvons donc facilement avoir des pairs Arduino/Capteur ce qui simplifie la modularité lorsqu’on a besoin d’ajouter de nouvelles ruches. Pour ajouter une nouvelle ruche on ajoute une nouvelle Arduino avec un nouveau serial et on peut grader la même configuration de capteurs sans avoir à faire de modifications (voir image).

Page 20 sur 46

Rapport de Projet « Ruche Intelligente »

AGI 2014-2015 - Istia

4.3 ACQUISITION DES DONNEES - RASPBERRY PI Les valeurs sont reçues en lisant les données arrivant sur le port série de la Raspberry Pi. Pour cela, nous avons dans un premier temps utilisé nodeJS qui permet de facilement traiter les données JSON mais qui manque de modularité en termes de réception série et de performance. C’est après avoir rapidement fait une ébauche en Javascript que nous nous sommes rendu compte que ce n’était pas forcement le meilleur choix de prendre ce langage, car il est assez lourd à déployer par rapport à la simple tâche d’enregistrer des données dans une base de données qu’il réalisait. Nous avons donc opté pour le Python. En effet ce langage est déjà présent sur de nombreuses distributions Linux (notamment celle de Raspbian) ce qui nous a permis de l’utiliser directement sans avoir à installer de nombreuses dépendances. Nous avons alors installé une librairie qui permet de lire et de traiter du JSON puis nous avons procédé de la même manière qu’avec NodeJS mais en Python.

Dans un premier temps l’application attend l'arrivée de message sur le port série. Quand un paquet arrive, il fait la correspondance entre les serials des différents capteurs et l‘ID du capteur en base de données pour ensuite enregistrer les valeurs dans la base de données MySQL. Ce procédé est assez simple, mais à besoin d’être fait valeur par valeur puisqu’il faut “reconstruire” la date de chaque acquisition en fonction de leur ordre dans le message. Ainsi la dernière valeur date de la réception du message alors que la 24ieme valeur a été prise il y à 24h.

4.4. SERVICE WEB - RASPBERRY PI Le site web a été réalisé à l’aide du langage Ruby et le framework Ruby On Rails. Ce framework dispose d’une architecture MVC et d’une API REST. C’est un grand avantage, en effet l’API et les vues se basent sur le même contrôleur, nous n’avons donc pas besoin de faire deux fois le travail pour réaliser les mêmes fonctions. On voit sur la figure 21 l’organisation des classes de l’application. Tout s’oriente autour de la classe “Ruche”, une ruche dispose d’une ou plusieurs arduinos, qui elles-mêmes disposent d’un ou plusieurs capteurs. Ces classes sont analogues à la configuration physique de la ruche. Ainsi il est beaucoup plus facile d’installer des nouveaux capteurs. Il suffit de faire “virtuellement” la même installation.

GESTION DES COMPTES La classe utilisateur est créé à l’aide de la gem devise, les vue associées à la gestion des utilisateurs (création, modification, oublie de mot de passe …) sont également générées automatiquement par cette librairie à l’aide de l’outil de scaffolding. Pour gérer les droits de chaque utilisateur nous avons utilisé la gem : cancan, celle-ci apporte des méthodes qui permettent de définir très simplement les droits d’un utilisateur sur les modèles de Rails. Ainsi on peut autoriser un utilisateur à modifier une ruche, un autre

Page 21 sur 46

Rapport de Projet « Ruche Intelligente »

AGI 2014-2015 - Istia

à seulement les afficher quant au dernier on peut lui interdire tout accès. Dans notre cas nous avons créé quatre rôles (figure 28): ● ● ● ●

Administrateur, qui est le propriétaire de l’application et qui dispose de tous les droits. Modérateur qui dispose également de tous les droits, mais qui n’est pas le propriétaire de l’application. 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

Modérateur

Enregistré / Anonyme

Voir

x

x

x

Modifier

x

x

Banni

FIGURE 28 : GESTION DES DROITS DES UTILISATEURS SUR L'APPLICATION WEB

Pour des raisons d’accessibilité, les utilisateurs non enregistrés peuvent quand même visualiser les ruches. Mais on peut à tout moment modifier la configuration pour rendre obligatoire l’inscription. On peut noter que la gem devise propose des moyens d’authentification poussés comme OmniAuth qui permet de se connecter avec son compte Google, Facebook, Twitter… Le service web a été réalisé en même temps que l’application web. En effet Rails implémente automatiquement une API REST dans ses contrôleurs. Avec une simple configuration on peut obtenir les mêmes routes que pour l’application web. Il faut seulement rajouter “.json” à la fin de l’url pour passer par l’API. Les “vue” du service web son réalisé à l’aide de JSON Builder, il permet d’exposer les propriétés des objets en JSON de manière 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

Rapport de Projet « Ruche Intelligente »

AGI 2014-2015 - Istia

ARCHITECTURE L’architecture d’une application Ruby On Rails est assez classique. On retrouve un dossier App contenant les vues, les contrôleurs et les modèles (MVC), on dispose aussi d’un 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 déploiement et au lancement de l’application (base de données, boot, tâche avant lancement…).

Le fichier Gemfile liste toutes les dépendances du projet (à la manière d’un package.json en NodeJS), de cette manière on peut installer un serveur assez rapidement en téléchargeant les librairies automatiquement. Nous n’allons pas expliquer le rôle 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, très connu, développé et utilisé par Twitter. Nous avons utilisé les composants de base comme le menu latéral, les champs de formulaire (à l’aide de la gem bootstrap_form) ce qui a simplifié le développement. Les couleurs de bases ont été remplacées par nos couleurs (orange et noir) avec quelques réécritures 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 l’icône d’une ruche, celle-ci change de couleur et devient plus grosse, c’est une animation assez simple à réaliser et très efficace pour le confort l’utilisateur. On retrouvera une screen de l’application en figure 31.

Page 23 sur 46

Rapport de Projet « Ruche Intelligente »

AGI 2014-2015 - Istia

FIGURE 31 : CAPTEUR D’ECRAN DE L'APPLICATION WEB

Pour afficher des graphiques, la librairie highstock a été importée dans Rails à l’aide 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 homogénéité dans le codage, il n’y avait que très peu de code Javascript (et JQuery) pour gérer la partie métier.

@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

+

"

("

+

Rapport de Projet « Ruche Intelligente »

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 L’APPLICATION Au final l’application apporte les fonctions suivantes : Fonctionnalité

Détail Gestion de compte

Enregistrement d’un utilisateur

Création d’un compte à la demande avec login + mdp

Modification du compte d’un utilisateur

Modification mot de passe, email, suppression du compte

Suppression d’un compte utilisateur

Suppression d’un compte à la demande de l’utilisateur ou un admin

Connexion / déconnexion à un compte

Connexion à un compte avec le couple login / mdp

Gestion de l’oublie du mot de passe

Une fois compte mail configuré, envoi d’un formulaire pour que l’utilisateur puisse saisie un nouveau mot de passe Gestion de ruches

Affichage d’une ruche

Affichage de toutes les informations des ruches

Modification d’une ruche

Modification de la valeur des attributs d’une ruche

Page 25 sur 46

Rapport de Projet « Ruche Intelligente »

AGI 2014-2015 - Istia

Gestion de capteurs Affichage d’un capteur

Affichage de toutes les informations d’un capteur

Modification d’un capteur

Modification de la valeur des attributs d’un capteur

Comparaison entre plusieurs capteurs

Comparaison de la valeur des attributs d’un capteur

Modification d’un type de capteur

Modification du type à partir d’un type dans une liste

Image personnalisé pour chaque capteur Autre Tableau d’administration

Tableau de bord pour la visualisation des informations : ● Ruche ● Capteur ● Type de capteur ● Valeur des capteurs ● Utilisateur ● Arduino

Modification d’une 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 très utiles pour alléger le travail du développeur. La plupart des librairies que nous avons utilisées permettent de remplacer une librairie Javascript par une interface en Ruby. Highstock aurait pu être utilisé en Javascript mais son implémentation aurait été plus compliquée. Les formulaires adaptés à Bootstrap auraient pu être réalisés manuellement en Ruby, mais la librairie Bootstrap_form permet d’automatiser cette tâche. On peut dire que la philosophie de Ruby On Rails a été, nous avons utilisé les gem pour éviter de faire des répétitions et nous avons utilisé les conventions de Ruby On Rails pour pouvoir déployer rapidement

Page 26 sur 46

Rapport de Projet « Ruche Intelligente »

AGI 2014-2015 - Istia

une application fonctionnelle. L’API pour le groupe sur l’application Android a été implémentée très facilement étant donné que les conventions de Ruby On Rails ont été suivies scrupuleusement. Au terme des ce projet, l’application 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

Rapport de Projet « Ruche Intelligente »

AGI 2014-2015 - Istia

5. GESTION DE PROJET 5.1. CYCLE DE VIE Ayant un projet mêlant électronique, carte programmable et service web, le cycle de vie du projet peut être découpé en deux sections : acquisition / traitement des données (arduino/raspberry) et consultation des données (site web). Pour cette première partie, le plus logique fut de développer en partant du plus bas niveau (électronique), pour ensuite coder la partie pour lire les données des capteurs, les envoyer à la Raspberry Pi, les stocker dans la base de données.

FIGURE 34 : ORDRE DE DEVELOPPEMENT DE PARTIE BAS NIVEAU

Pour la deuxième partie, axée logiciel, un cycle de développement en spirale fut adoptée (voir figure 35)

En effet, chaque fonctionnalité fut étudiée, implémentée et testée. Une fois validée, le développement vers la fonctionnalité suivante pouvait commencer. Ce cycle de développement permet un développement plus souple, où différentes fonctionnalités peuvent être réalisées en parallèle. De plus, on dispose d’une meilleure vue d’ensemble sur l’avancement de l’application.

FIGURE 35 : CYCLE DE VIE EN SPIRALE

Page 28 sur 46

Rapport de Projet « Ruche Intelligente »

AGI 2014-2015 - Istia

Analyse / Spécification Cette phase est l’analyse des besoins du client, et la spécification des fonctionnalités de l’application. Mots clés de cette période : imagination et pragmatisme. Conception Phase primordiale, elle permet de réfléchir et de concevoir notre future application avant de se jeter corps perdu dans la programmation. Cette phase, souvent négligé dans les petits projets, reste une phase importante, car elle permet de bien définir les différents objets de l’application, l’architecture, ainsi que les maquettes des interfaces graphiques. C’est un peu comme l’architecte qui dessine les plans de la maison en veillant bien à respecter le cahier des charges, afin que l’ouvrier n’ait pas à réfléchir comment faire, mais simplement faire. L’idée de la phase de conception est là : réfléchir et définir avant de construire, afin de savoir par où commencer, mais également pour éviter les risques de devoir tout refaire, car on n’avait pas pensé à un détail (imaginez-vous vouloir mettre une salle de bain au deuxième étage de votre maison alors que la plomberie ne se limite qu’au rez-de-chaussée… “J’aurais dû y penser avant”, diriez-vous). Mots clés de cette période : compréhension et réflexion. Test / Validation La plus longue période, mais également la plus enrichissante. Globalement, cette phase réunie proportionnellement trois activités : “apprentissage”, “recherche de solutions” et “écriture du code”. Cette dernière devait être effectuée avec rigueur, en prenant garde à respecter les règles définies en conception et en faisant l’effort de conserver un code propre. “Laissez toujours le code plus propre que vous ne l’avez trouvé”. Mots clés de cette période : rigueur et réflexion.

5.2. MACRO-PLANNING ET REPARTITION DES ACTIVITES Le projet peut être décomposé en différentes phases: ● ● ● ● ● ●

Electronique et codage de l’Arduino Paramétrage de la Raspberry Codage du serveur de données (x2 car nous avons utilisé deux technologies) Codage du serveur web Codage du client web (interfaces graphiques) Mise en place de la base de données

Page 29 sur 46

Rapport de Projet « Ruche Intelligente »

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 différentes activités : ● ● ● ● ●

Electronique (branchement et configuration des capteurs) Etude (étude des différentes technologies) Conception Codage (écriture du code) Tests

La répartition du temps consacré à chaque activité est précisé en figure 37.

FIGURE 37 : REPARTITION EN TEMPS DES DIFFERENTES TACHES

5.3. GESTION DES SOURCES AVEC BITBUCKET Durant le développement en équipe, nous étions obligés d’avoir un lieu où centraliser toutes nos sources. Nous avons donc choisi le site web Bitbucket.org pour cela. C’est un service web

Page 30 sur 46

Rapport de Projet « Ruche Intelligente »

AGI 2014-2015 - Istia

d'hébergement et de gestion de développement de logiciels, utilisant le programme Git, qui permet aux développeurs travaillant sur le projet, de télécharger la dernière version du code et d’envoyer leurs modifications du code. Le site fournit également des fonctionnalités de type réseaux sociaux : flux, suivi de personnes ou de projets, graphes de réseau pour les dépôts, etc. Durant le développement, lorsqu’un fichier est créé ou mis à jour, par un développeur il est donc «commité» puis envoyé au serveur par l’intermédiaire de la commande git push. Puis, une fois connecté au site du dépôt, 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 séparation du travail est un concept indispensable lors du travail en équipe. Participant à un projet regroupant différents technologies, avons donc opté pour ce découpage du travail, selon les envies, les compétences et goûts des personnes : ● Arduino (récupération des données des capteurs) : Florian ● Raspberry (traitement des données en temps réel) : 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 d’un code Arduino et Raspberry fonctionnel. Bien entendu, tout n’était pas rigide, et un peu de souplesse permettait d'accélérer le développement. Cela signifie que n’importe qui pouvait toujours travailler sur la partie d’un autre pour résoudre une

Page 31 sur 46

Rapport de Projet « Ruche Intelligente »

AGI 2014-2015 - Istia

erreur, ou encore implémenter de lui-même une partie de programme afin de tester son code. Le seul risque à faire cela est la création d’un “conflit”, mais qui était souvent relativement simple et rapide à résoudre.

5.5. GESTION DES TACHES Toutes les tâches durant le projet ont été gérées de manière “agile”. Ici, pas de chef de projet, chacun était libre de créer une tâche à réaliser et la poster sur BitBucket (voir figure 39). Ensuite, chacun indiquait la tâche qu’il avait choisi de réaliser, et notifia le site lors que la tâche fut réalisée et postée sur le serveur.

FIGURE 39 : GESTION DES TACHES DE BITBUCKET

5.6. BILAN DE CETTE GESTION Le point le plus important est que les délais ont été respectés. A partir de là, cette gestion peut être considérée comme une réussite. Au-delà de ça, la charge de travail n’a jamais trop variée, les semaines étaient assez équilibrées et nous n’avons jamais dû quadrupler notre temps de travail en approche des deadlines. La gestion est restée agile et le plus important fut la communication entre les différents membres. Le système de “to-do list” est vraiment efficace, qui permet de découper le travail en un ensemble de tâches simples. De plus, cela permet de rien oublier durant le développement du projet.

Page 32 sur 46

Rapport de Projet « Ruche Intelligente »

AGI 2014-2015 - Istia

6. BILAN GLOBAL 6.1. IDEES D’AMELIORATION Avec un projet tel que celui là, beaucoup de fonctionnalités pourraient être ajoutées. Nous en proposerons ici que quelques-unes : ● ● ● ● ● ●

Authentification avec Facebook, Google… Gestion de plusieurs ruches pour plusieurs apiculteurs (droits, visibilité …) Site disponible depuis l’Internet. Personnalisation du thème Changement de langue Envoi d’emails et d’alertes

6.2. ASPECTS PEDAGOGIQUES Nous avons beaucoup appris, tout d’abord un plan technique, car les enseignements proposés par l’Istia n’ont pas portés sur tous les domaines utilisés. Nous avons pu redécouvrir le fonctionnement événementiel et asynchrone de Node.js, même si nous n’avons finalement pas conservé cette technologie. Nous avons également appris à programmer en Ruby et à utiliser un framework Ruby On Rails. Certes, plusieurs connaissances que l’on nous a enseignées nous furent utiles, comme la programmation objet, quelques principes de conception logiciel, l’algorithmique ou encore le développement 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 managérial (développement en équipe, séparation du code). Puis, pour finir, nous avons également appris sur le plan humain, où nous constatons qu’il faut faire preuve d’humilité, d’écoute, d’entraide et de patience pour bien travailler en équipe. Le métier de développeur ne se résume 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 rencontrée a été celle de configurer la Raspberry Pi pour qu’elle puisse fonctionner avec Ruby. En effet- il est nécessaire, d’installer le SDK de Ruby avant de pouvoir déployer une application Ruby. Pour cela nous avons utilisé Passenger, c’est un outil qui automatise le déploiement d'applications Ruby (NodeJS…) sur Apache et sur NGinx.

Page 33 sur 46

Rapport de Projet « Ruche Intelligente »

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 d’avoir de bonnes performances pour compiler nos sources (de même pour celle de Ruby et Rails).

Les modules ARF-53 ont été compliqués à prendre en main étant donné que nous ne disposions pas de la documentation (seulement au début) et que leur mise en place est assez difficile, il faut regarder ce qu'envoie les modules sur le port série pour pouvoir les déboguer. Dans notre cas, les vitesses de communication n’étaient pas les bonnes, nous ne pouvions même pas savoir ce qui ne fonctionnait pas. C’est après de nombreuses tentatives que nous avons trouvé la bonne combinaison.

Page 34 sur 46

Rapport de Projet « Ruche Intelligente »

AGI 2014-2015 - Istia

6.4. AVIS PERSONNELS Johan Pour ma part, ce fut une expérience assez enrichissante, que ce soit en termes de développement que de gestion de projet. Le travail en équipe a vraiment du bon, car il nous apprend l’humilité, l’écoute et la compréhension. On apprend de l’autre, qui saura toujours quelque chose que vous ne savez pas. Niveau technique, j’ai pu perfectionner mes compétences en développement, en algorithmique mais électronique que j’ai pu suivre de loin. Ce projet fut très instructif pour moi, de par sa large diversité en technologies. Les tâches furent distribuées au début du projet, selon les goûts et les compétences de chacun. Florian Au cours de ce projet, j’ai pu d’une part utiliser et approfondir mes connaissances de développement et de gestion de projet et d’autre part découvrir de nouvelles technologies, notamment le Ruby et son framework Ruby On Rails. Le fait d’avoir travaillé sur un projet très complet (de l’étude jusqu’à la réalisation finale) m’a permis de bien comprendre le cycle de création d’une solution technologique complexe. Du fait du travail d’équipe sous Git, j’ai dû durant ce projet apprendre à bien gérer mon code ainsi que sa documentation pour ne pas pénaliser les autres développeurs. Ce projet, en plus d’une aventure technologique a été pour moi une aventure humaine plaisante et instructive tant personnellement que professionnellement. Thomas Ce projet m’a permis de découvrir un nouveau langage : Ruby et le framework Rails qui lui est la plupart du temps associé, Ce n’est pas en soi une découverte, mais plutôt l’apprentissage d’une nouvelle syntaxe. En effet Ruby comme tout langage orienté objet reprend les grandes lignes de Java ou bien de C# mais avec une forme différente. C’est un essayant de nouveaux langages comme celui-ci, qu’on apprend de nouvelles astuces et qu’on peut conforter ses choix technologiques futurs. J’ai aimé la partie communication avec la ruche, puisque que cette étape impliquait de devoir toucher à pas mal de domaines, l’électronique, l’administration réseau, la mise en production d’application… L’organisation et la gestion du projet (notamment avec git) et le travail en équipe ont été des points importants qu’il ne fallait pas négliger. La gestion des bugs et des améliorations nous ont appris à formaliser nos besoins et à communiquer de manière plus efficace.

Page 35 sur 46

Rapport de Projet « Ruche Intelligente »

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 découvert la technologie Ruby on Rails qui commence à être de plus en plus populaire dans le monde du développement Web, et qui sera de plus en plus utilisé et apporte donc une vrai valeur ajouté à notre capital de connaissances. Il en est de même pour Bootstrap. Nous avons conduit un projet du bas niveau au haut niveau et donc pu couvrir un large panel de compétences. Et dans le deuxième cas, le travail en équipe fait beaucoup appel à nos qualités sociales : l’humilité, la patience, l’entraide. C’est important dans un travail en équipe, et c’est durant ce genre de projet que l’on s’en rend compte. La cohésion sociale du groupe est le pilier du projet, qui ne peut aboutir sans cela. Notre projet est à la hauteur du cahier des charges prévu. Cependant, les différents problèmes rencontrés nous ont beaucoup ralentis et même avec beaucoup de travail, il faut toujours du temps pour apprendre, comprendre et bien utiliser de nouvelles technologies. Si c’était à refaire, nous garderions l’architecture mise en place, car nous la trouvons robuste et bien organisée.

“Intelligence is the ability to avoid doing work, yet getting the work done.” Linus Torvald

Page 36 sur 46

Rapport de Projet « Ruche Intelligente »

AGI 2014-2015 - Istia

GLOSSAIRE API (Application Programming Interface) : Ensemble de classes et de fonctions qui servent d’interface à une bibliothèque (library en Anglais). Il fait la communication entre le logiciel et le contenu de cette bibliothèque. Auto-complétion : C’est le fait que le logiciel de développement propose au développement des noms de fonction / variable lorsque qu’il est en train d’écrire le code. Base de données : Outil permettant de stocker des données. Les données peuvent être de différentes natures, et desfois liées entre elles. Client-serveur : architecture très utilisée sur le web. Désigne un mode de communication à travers un réseau entre plusieurs programmes ou logiciels : le client, envoie des requêtes ; le ou les serveur(s) attend(ent) les requêtes des clients et y répond(ent). Design pattern : c’est un patron utilisé en conception. Il permet de résoudre des problèmes en imposant une structure. Par exemple, le pattern Observer permet de mettre à jour une vue à chaque changement des données sans que la couche traitement n’ait référencé la couche vue. Framework : ensemble de composants qui servent à créer les fondations, l'architecture et les grandes lignes d'un logiciel. L'objectif premier d'un framework est d'améliorer la productivité des développeurs qui l'utilisent. IDE : pour « Integrated Development Environment », logiciel disposant de multiples outils embarqués afin d’aider et d’assister le développeur dans le développement d’un logiciel. JSON : Format de données de plus en plus utilisé pour la communication entre différents programmes informatiques. Langage de programmation : un langage qui permet aux développeurs d'écrire des instructions qui seront analysées et traitées par l'ordinateur. Langage interprété : langage non compilé, c’est-à-dire qu’aucun fichier exécutable (.exe) n’est créé, le code source reste tel quel. Si l’on veut exécuter ce code, on doit le fournir à un interpréteur qui se chargera de le lire et de réaliser les actions demandées. Langage multi-paradigme : C’est un langage pouvant utiliser plusieurs principes, comme par exemple la programmation orienté objet ou la programmation impérative. Liaison série : La communication série consiste à transmettre des informations après les avoir préalablement découpées en plusieurs morceaux de taille fixe (cette taille est le nombre de lignes de

Page 37 sur 46

Rapport de Projet « Ruche Intelligente »

AGI 2014-2015 - Istia

communication disponibles). Elle s'oppose à la communication parallèle où les informations à transmettre n'ont pas à être découpées avant d'être envoyée. Open-source : La désignation open source, ou « code source ouvert », s'applique aux logiciels dont la licence respecte des critères précisément établis par l'Open Source Initiative, c'est-à-dire les possibilités de libre redistribution, d'accès au code source et de création de travaux dérivés. Programmation impérative : En informatique, la programmation impérative est un paradigme de programmation qui décrit les opérations en séquences d'instructions exécutées 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 très rapidement en code machine et l'optimise même, grâce à des procédés complexes. MVC : Le patron modèle-vue-contrôleur (en abrégé MVC, de l'anglais model-view-controller), tout comme les patrons modèle-vue-présentation ou Présentation, abstraction, contrôle, est un modèle destiné à répondre aux besoins des applications interactives en séparant les problématiques liées aux différents composants au sein de leur architecture respective. MySQL : C’est un système de gestion de bases de données. Il s’oppose à MongoDb, car il utilise le langage SQL Navigateur web : logiciel servant à afficher des pages au format html se trouvant sur le web. Plus techniquement, c’est un client http. Programmation événementielle : logique de programmation raisonnant sur des évènements, c’est-àdire que quand il se passe telle chose, alors on fait cela. Elle s'oppose à la programmation séquentielle. Programmation orienté objet : Un langage de programmation orienté objet s’inspire de ce qui nous entoure. Par exemple, nous pouvons disposer d’un objet voiture, qui est composé de 4 objets roues, 1 objet moteur… une voiture est également un objet véhicule (objet parent). Ces différents objets possèdent des caractéristiques spécifiques. REST : REST (Representational State Transfer) est un style d’architecture pour les systèmes hypermédia distribués, créé par Roy Fielding en 2000 dans le chapitre 5 de sa thèse de doctorat. Scaffolding : L'échafaudage ou scaffolding en anglais est une manière de concevoir des logiciels liés à une base de données. Cette technique est souvent fournie avec le patron de conception Modèle-VueContrôleur, dans lequel le programmeur écrit une spécification décrivant comment la base de données sera utilisée.

Page 38 sur 46

Rapport de Projet « Ruche Intelligente »

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 données entre applications et systèmes hétérogènes dans des environnements distribués Socket : Canal réseau permettant la communication entre deux programmes informatiques.

Page 39 sur 46

Rapport de Projet « Ruche Intelligente »

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 : Fonctionnalités 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 d’écran 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

Rapport de Projet « Ruche Intelligente »

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 différents 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

Rapport de Projet « Ruche Intelligente »

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

Rapport de Projet « Ruche Intelligente »

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 Télécharger le connecteur de la même 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 télécharger 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 démarrer le wifi s’il fonctionne mal : sudo service hostapd start sudo service dnsmasq start

Pour redémarrer le serveur Rails : cd /path/to/rails/project/tmp touch restart.txt

Page 43 sur 46

Rapport de Projet « Ruche Intelligente »

AGI 2014-2015 - Istia

ANNEXE 2 : MISE EN PLACE DU SERVEUR D’ACQUISITION 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 défini les ID de l'Arduino, de la ruche dans laquelle elle est placée ainsi que ceux des capteurs et leur type. Il faut également configurer le principe d'acquisition des données et l'adapter à un éventuel nouveau périphérique. Une fois configuré, on peut dans un deuxième temps écrire le programme dans le code de l'Arduino grâce à l'IDE Arduino et on peut procéder au branchement des différents périphériques sur les ports définis dans le code. Enfin, une fois démarrée et les périphériques branchés, le système est autonome et se charge d'envoyer les données à intervalle régulier.

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

Rapport de Projet « Ruche Intelligente »

AGI 2014-2015 - Istia

ANNEXE 3 : EXEMPLE DE CODE DU SERVEUR D’ACQUISITION DES DONNEES – RASPBERRY

PROCEDURE Il faut d'une part brancher le convertisseur USB/Serial afin de brancher le récepteur HF à la Raspberry. Une fois branchée, il faut vérifier sur quel port le système est reconnu et le configurer dans le code source. Une fois la base de données créé grâce au Ruby, on peut lancer le programme d'acquisition qui récupérera les informations pour les stocker dans la base de données. Le service Python est autonome et ne nécessite 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