Eclipse IoT pour un scénario domotique

SmartRoom
Eclipse IoT pour un
scénario domotique
Réalisé par : Ismail Atitallah & Yang Tai
Encadré par : Mme Chantal Taconet
1
SmartRoom
2
SmartRoom
Table of Contents
Introduction .............................................................................................................................................. 5
1.
Internet of Things .......................................................................................................................... 6
2.
Eclipse IoT ........................................................................................................................................ 6
2.1 Défintion ......................................................................................................................................... 6
2.2 Contexte .......................................................................................................................................... 7
3.
Projet ASR ......................................................................................................................................... 8
3.1 Objectif du Projet ........................................................................................................................ 8
3.2 Choix du framework utilisé ..................................................................................................... 8
3.2.1 MQTT ....................................................................................................................................... 8
3.2.2 Choix Adapté ..................................................................................................................... 10
3.3 Application mobile « SmartRoom » .................................................................................. 11
3.4 Raspberry Pi et Grove Pi ....................................................................................................... 11
3.4.1 Raspberry Pi ...................................................................................................................... 11
3.4.2 Grove Pi ............................................................................................................................... 12
3.6 Scénarios ..................................................................................................................................... 13
3.6.1 Scénario Affichage message humeur ....................................................................... 13
3.6.2 Scénario Green : ............................................................................................................... 14
3.6.3 Scénario Réveil public .................................................................................................... 15
3.6.4 Scénario Lampe Nuit ...................................................................................................... 17
3.6.5 Scénario Porte Ouverte.................................................................................................. 19
3.7 Gestion de projet ...................................................................................................................... 20
4. Problèmes rencontrés ................................................................................................................... 20
5. Continuité du projet ....................................................................................................................... 21
Conclusion .............................................................................................................................................. 22
Remerciments ....................................................................................................................................... 23
Annexes .................................................................................................................................................... 24
Annexe 1 : Liste des tâches réalisées ....................................................................................... 24
Annexe2 : code sur le Raspberry pour le scénario « message Humeur » .................. 26
Annexe 3 : code java de l’interface « Message Humeur » ................................................. 29
3
SmartRoom
Figure 1: Etape "Subscribe" MQTT ................................................................................................... 9
Figure 2: Etape "Publish » MQTT ................................................................................................... 10
Figure 3: L’interface principale de SmartRoom ........................................................................ 11
Figure 4: Photo Raspberry ............................................................................................................ 12
Figure 5: Photo Grove Pi ................................................................................................................ 12
Figure 6: L’interface du scénario Message Humeur ................................................................ 13
Figure 7: L’architecture du scénario Message Humeur ......................................................... 14
Figure 8: L’interface du scénario Green ................................................................................... 15
Figure 9: L’architecture du scénario Green ................................................................................ 15
Figure 10: Les deux interfaces du scénario Reveil Public .................................................... 16
Figure 11: L’architecture du scénario Reveil Public ............................................................... 17
Figure 12: L’interface du scénario Lampe de nuit ................................................................... 18
Figure 13: L’architectures du scénario Lampe de nuit .......................................................... 18
Figure 14: L’interface du scénario Porte ouverte ..................................................................... 19
Figure 15: L’architecture du scénario Porte Ouverte ............................................................. 20
4
SmartRoom
Introduction
L’horizon de l’Internet des objets est celui d’un monde toujours plus densément connecté
qui relie les hommes, les données et les objets dans un écosystème numérique
désormais global.
Les objets connectés représentent un important relais de croissance économique selon
de nombreuses études. Ils ouvrent la possibilité de connecter les personnes ou les objets
de manière plus pertinente, de fournir la bonne information au bon destinataire et au
bon moment, ou encore de faire ressortir les informations utiles à la prise de décision.
Nous vivons aujourd’hui une révolution numérique globale, une nouvelle révolution
industrielle, alimentée par l’essor des objets connectés, que nous appellerons Internet of
Things (IoT), l’Internet du Tout connecté.
5
SmartRoom
1. Internet of Things
L’Internet des objets (IdO) est une « infrastructure mondiale pour la société de
l'information, qui permet de disposer de services évolués en interconnectant des objets
(physiques ou virtuels) grâce aux technologies de l'information et de la communication
interopérables existantes ou en évolution ». En réalité, la définition de ce qu’est l’Internet
des objets n’est pas figée. Elle recoupe des dimensions d’ordres conceptuel et technique.
D’un point de vue conceptuel, l’Internet des objets caractérise des objets physiques
connectés ayant leur propre identité numérique et capables de communiquer les uns
avec les autres. Ce réseau crée en quelque sorte une passerelle entre le monde physique
et le monde virtuel.
D’un point de vue technique, l’IdO consiste en l’identification numérique directe et
normalisée (adresse IP, http…) d’un objet physique grâce à un système de communication
sans fil qui peut être une puce RFID, Bluetooth ou Wi-Fi.
Les objets connectés produisent de grandes quantités de données dont le stockage et le
traitement entrent dans le cadre de ce que l’on appelle les big data. En logistique, il peut
s’agir de capteurs qui servent à la traçabilité des biens pour la gestion des stocks et les
acheminements. Dans le domaine de l’environnement, il est question de capteurs
surveillant la qualité de l’air, la température, le niveau sonore, l’état d’un bâtiment, etc.
En domotique, l’IdO recouvre tous les appareils électroménagers communicants, les
capteurs (thermostat, détecteurs de fumée, de présence…), les compteurs intelligents et
systèmes de sécurité connectés des appareils de type box domotique.
Le phénomène IdO est également très visible dans le domaine de la santé et du bien-être
avec le développement des montres connectées, des bracelets connectés et d’autres
capteurs surveillant des constantes vitales. Selon diverses projections (cf. Cisco et le
cabinet Gartner), le nombre d’objets connectés devrait largement augmenter au fil des
ans.
2. Eclipse IoT
2.1 Défintion
Eclipse IoT : est un ensemble de logiciels open source pour l'internet des objets.
L’équipe d’Eclipse créent une communauté open source qui fournira les blocs de
construction open source pour créer un Internet des objets. La communauté Eclipse IoT
fournit des projets open source que les développeurs peuvent utiliser pour créer leurs
solutions IdO.
6
SmartRoom
Le premier projet Eclipse IdO commencé en Novembre 2012. Il y a maintenant 12 projets
différents open source visant IoT et M2M. Voici un rapide tour d'horizon de ces projets.
 Paho fournit la mise en œuvre de client du protocole de messagerie MQTT Oasis.
Paho inclut Java, C, C ++, Python, JavaScript et d'autres implémentation du langage
de la norme MQTT.
 Mosquitto est le projet de la sœur de l'Paho, fournissant une application de
serveur de MQTT. Nous organisons un exemple de test de mosquitto au
« iot.eclipse.org » afin que les développeurs puissent facilement tester leurs
applications basées sur MQTT.
 Californium est une implémentation Java de protocole d'application limitée.
 OM2M est une implémentation de la norme OneM2M (précédemment appelé de
norme ETSI M2M). OM2M est un ensemble de services Java et OSGi qui mettent
en œuvre la norme d’OneM2M.
 Wakaama est une implémentation du protocole OMA Léger M2M pour les
périphériques et la gestion de services. Wakaama est écrit en C et conçu pour être
portable POSIX systèmes conformes.
 Kura est un ensemble de services Java et OSGi qui mettent en œuvre les services
communs nécessaires à une passerelle IdO
 Eclipse SCADA (Supervisory Control and Data Acquisition) est un ensemble de
services Java et OSGi pour la création de systèmes de contrôle industriels qui
surveillent et contrôlent les processus industriels, tels que les planchers d'usine
ou des fermes solaires.
 Eclipse SmartHome est un ensemble de services pour l'intégration de la
domotique Java et OSGi. Ce projet fournit un point d'accès unique pour les
différents dispositifs et protocoles domotiques.
 Ponte est un courtier qui va combler différentes normes IdO (tels que MQTT et
CoAP) et fournir une API REST à ces normes.
 Concierge est une implémentation de la norme OSGi qui vise à avoir un très faible
encombrement de l'exécution de sorte qu'il est adapté pour les petits appareils
IdO.
 Krikkit est un projet visant à définir des règles pour les messages qui passent à
travers un dispositif de bord.
 Mihini est un cadre basé sur Lua pour créer des applications fonctionnant sur
l'internet des objets et M2M passerellesProjet
2.2 Contexte
Avec l'Internet des objets, les objets communicants/capteurs/actuateurs sont
accessibles à travers Internet.
Quels sont les logiciels qui rendront cela possible ?

Comment écrire la logique d'un objet communicant
7
SmartRoom


Quel service pour transmettre des notifications depuis les objets vers les
applications
Comment construire une application qui reçoit des notifications depuis des
objets communicants et agit sur des objets communicants ?
Dans le cadre de notre projet ASR, nous avons voulu mettre en avant les aspects
les plus intéressants de logiciels d’Eclipse IoT.
3. Projet ASR
3.1 Objectif du Projet
Le projet consiste dans un premier temps à étudier ces logiciels, notamment au
travers du GreenHouse tutorial qui connecte à l'Internet un Raspberry, un capteur
d'humidité et de température, une lampe LED, puis de définir notre propre
scénario de démonstration à partir d'objets connectés, d'open data pour
construire une application IoT basée sur les logiciels Eclipse IoT.
3.2 Choix du framework utilisé
3.2.1 MQTT
MQTT (Message Queuing Telemetry Transport) est un standard qui implémente le
paradigme publish-subscribe C’est à travers ce standard que les compteurs
d’électricité, les véhicules, les détecteurs, les équipements industriels ou de santé
transfèreront des données entre eux ou avec des serveurs.
3.2.1.1 Pourquoi MQTT et pas un autre ?
MQTT est ouvert, simple, léger et facile à mettre en œuvre. Il est idéal pour
répondre aux besoins suivants :
- Particulièrement adapté pour utiliser une très faible bande passante,
- Idéal pour l’utilisation sur les réseaux sans fils,
- Faible consommateur en énergie,
- Très rapide, il permet un temps de réponse supérieur aux autres standards du
web actuel,
- Permet une forte fiabilité si nécessaire,
- Nécessite peu de ressources processeurs et de mémoires.
3.2.1.2 MQTT : Comment ça marche ?
MQTT est un service de publication/abonnement TCP/IP simple et extrêmement
léger. Il fonctionne sur le principe client/serveur.
8
SmartRoom
Le serveur, nommé broker, va collecter des informations que les publishers (les
Objet communicants) vont lui transmettre. Certaines informations collectées par
le broker sont renvoyées à certains publishers ayant préalablement fait la
demande au broker.
Le principe d’échange est très proche de celui de Twitter. Les messages sont
envoyés par les publishers sur un canal appelé topic. Ces messages peuvent être
lus par les subscribers (abonnés). Les topics (ou canaux d’informations) peuvent
avoir une hiérarchie qui permet de sélectionner finement les informations que l’on
désire.
Les messages envoyés par les objets communications peuvent être de toutes
sortes mais ne peuvent excéder une taille de 256 Mo.
3.2.1.3 Exemple
Le topic ‘/home/salon/temperature’ communiquera les températures du salon si
un object connecté s’y abonne (la sonde de température présente dans le salon
publiera régulièrement la température relevée sur ce topic). Si un publisher
s’abonne au topic ‘/home/salon/#’ il recevra toutes les données du salon (on peut
imaginer : luminosité, humidité, température…).
S’il s’abonne au topic ‘/home/#’, il collectera toutes les données des sondes de la
maison.
Figure 1: Etape "Subscribe" MQTT
9
SmartRoom
Figure 2: Etape "Publish » MQTT
Les trois clients établissent une connexion TCP avec le broker. Les clients B et C
souscrivent au topic température. Le Client A publie sur le topic température une
valeur de 22,5°. Le broker propage le message à tous les clients ayant
préalablement souscrit au topic Temperature.
3.2.1.4 Sécurité
Les données IoT échangées peuvent s’avérer très critiques, c’est pourquoi il est
possible de sécuriser les échanges à plusieurs niveaux :
 Transport en SSL/TLS,
 Authentification par certificats SSL/TLS,
 Authentification par login/mot de passe.
3.2.2 Choix Adapté
Eclipse IoT propose des frameworks pour le MQTT : Paho et Mosquitto, On a
décidé de les utiliser pour notre démonstration.
 Paho fournit la mise en œuvre de client du standard de messagerie MQTT Oasis.
Paho inclut Java, C, C ++, Python, JavaScript et d'autres implémentation du langage
de la norme MQTT.
 Mosquitto est le projet de la sœur de l'Paho, fournissant une application de
serveur de MQTT. Nous organisons un exemple de test de Mosquitto au
« iot.eclipse.org » afin que les développeurs puissent facilement tester leurs
applications basées sur MQTT.
10
SmartRoom
3.3 Application mobile « SmartRoom »
SmartRoom est une application mobile Android qui sert à automatiser la chambre
d’une personne. Cette application est caractérisée par 5 fonctionnalités comme
montre la figure 1.
Figure 3: L’interface principale de SmartRoom
3.4 Raspberry Pi et Grove Pi
3.4.1 Raspberry Pi
Le Raspberry Pi est un nano-ordinateur monocarte à processeur ARM. Cet
ordinateur, qui a la taille d'une carte de crédit, est destiné à encourager
l'apprentissage de la programmation informatique; il permet l'exécution de
11
SmartRoom
plusieurs variantes du système d'exploitation libre GNU/Linux et des logiciels
compatibles.
Le Raspberry Pi possède un processeur ARM11 à 700 MHz. Il inclut 1, 2 ou 4 ports
USB, un port RJ45 et 256 Mo de mémoire vive pour le modèle d'origine (512 Mo
sur les dernières versions54). Son circuit graphique BMC VideoCore 4 permet de
décoder des flux Blu-Ray full HD (1080p 30 images par seconde), d'émuler
d’anciennes consoles et d'exécuter des jeux vidéo relativement récents.
Le Raspberry communique avec SmartRoom grâce des codes java exécutables
dans le Raspberry.
Figure 4: Photo Raspberry
3.4.2 Grove Pi
Grove Pi est une carte électronique que vous pouvez vous connecter à des
centaines de différents capteurs, de sorte que vous pouvez les programmer
pour surveiller, contrôler, et les dispositifs d'automatisation dans votre vie.
Figure 5: Photo Grove Pi
12
SmartRoom
3.6 Scénarios
L’application est déployée sur tous les mobiles des personnes des scénarios. La
personne principale est Bob. Toutes les communications entre SmartRoom et
Raspberry se font par MQTT.
3.6.1 Scénario Affichage message humeur
Dans ce scénario, on utilise un RGB Backlight LCD et un Buzzer. Grâce à un écran
se trouvant dans la chambre commune de l’appartement, les colocataires peuvent
afficher dans la chambre les messages saisis sur leur téléphone portable. A partir
de SmartRoom, une personne saisit le message et puis invoque la méthode
Publish(« asr/msg »,msg) [annexe2]. Et puisque le Raspberry est déjà en écoute
grâce à Subscribe(« asr/msg ») [annexe3], le message sera affiché dès que le
Raspberry le reçoit et l’affiche sur l’écran LCD en activant une alerte sonore avec
le capteur Buzzer.
Figure 6: L’interface du scénario Message Humeur
13
SmartRoom
Figure 7: L’architecture du scénario Message Humeur
3.6.2 Scénario Green :
A travers un capteur de température et un RGB Backlight LCD, on construit un
système avec lequel on peut récupérer la valeur de la température de la chambre
et l’afficher sur le RGB Backlight LCD. Ecran LCD est connecté au Grove Pi par le
bus 1. Le capteur de température est connecté au Grove Pi par le pin A0. Grove Pi
est monté sur le Raspberry. Toutes les 5 min, le capteur mesure la température
qui est affichée sur l’écran LCD et les mobiles abonnés. Cette valeur est envoyée
vers
l’application
« SmartRoom »
en
faisant
Publish
(« asr/bob/temperature/resultat », temp). Et enfin la valeur est affichée sur
SmartRoom grâce à Subscribe(« asr/bob/temperature/resultat »).
14
SmartRoom
Figure 8:
L’interface du scénario Green
Figure 9: L’architecture du scénario Green
3.6.3 Scénario Réveil public
Dans ce scénario, on utilise un Buzzer et un bouton.
Les personnes et les évènements autorisés déclenchent la sonnerie du réveil de Bob.
15
SmartRoom
1er cas : Bob ne peut pas se réveiller tôt même s’il règle le réveil. Mais il a son ami Alice
qui peut se réveiller tôt toujours. Donc Bob autorise Alice à déclencher un réveil pour Bob
pour le réveiller.
2ème cas : Bob X dorme toujours l’après-midi. Donc il a besoin de se réveiller lorsque son
amie Alice est disponible pour travailler sur leur projet. Donc Bob autorise Alice à
déclencher un réveil pour le réveiller.
L’autorisation et le buzz se fait par l’application « SmartRoom ». En saisissant le sujet sur
lequel il autorise le réveil (par exemple examenMath, CoursesTerminées, Ismail, Yang),
Bob invoque la méthode Publish(« asr/bob/reveil/authorize »,topic). Et puisque le
Raspberry est déjà en écoute grâce à Subscribe(« asr/bob/reveil/authorize »), elle reçoit
le topic et s’inscrit directement au sujet lié au buzz par la méthode
Subscribe(« asr/reveil/bob/topic »). L’ami de Bob, Alice, saisit le topic. Et maintenant, elle
peut invoquer la méthode Publish(« asr/reveil/bob/topic »,reveil) pour déclencher le
Buzzer. Pour arrêter le Buzzer, Bob doit presser sur un bouton branché au Raspberry
pendant 10 secondes. Et comme ça Alice est sûr que Bob est réveillé.
Figure 10: Les deux interfaces du scénario Reveil Public
16
SmartRoom
Figure 11: L’architecture du scénario Reveil Public
3.6.4 Scénario Lampe Nuit
Dans ce scénario, on utilise un capteur de lumière et un led.
Ce scénario a pour but de faire fonctionner une lampe dès que l’éclairage est très
faible, d’éteindre toutes les lampes lorsqu’il y a une luminosité forte. En plus, ce
scénario sert à gérer l’état des lampes des chambres à distance.
Le capteur de luminosité mesure toujours l’éclairage. Lorsqu’il est faible, une
lampe led s’allume. Et donc Bob peut savoir l’état des lampes de sa chambre à
partir de SmartRoom. A partir de l’application « SmartRoom », Bob fait appel à la
fonction Publish(« asr/bob/lamp/request »,request) à travers l’interface de
l’application « SmartRoom ». Celui-ci, inscrite à ce sujet, elle reçoit le message
request et appelle la fonction Publish(« asr/bob/lamp/»,etat_lampe). SmartRoom
reçoit les états des lampes par Subscribe(« asr/bob/lamp/») et l’affiche sur
l’interface de l’application « SmartRoom ». Lorsque Bob change l’état d’une lampe
de sa chambre, la méthode Publish(« asr/bob/lamp/update») est invoquée
instantanément. Le Raspberry met à jour les états des lampes de la chambre via s
Subscribe(« asr/bob/lamp/update»).
17
SmartRoom
Figure 12: L’interface du scénario Lampe de nuit
Figure 13: L’architecture du scénario Lampe de nuit
18
SmartRoom
3.6.5 Scénario Porte Ouverte
Dans ce scénario, on utilise un capteur de son et un Buzzer.
Ce scénario a pour but de déclencher une alarme lors d’intrusion.
Lorsque le Raspberry a mesuré des valeurs positifs à partir du capteur son, une
alarme se déclenche et la méthode Publish(« asr/bob/porte »,alerte) est
invoquée. L’application « SmartRoom » reçoit l’alerte par la méthode
Subscribe(« asr/bob/porte ») et une notification sera affichée sur l’écran du
mobile.
Pour arrêter le buzzer, X envoie un message Stop via l’application « SmartRoom »
par la méthode Publish(« asr/X/porte/stop »,stop). Et en recevant le message, le
Raspberry arrête le buzzer.
Figure 14: L’interface du scénario Porte ouverte
19
SmartRoom
Figure 15: L’architecture du scénario Porte Ouverte
3.7 Gestion de projet
Le projet a été réalisé en binôme sous la coordination de Mme Chantal Taconet.
Des réunions hebdomadaires ont été programmées pour faire le point sur
l’avancement du projet qui a été mené selon la méthode Agile.
Cette agilité nous a permis de suivre la progression du projet de bout en bout et
de rendre compte au plus près des tâches que nous réalisions chaque
semaine. Dorénavant, une analyse de la complexité des tâches nous
permet de prédire celles qui sont les plus difficiles et les plus longues à exécuter.
En ce qui concerne la partie développement, nous avons codé
sous
Eclipse Kepler. Nous avons développé l’intégralité de notre projet sous un dépôt
GIT en y déposant nos sources et sous un dépôt SVN en y
déposant nos documents et notre suivi du projet. Le backlog du suivi du projet
s’est effectué sous ZIM. Voici la liste des tâches effectuées tout au long du projet,
leur priorité selon MuSCoW et leur complexité suivant la suite de Fibonacci
[annexe1].
4. Problèmes rencontrés
Les problèmes majeurs qui ont été rencontrés ont été principalement dus aux
problèmes des capteurs : Le LCD et le capteur de son parfois cessent de fonctionner. Donc,
comme solution, on retire tous les capteurs et les branche de nouveau. Si ça ne fonctionne
20
SmartRoom
pas, on arrête le Raspberry et de le démarre de nouveau.
Sans oublier les problèmes de développement avec ADT : Il ne charge pas le projet, il fait
des fausses dépendances. Comme solution, on essaye de redémarrer ADT. Sinon, on crée
un nouveau workspace et on importe notre projet.
Un autre problème majeur est le manque d’une bibliothèque java pour Grove Pi
approuvée par le groupe Dexter qui est le fondateur du Grove Pi. Heureusement on a
trouvé une bibliothèque développée par un utilisateur « Dan Jackson » sur le lien suivant :
https://openlab.ncl.ac.uk/gitlab/dan.jackson/pitutorials/blob/39a6b5591c4207e265600f029b7fcde5a7868905/ubicomp-practicals/p1introduction-rpi.md
5. Continuité du projet
Nous estimons ajouter le Multiprise ALLNET ALL4076 pour le scénario Lampe de nuit et
aussi nous voulons ajouter une caméra au scénario porte ouverte.
Nous estimons de rendre les deux scénarios « Green » et « Lampe de nuit » automatique.
C’est-à-dire l’utilisateur n’a pas besoin de cliquer sur le bouton pour voir la température
ou l’état des lampes.
21
SmartRoom
Conclusion
Notre mission principale consistait à concevoir et à réaliser une démonstration d’internet
des objets avec Eclipse Iot. Pour ce faire, nous nous sommes dans un premier temps autoformés sur tous les logiciels nécessaires à la réalisation de la démonstration (SVN, GIT,
Maven) ainsi que sur les outils importantes pour pouvoir exploiter le Raspberry et les
capteurs.
Nous avons pu faire fonctionner tous les scénarios mais il en reste quelques améliorations.
Au terme de notre projet, nous avons acquis une plus ample connaissance de l’Eclipse IoT
ainsi que ses frameworks Paho et Mosquitto.
22
SmartRoom
Remerciments
Nous tenons à exprimer notre gratitude à nos chers encadrants Madame Chantal
TACONET et Monsieur Djamel BELAID pour nous avoir accordés leur confiance et pour les
conseils qu’ils nous ont prodigué et pour les ressources matérielles mises à notre
disposition tout au long de notre projet
Nous exprimons également notre très haute considération et nos vifs remerciements à
tous les membres du jury.
De très nombreuses personnes dont les noms ne sont pas cités nous ont aidés,
encouragés et conseillés. Nous espérons pouvoir un jour leur témoigner notre ample
reconnaissance.
23
SmartRoom
Annexes
Annexe 1 : Liste des tâches réalisées
[MUST][1] {Ismail, Yang} : Création du compte fusionforge et envoi du login.
[MUST][1] {Chantal} : Créer le projet fusion forge, ajout des utilisateurs et création
des listes de diffusion.
[MUST][1] {Ismail, Yang} Choix de petit matériel
[MUST][1] {Chantal} Achat des petits matériels
[*] [MUST][1]{Chantal}Avertir quand matériel est arrivé
[*] [MUST][1] {Ismail, Yang} Discussion sur matériel et installations
* installation logiciel : zim, git-all, junit4, maven, java 8, eclipse
[*] [MUST][1] {Ismail, Yang} : suivre le tutoriel Git http://progit.org, chapitre «
Git Basics »
[*] [MUST][1] {Ismail, Yang} : suivre le tutoriel Git http://progit.org, chapitre «
Getting Started »
[*] [MUST][1] {Ismail, Yang} : installation locale de la dernière version de
Maven (version 3) dans ~/Local/Maven
* j'ai extrait maven 3.2.3 dans mon répertoire /home/export
M2_HOME=/home/brice/Mavenleon/Local/Maven-3.2.3
* j'ai ensuite ajouté ces deux lignes suivantes à mon fichier .bashrc (~/.bashrc) :
* export M2_HOME=/home/leon/Local/Maven-3.2.3
* export PATH=${M2_HOME}/bin:${PATH}
* pour savoir si l'ajout dans PATH a été réalisé correctement, je tape dans une
console :
* echo $PATH
[MUST][1] {Ismail, Yang} : lire dans le livre « Maven by example » le chapitre «
Customizing a Maven Project »
[MUST][1] {Ismail, Yang} : suivre le tutoriel « Maven Getting Started Guide »
http://maven.apache.org/guides/getting-started/
[MUST][1] {Ismail, Yang} : lire dans le livre « Maven by example » le chapitre « A
Simple Web Application »
[MUST][1] {Ismail, Yang} : lire dans le livre « Maven by example » le chapitre « A
[MUST][3] {Ismail, Yang} : Préparer une présentation sur les briques logicielles
Eclipse-IoT (12) et identifier ceux sur lesquels travailler en priorité
[MUST][3]{Ismail, Yang} : Présentation mi-parcours
[MUST][5] {Yang} : MQTT
[MUST][1] {Ismail, Yang} : Regarder la vivacité d'eclipse IoT
[MUST][11]{Ismail,
Yang}
:
faire
le
tutoriel
eclipse
IoT
http://iot.eclipse.org/java/tutorial
24
SmartRoom
[MUST][11]{Ismail, Yang} : ajouter un nouveau capteur, mettre à jour côté
raspberry et côté client
[MUST][11]{Ismail, Yang} : Définir la démonstration finale
[SHOULD][11]{Ismail, Yang} décrire le scénario
[MUST][11]{Ismail, Yang} : Développement scénario humeur
[MUST][11] {Ismail, Yang}: Développement scénario green
[MUST][11] {Ismail, Yang}:Développement scénario Lumière
[MUST][11] {Ismail, Yang}: Trouver un nouveau scénario
[MUST][11] {Ismail, Yang}: Développement scénarios réveil public
[SHOULD][11]{Ismail, Yang} Avertir le propriétaire s’il y a une personne qui a entré
dans la chambre pendant son absence
25
SmartRoom
Annexe2 : code sur le Raspberry pour le scénario « message Humeur »
import
import
import
import
import
import
org.eclipse.paho.client.mqttv3.IMqttDeliveryToken;
org.eclipse.paho.client.mqttv3.MqttCallback;
org.eclipse.paho.client.mqttv3.MqttClient;
org.eclipse.paho.client.mqttv3.MqttConnectOptions;
org.eclipse.paho.client.mqttv3.MqttException;
org.eclipse.paho.client.mqttv3.MqttMessage;
import
import
import
import
import
grovepi.GrovePi;
grovepi.Pin;
grovepi.common.Delay;
grovepi.i2c_devices.RgbLcdDisplay;
grovepi.sensors.Buzzer;
public class Lcd_subscrible implements MqttCallback {
MqttClient client;
public Lcd_subscrible() {
lcd = new RgbLcdDisplay();
}
public static void main(String[] args) {
new Lcd_subscrible().doDemo();
}
public void doDemo() {
try {
client = new MqttClient("tcp://m2m.eclipse.org:1883",
"Lcd_subscrible");
MqttConnectOptions options;
options = new MqttConnectOptions();
options.setWill("pahodemo/clienterrors", "crashed".getBytes(), 2,
true);
client.connect(options);
client.setCallback(this);
client.subscribe("asr/ismail/msg/green");
client.subscribe("asr/ismail/msg/blue");
client.subscribe("asr/ismail/msg/red");
} catch (MqttException e) {
e.printStackTrace();
}
}
public void connectionLost(Throwable cause) {
// TODO Auto-generated method stub
}
public void messageArrived(String topic, MqttMessage message) throws
Exception {
26
SmartRoom
start_buzzer();
if (topic.equals("asr/ismail/msg/green")) {
System.out.println(message);
String msg = new String(message.getPayload());
final Lcd_subscrible test = new Lcd_subscrible();
test.run(msg,"green");
}else if(topic.equals("asr/ismail/msg/red")){
System.out.println(message);
String msg = new String(message.getPayload());
final Lcd_subscrible test = new Lcd_subscrible();
test.run(msg,"red");
}else if(topic.equals("asr/ismail/msg/blue")){
System.out.println(message);
String msg = new String(message.getPayload());
final Lcd_subscrible test = new Lcd_subscrible();
test.run(msg,"blue");
}
}
public void deliveryComplete(IMqttDeliveryToken token) {
// TODO Auto-generated method stub
}
private final RgbLcdDisplay lcd;
public void run(String message, String color) {
testGreeting(message, color);
lcd.shutdown();
}
public void testGreeting(String msg, String color) {
if (color.equals("red")) {
lcd.setBacklightRgb(255, 0, 0);// back light of red
lcd.setText(msg);
Delay.milliseconds(5000);
} else if (color.equals("green")) {
lcd.setBacklightRgb(0, 255, 0);// back light of green
lcd.setText(msg);
Delay.milliseconds(5000);
} else if(color.equals("blue")){
lcd.setBacklightRgb(0, 0, 255);// back light of blue
lcd.setText(msg);
Delay.milliseconds(5000);
}
}
public void start_buzzer(){
GrovePi grovePi = new GrovePi();
Buzzer buzzer =
grovePi.getDeviceFactory().createBuzzer(Pin.DIGITAL_PIN_8);
buzzer.setState(true);
Delay.milliseconds(100);
buzzer.setState(false);
Delay.milliseconds(100);
27
SmartRoom
buzzer.setState(true);
Delay.milliseconds(100);
buzzer.setState(false);
Delay.milliseconds(100);
buzzer.setState(true);
Delay.milliseconds(100);
buzzer.setState(false);
Delay.milliseconds(100);
buzzer.setState(true);
Delay.milliseconds(50);
buzzer.setState(false);
Delay.milliseconds(50);
buzzer.setState(true);
Delay.milliseconds(50);
buzzer.setState(false);
}
}
28
SmartRoom
Annexe 3 : code java de l’interface « Message Humeur »
package com.grisaf.mqttsample;
import
import
import
import
import
import
import
import
org.eclipse.paho.client.mqttv3.IMqttDeliveryToken;
org.eclipse.paho.client.mqttv3.MqttCallback;
org.eclipse.paho.client.mqttv3.MqttClient;
org.eclipse.paho.client.mqttv3.MqttConnectOptions;
org.eclipse.paho.client.mqttv3.MqttException;
org.eclipse.paho.client.mqttv3.MqttMessage;
org.eclipse.paho.client.mqttv3.MqttPersistenceException;
org.eclipse.paho.client.mqttv3.persist.MemoryPersistence;
import
import
import
import
import
import
import
import
import
import
import
import
import
import
import
android.os.Bundle;
android.annotation.SuppressLint;
android.app.Activity;
android.app.NotificationManager;
android.app.PendingIntent;
android.app.TaskStackBuilder;
android.content.Context;
android.content.Intent;
android.support.v4.app.NotificationCompat;
android.view.Menu;
android.view.View;
android.view.View.OnClickListener;
android.widget.Button;
android.widget.EditText;
android.widget.TextView;
@SuppressLint("NewApi")
public class Message extends Activity implements MqttCallback {
private NotificationManager myNotificationManager;
private static MqttClient clientPorte;
private int a = 111;
private String topic = "";
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.message);
clientPorte = connect("asrPorte");
try {
clientPorte.subscribe("asr/ismail/porte", 0);
clientPorte.setCallback(Message.this);
// client.wait();
} catch (MqttPersistenceException e) {
e.printStackTrace();
} catch (MqttException e) {
e.printStackTrace();
}
//TextView resultText = (TextView) findViewById(R.id.resultTextView);
MQTTUtils.connect();
29
SmartRoom
Button send = (Button) findViewById(R.id.sendButton);
send.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View arg0) {
TextView resultText = (TextView)
findViewById(R.id.resultTextView);
EditText messageEditText = (EditText)
findViewById(R.id.serverText);
String payload = messageEditText.getText().toString();
if (topic.equals(""))
resultText.setText("Choose a color");
else if (payload.equals(""))
resultText.setText("Write your message");
else if (payload.length() > 32)
resultText.setText("Message too long");
else {
MQTTUtils.pub(topic, payload);
resultText.setText(String.format("%s : Envoyé", payload));
}
}
});
Button retour = (Button) findViewById(R.id.retour);
retour.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View arg0) {
startActivity(new Intent(Message.this, Main.class));
}
});
Button blue = (Button) findViewById(R.id.blue);
blue.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View arg0) {
topic = "asr/ismail/msg/blue";
TextView resultText = (TextView)
findViewById(R.id.resultTextView);
resultText.setText("Blue");
}
});
Button green = (Button) findViewById(R.id.green);
green.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View arg0) {
topic = "asr/ismail/msg/green";
30
SmartRoom
TextView resultText = (TextView)
findViewById(R.id.resultTextView);
resultText.setText("Green");
}
});
Button red = (Button) findViewById(R.id.red);
red.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View arg0) {
topic = "asr/ismail/msg/red";
TextView resultText = (TextView)
findViewById(R.id.resultTextView);
resultText.setText("Red");
}
});
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
// Inflate the menu; this adds items to the action bar if it is
present.
getMenuInflater().inflate(R.menu.main, menu);
return true;
}
protected void displayNotificationOne(String image) {
// Invoking the default notification service
NotificationCompat.Builder mBuilder = new NotificationCompat.Builder(
this);
mBuilder.setContentTitle("Someone just entered your room");
mBuilder.setContentText("Check his identity");
mBuilder.setTicker("Alert: Someone just entered");
mBuilder.setSmallIcon(R.drawable.housenoir);
// Creates an explicit intent for an Activity in your app
Intent resultIntent = new Intent(this, Porte.class);
resultIntent.putExtra("notificationId", image);
// This ensures that navigating backward from the Activity leads out
of
// the app to Home page
TaskStackBuilder stackBuilder = TaskStackBuilder.create(this);
// Adds the back stack for the Intent
stackBuilder.addParentStack(Porte.class);
// Adds the Intent that starts the Activity to the top of the stack
stackBuilder.addNextIntent(resultIntent);
PendingIntent resultPendingIntent = stackBuilder.getPendingIntent(0,
PendingIntent.FLAG_ONE_SHOT // can only be used once
);
// start the activity when the user clicks the notification text
31
SmartRoom
mBuilder.setContentIntent(resultPendingIntent);
myNotificationManager = (NotificationManager)
getSystemService(Context.NOTIFICATION_SERVICE);
// pass the Notification object to the system
myNotificationManager.notify(a, mBuilder.build());
}
@Override
public void connectionLost(Throwable arg0) {
// TODO Auto-generated method stub
}
@Override
public void deliveryComplete(IMqttDeliveryToken arg0) {
// TODO Auto-generated method stub
}
@Override
public void messageArrived(String arg0, MqttMessage arg1) throws Exception
{
// TODO Auto-generated method stub
displayNotificationOne("porte");
}
public static MqttClient connect(String nom) {
try {
MemoryPersistence persistance = new MemoryPersistence();
MqttClient client1 = new MqttClient("tcp://m2m.eclipse.org:1883",
nom, persistance);
MqttConnectOptions options = new MqttConnectOptions();
options.setWill("pahodemo/clienterrors",
"crashed".getBytes(),2,true);
client1.connect(options);
return client1;
} catch (MqttException e) {
e.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
}
32