GEII 1A 2015-2016 MULHOUSE

Projet NAO Domus :

Sommaire :

(cliquez pour naviguer)

Membres du groupe
Présentation du sujet
Cahier des charges
Réalisation du projet
Etude financière
Aboutissement du projet
Perspectives d’amélioration
Bilan et conclusion
Manuel technique
Sources d’information / Bibliographie
Annexes
Remerciements

Membres du groupe :

HABERKORN Jonas (chef de projet)
BADIENZI Adin
BOYARD André-Julien
CERNO Quentin
FARICELLI Lucas
SCHROEDER Yann

Présentation du sujet :

Lors de nos études en GEII, il nous est demandé au deuxième semestre de réaliser un projet. Nous serons évalués sur notre réalisation, mais également sur notre organisation, notre implication et la communication dont nous avons fait preuve au cours de ce projet.

Le choix des sujets du projet se fait par vote sur l’ensemble des projets disponibles, ce qui permet d’attribuer à chaque personne un projet qui l’intéresse. De ce fait, nous sommes impliqués dans ce projet étant donné que nous avons choisis les sujets traités.

Cahier des charges :

But du projet :

Ce projet a pour but de promouvoir le DUT Génie Électrique et Informatique Industrielle de Mulhouse lors des portes ouvertes en présentant le résultat de la combinaison de plusieurs enseignements différents.

Il nous permet également d’approfondir nos connaissance dans certains domaines et de découvrir la gestion de projet.

Diagramme Bête à corne :

Ce diagramme expose les personnes ou l’institution à qui le projet rend service, sur qui ou quoi elle agit et dans quel but.

Présentation du projet :

Pour ce faire, le projet est de commander, par la voix, un robot NAO qui nous accompagne dans le bâtiment B et de pouvoir lui demander des informations sur n’importe quelle salle de ce bâtiment tels que la température, l’éclairage, etc. Ainsi qu’avoir la possibilité de lui ordonner la commande des lumières à partir d’un ordre vocal.

Une maquette sera réalisée pour mettre en évidence l’état de ces éléments dans chacune des salles, afin d’avoir un aperçu plus global et rapide de l’état du bâtiment et de l’extérieur.

L’interface entre le NAO, les capteurs et la maquette sera assurée par un serveur sur Raspberry Pi codé en python.

Contraintes :

Date limite : 30 mars 2016
Budget : 200€
Impossibilité de commuter réellement la lumière (d’où la représentation via la maquette)

Définition de termes techniques essentiels :

Robot NAO :

Le robot NAO (voir image 1) est un robot articulé programmable créé par Aldebaran. Il dispose de nombreux capteurs (voir image 2) et degrés de liberté (voir image 3). Il est composé d’un noyau Linux et est programmable soit par python, soit par chorégraphe qui est un logiciel de codage par enchainement de blocs.

Nous allons principalement utiliser son module Wi-Fi pour le connecter au réseau et chorégraphe (auquel on ajoute quelques scripts pythons) pour programmer les interaction Homme/robot NAO.

image 1

image 2

image 3

Arduino :

Un arduino est un microcontrôleur programmable possédant des entrées et des sorties (image 1), qui se programme dans un langage très ressemblant au C et qui possède un environnement de développement dédié (image 3).

Toutes les bibliothèques et connaissances sur le développement de programmes arduino est libre d’accès. De plus, Arduino jouit d’une grande popularité dans le domaine du DIY (Do It Yourself) ce qui implique des tutoriels très variés et dans différentes langues sur tout les aspect de l’utilisation des arduinos.

Nous utiliseront deux types de microcontrôleurs arduino : deux arduino UNO (image 1) et un arduino Yun (image 2), les arduino UNO sont déjà mis en place en amont de notre projet par ceux ayant réalisé un projet similaire précédemment, nous allons donc réaliser la platine accueillant les capteurs pour l’Arduino Yun et mettre l’ensemble en place.

image 1

image 2

image 3

Raspberry pi :

Une Raspberry Pi (image 1) est un nano-ordinateur monocarte qui possède son propre système d’exploitation sous linux. On peut naviguer sur internet, développer des programmes (image 2) et gérer des sorties.

Nous allons nous en servir pour y héberger un serveur afin de : communiquer avec le robot NAO, chercher et traiter les informations des capteurs sur le site internet de l’IUT et contrôler la maquette.

image 1

image 2

Serveur de l’I.U.T :

Le serveur en question est celui de l’IUT de Mulhouse. Il récupère les données des capteurs et les stock dans une base de données. Cette base de données est lue lors d’une requête à une page spécifique ( exemple : http://www.mmi.iutmulhouse.uha.fr/exportxml.php?var1=1995 ) et est mise sous forme d’une page internet.

Le traitement de ces données est très rapide et la banque de données enregistrés remonte jusqu’au 01/01/15. On pourrait également l’utiliser afin de réaliser des diagrammes, comme par exemple : celui de l’évolution de la température intérieur au fil des jours, mais notre projet se concentre autour des valeurs à l’instant présent de la demande.

Maquette :

La maquette à l’effigie du bâtiment B permettra de représenter l’état des pièces (lumières, température …) et de l’extérieur, par exemple : si la température est au-dessus d’un certain seuil, la LED associée s’allumera.

Elle sert également à visualiser l’ordre d’allumage ou d’extinction des lumières, puisque ceci aurait requis une modification de l’installation électrique déjà présent, ce que l’on ne peut effectuer.

Capteurs :

Les capteurs sont reliés à un Arduino qui envoie les données reçus au serveur de l’I.U.T.

Nous utiliserons des capteurs de température, d’humidité, de luminosité, d’ouverture de porte (ILS). Il nous faudra réaliser une platine adaptée au arduino qui permet de conditionner sous forme d’une tension la variation de résistance des capteurs.

Schéma de la structure du projet :

Le schéma suivant décrit les interactions entre les différents éléments constituant ce projet.

Nous avons en premier l’Arduino qui envoie les données des capteurs dans la base de donnée du serveur de l’IUT.

Le serveur met à disposition ces données et les envoie à la Raspberry Pi sous la forme d’une page internet lorsque celle-ci les demande.

La Raspberry Pi met à jour la maquette en fonction des valeurs des capteurs qu’elle lit sur la page internet générée par le serveur de l’IUT.

Le Robot NAO, en fonction de la demande de l’utilisateur, va envoyer : une demande d’information sur un capteur, de mise à jour de l’état d’une lumière ou de mise à jour de la maquette à la Raspberry PI, qui va lui répondre respectivement : la valeur du capteur avec un commentaire sur cette valeur, que l’état de la lumière à bien été modifié ou que la maquette à bien été mise à jour.

Diagramme pieuvre :

Ce diagramme représente les fonctions principales (FP) que notre Projet doit réaliser et les contraintes (FC) aux quelles il est soumis.

Organigramme WBS :

Organigramme GANTT :

Organisation des sous-groupes :

Serveur et maquette :
- HABERKORN Jonas
- SCHROEDER Yann

Capteurs et Arduino :
- BADIENZI Adin
- BOYARD André-Julien

Robot NAO :
- CERNO Quentin
- FARICELLI Lucas

Réalisation du projet :

L’Arduino Yun et les capteurs :

Choix de l’Arduino :

De nombreuses solutions techniques étaient possibles, il nous fallait d’abord choisir le moyen de communication que nous allions utiliser.

Pour cela nous avions le choix entre une connexion filaire (via shield Ethernet) ou sans fil (Wi-Fi).

Nous avons choisis une connexion Wi-Fi, ce qui permet une plus grande liberté dans le choix de l’emplacement des capteurs, en effet, la présence d’une prise réseau à proximité n’est plus nécessaire.

Encore une fois, nous avons du réaliser un choix concernant les éléments à utiliser pour cette connexion :

Première possibilité : un shield Wi-Fi
- Avantages : se place sur une Arduino UNO (très commune); nous possédons déjà un modèle Kicad pour une platine sur Arduino UNO.
- Inconvénients : prend beaucoup de place (Arduino UNO + shield Wi-Fi)

Seconde possibilité : une Arduino YUN Mini
- Avantages : Très petite; module Wi-Fi intégré
- Inconvénients : Ne peut pas communiquer par Ethernet, ce serait une solution de secours en cas de problème avec le Wi-Fi

Troisième possibilité et celle retenue : une Arduino YUN
- Avantages : Module Wi-fi et Ethernet intégré; Positionnement des broches identique à l’Arduino UNO.
- Aucun inconvénient majeur.

Choix des capteurs :

Le programme Arduino que nous avons récupéré a est réalisé pour :

une photorésistance LDR 6012

Un capteur de température DS18B20

Cependant, la photorésistance n’était plus présente sur le site RS-online par lequel nous devons passer commande.

Nous avons donc dû chercher une photorésistance aux caractéristique proches, nous avons choisi :

une photorésistance LDR V43N2

Pour le capteur indiquant l’état de la porte, nous avons choisis un capteur de proximité de type ILS

Réalisation de la platine :

Nous avons réalisé la platine, dans un premier temps, sur Kicad, où nous avons réalisé le schéma électrique :

Puis réalisé la platine dans ses dimensions finales, positionné les pins de l’Arduino, et pisté les différents éléments suivant le schéma électrique :

Pour la réaliser, nous avons :

imprimé la plaque routée et nous avons rendu le papier transparent, afin d’obtenir un typon.

placé le typon sur notre plaque dans une insoleuse UV sous vide

placé la plaque dans un produit révélateur
utilisé du perchlorure de fer pour réaliser la gravure, il nous reste alors plus que les pistes de cuivre qui étaient présentes sur le typon
passé la plaque dans l’étameuse

percé la plaque

Pour finir nous avons soudé les composants et les résistances, et monté le tout sur l’Arduino YUN.

Programme Arduino :

Le programme présent dans l’Arduino peut être simplifié de la sort :

La maquette :

Réalisation du plan :

La réalisation du plan s’est faite à partir du plan réel du bâtiment :

Ce plan à été traité puis imprimé aux dimensions de notre plaque qui nous sert de support :

Choix des LEDs :

Nous avons choisis :

Des LEDs rouges pour la température
Des LEDs jaunes pour la lumière
Des LEDs bleues pour l’humidité
Une LED blanche pour l’état de la porte

Les LEDs rouges et jaunes sont utilisées avec une résistance de 82Ω et les LEDs bleues et blanches avec des résistances de 1200Ω.

Les LEDs seront toutes alimentées selon ce schéma :

Avec :

+VCC : la tension des sorties de la Raspberry Pi
GND : la masse
R : la valeur de la résistance
A : le courant d’utilisation de la LED
Ur : la tension absorbée par la résistance
Uled : la tension d’utilisation de la LED

Le choix des résistance s’est réalisé avec le calcul suivant : R≥(+VCC – Uled)/A

Ce qui nous donne des résistances supérieurs à 75Ω pour les jaunes et 80Ω pour les rouges, d’où notre choix pour 82Ω.

Pour les LEDs bleues et blanches, on trouve également un résultat petit, cependant, ces LEDs éclairent de trop et sont difficiles à regarder, c’est pourquoi nous avons choisi une résistance plus importante pour notre confort visuel : 1200Ω.

Réalisation de la maquette :

Pour finaliser la maquette, nous avons percé la plaque avec le plan et introduit les LEDs.

Puis, nous avons soudé les cathodes des LEDs entre elles et les anodes à leurs résistances respectives puis à leur sortie assignée de la Raspberry Pi.

La Raspberry Pi :

Réception et traitement des données des capteurs :

Les données des capteurs sont récupérés sur le serveur de l’IUT qui nous les envoie sous la forme d’une page internet, par exemple : http://www.mmi.iutmulhouse.uha.fr/exportxml.php?var1=1992.

La Raspberry Pi fera office de serveur plus accessible pour le robot NAO et commandera la maquette; elle doit, de ce fait, récupérer les données des capteurs sur ces pages internet.

On utilise pour la Raspberry Pi le language de programmation Python dans sa version 2.7.

Dans un premier temps, il faut lire la page internet :

import sys
import urllib

page=urllib.urlopen(‘http://www.mmi.iutmulhouse.uha.fr/exportxml.php?var1=1995’)
textepage=page.read()

Voir le résultat stocké dans textepage

On a donc stocké le contenu de la page internet dans la variable textepage, maintenant on enlève tous les retours à la lignes, on sépare chaque balises html par un retour à la ligne et on remplace les ouvertures de balises « < » par des fermetures « > » et on stocke le tout dans la variable sanssigne :

sanssigne= textepage.replace(‘\n’, »)
sanssigne= sanssigne.replace(‘>’,’>\n’)
sanssigne= sanssigne.replace(‘<‘,’>’)

Voir le résultat stocké dans sanssigne

Pour finir, on sépare cette chaîne de caractère en un tableau de chaîne de caractère, on remplace les ‘.’ par des ‘,’ , on retire les « /data » et les retours à la ligne de chaque chaînes de caractère du tableau. De plus,certains capteurs de température renvoient ‘180’ au lieu de ‘18,0’; on ajoute donc cette virgule :

sanssigne= sanssigne.split(« >’)
i=0;
while i<len(sanssigne) :

sanssigne[i]=sanssigne[i].replace(‘.’,’,’)
sanssigne[i]=sanssigne[i].strip(‘/data’)
sanssigne[i]=sanssigne[i].strip(‘\n’)
i+=1

i=0
if data== »TB20″ or data== »TIB22″ or data== »TB19″:

i=10

elif data== »TEB22″ :

i=22

if i!=0 :

j=len(sanssigne[i])
j-=1
degre_entier=sanssigne[i][:j]
degre_decimal=sanssigne[i][j:]
sanssigne[i]= »%s%s » % (degre_entier,degre_decimal)

Voir le résultat final avec l’index de chaque chaîne de caractère du tableau

Communication avec le robot NAO :

La communication avec le robot NAO se fait par le réseau de l’IUT et par protocole UDP (sans contrôle d’erreur de transmission).

Sous python 2.7, il faut renseigner l’IP du destinataire et le port de destination, il faut également dédier un port de réception avec la fonction ‘.bind()’, le tout en utilisant la librairie ‘socket’ :

import socket

UDP_IP = ‘10.95.2.226’
UDP_PORT_reception = 5005
UDP_PORT_emission = 2064

sock_reception = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) # UDP
sock_emission = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) # UDP
sock_reception.bind(( »,UDP_PORT_reception))

On vient d’initialiser la communication, pour envoyer un message on utilise la fonction ‘.sendto()’ avec comme argument : le message, l’IP du destinataire et le port ciblé :

sock_emission.sendto(MESSAGE, (UDP_IP, UDP_PORT_emission))

Pour recevoir un message, on utilise la fonction ‘.recvfrom()’ qui renvoie le message et l’IP de l’expéditeur avec comme argument la taille maximale du message :

trame, addr = sock_reception.recvfrom(1024)

À noter que lorsque l’on veut recevoir un message, le programme restera bloqué sur cette fonction jusqu’à la réception d’un message, il faut donc être sûr que l’on va recevoir un message à ce moment.

Commande de la maquette :

La maquette est contrôlée par les entrées/sorties de la Raspberry Pi, chaque LED de la maquette est associée à sa propre broche définie en tant que sortie.

Pour contrôler ces broches il faut déjà savoir les quels nous allons utiliser, car certaines sont uniquement utilisable comme alimentation, d’autres comme masse et d’autres sont réservées à des utilisations particulières. Nous nous référons donc à ce schéma :

À partir le là, il ne reste plus qu’à ajouter la bibliothèque ‘GPIO’ qui permet de gérer les sorties, de préciser que l’on compte les sorties de la façon BCM (en orange sur l’image) et non en BOARD (de 1 à 40, en gris sur le schéma) à notre programme et à initialiser à l’état bas chacune des sorties utilisées :

import RPi.GPIO as GPIO

GPIO.setmode(GPIO.BCM)

GPIO.setup(16,GPIO.OUT,initial=GPIO.LOW) #Température B20
GPIO.setup(26,GPIO.OUT,initial=GPIO.LOW) #Humidité B20
GPIO.setup(20,GPIO.OUT,initial=GPIO.LOW) #Luminosité B20
GPIO.setup(6,GPIO.OUT,initial=GPIO.LOW) #Température B22
GPIO.setup(12,GPIO.OUT,initial=GPIO.LOW) #Humidité B22
GPIO.setup(13,GPIO.OUT,initial=GPIO.LOW) #Luminosité B22
GPIO.setup(17,GPIO.OUT,initial=GPIO.LOW) #Température exterieur
GPIO.setup(18,GPIO.OUT,initial=GPIO.LOW) #Humidité exterieur
GPIO.setup(27,GPIO.OUT,initial=GPIO.LOW) #Luminosité exterieur
GPIO.setup(14,GPIO.OUT,initial=GPIO.LOW) #Température B19
GPIO.setup(15,GPIO.OUT,initial=GPIO.LOW) #Luminosité B19
GPIO.setup(4,GPIO.OUT,initial=GPIO.LOW) #Porte B19

Pour modifier l’état d’une sortie, on utilise normalement la fonction GPIO.output(), mais des problèmes ont étés rencontrés avec cette fonction, nous allons donc utiliser une astuce qui fonctionne mais qui n’est pas ‘correcte’ d’un point de vue ‘puriste’. On va re-déclarer la broche souhaitée comme étant une sortie, mais on va changer son état initial. Par exemple, si l’humidité dépasse les 50%, alors la LED s’allume, sinon elle est éteinte :

if donnee>=50:

GPIO.setup(26,GPIO.OUT,initial=GPIO.HIGH)

else:

GPIO.setup(26,GPIO.OUT,initial=GPIO.LOW)

Il faudra faire attention dans le programme final à traiter les données pour qu’elles soient prises en compte comme des nombre, avec comme séparateur décimal le point et non la virgule comme c’est le cas dans le tableau sanssigne. La condition ressemblera alors à cela :

if float(donnee.replace(« , », ». »))>=50:

Programme complet :

Le programme complet de la Raspberry Pi peut se résumer avec cet organigramme :

Le robot NAO :

Gestion des mouvements :

Les mouvements du robot sont programmés sur le logiciel chorégraphe. Une fenêtre « Robot view » nous permet de connaître la position actuelle du robot dans l’espace :

Nous pouvons faire bouger le robot à partir de cette fenêtre pour lui indiquer une pose à atteindre et l’inclure dans le programme :

Mais nous avons choisis d’éditer plus précisément les mouvements du robot NAO grâce à une interface où l’on peut, pour chaque articulation, donner un angle précis de la position à atteindre :

L’enchaînement des différentes positions donne un mouvement qui donne plus de vie au robot. Les positions peuvent être appelées dans une timeline (sorte de frise chronologique) où l’on enchaine les positions dans le temps en réglant l’écart de temps entre chaque position et la vitesse à la quelle elle doivent être atteinte. On gère ainsi la vitesse du mouvement.

Gestion des dialogues :

Les dialogues entre l’utilisateur et le robot NAO sont gérés par une ‘boite’ spécial. Celle-ci est reliée à un fichier texte où l’on programme d’abord les phrases reconnues par le robot NAO entre parenthèse et entre crochets les différentes variantes de mots, puis la réponse du robot et enfin, on peut faire changer une sortie de la boite en indiquant le nom de la sortie après un dollars ($) et en précisant son état.

Voir le programme.

C’est cette boîte qui va déterminer la suite du programme. Elle peut ainsi entamer la séquence de demande d’information ou de modification d’état des capteurs à la raspberry Pi, ou modifier la position du robot, voir même arrêter le programme.

Communication avec la Raspberry Pi :

La communication avec la raspberry pi se fait par le réseau de l’IUT et par protocole UDP (sans contrôle d’erreur de transmission), le fonctionnement est exactement le même que celui utilisé dans le programme de la raspberry Pi, de ce fait, toutes les explications seront les mêmes mais avec les adresses IP et ports émetteurs et récepteurs inversés.

import socket

UDP_IP = ‘10.95.2.250’
UDP_PORT_reception = 2064
UDP_PORT_emission = 5005

sock_reception = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) # UDP
sock_emission = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) # UDP
sock_reception.bind(( »,UDP_PORT_reception))

On vient d’initialiser la communication, pour envoyer un message on utilise la fonction ‘.sendto()’ avec comme argument : le message, l’IP du destinataire et le port ciblé :

sock_emission.sendto(MESSAGE, (UDP_IP, UDP_PORT_emission))

Pour recevoir un message, on utilise la fonction ‘.recvfrom()’ qui renvoie le message et l’IP de l’expéditeur avec comme argument,la taille maximale du message :

trame, addr = sock_reception.recvfrom(1024)

Etude financière :

Voici l’utilisation détaillée de notre budget de 200€ pour la réalisation de ce projet :

Aboutissement du projet :

Notre projet est arrivé à son terme et nos objectifs sont atteins :

Le robot NAO dialogue avec l’utilisateur et peut demander des informations à la raspberry Pi et modifier l’état des lumières
La raspberry Pi communique avec le robot NAO, commande la maquette et récupère les données des capteurs sur le serveur de l’IUT
L’Arduino YUN récupère et traite les données des capteurs.

La seule étape restante ne peut être réalisée par notre groupe car il s’agit de la mise sur le réseau de l’Arduino YUN et d’autoriser l’écriture dans la base de donnée de l’IUT, ce que nous ne pouvons pas faire nous-même. La fin de ce projet n’est pas de notre ressort, de plus que nous ne saurions résoudre les problèmes rencontrés pour l’écriture le l’Arduino sur le serveur.

Voici quelques vidéos présentant les différentes applications de notre projet :

Perspectives d’amélioration :

Nous pouvons envisager d’ :

équiper plus de salles de capteurs et ajouter d’autres types de capteurs (par exemple : la consommation d’électricité, la qualité de l’aire…)
ajouter un afficheur à la maquette (par exemple : PC1602ARSD) qui afficherait les valeurs des capteurs
ajouter un système de reconnaissance de salle au NAO pour lui demander l’état de la salle dans la quelle nous somme sans avoir à en connaître le nom
afficher une maquette numérique sur une page internet avec un accès simplifié aux valeurs des capteurs et la possibilité d’y changer l’état des lumière

Bilan et conclusion :

Dans l’ensemble, notre projet s’est très bien déroulé. Nous n’avons pas eu de gros problèmes, nous avons fini dans les temps, et nous avons progressé dans certains domaines, principalement la programmation.

Excepté un cas, tout le groupe était présent et impliqué dans le projet.

En conclusion, la réalisation de ce projet était très intéressante et nous a permis de découvrir le fonctionnement de la gestion d’un projet avec toutes ses contraintes. Nous nous sommes prouvé que nous pouvons arriver à un résultat même si, au départ, nous ne connaissions rien de l’outil que nous allions manipuler. Il s’agit pour nous d’une très bonne expérience.

Manuel technique :

Voici les différentes étapes à réaliser dans l’ordre afin d’utiliser notre projet et/ou le modifier.

Il faut cependant avoir pris connaissance de l’ensemble du site avant d’utiliser ou modifier le projet, car des choix ont étés réalisés pour certaines raisons, et il est préférable de manipuler quelque chose dont on a compris le fonctionnement.

Mettre en place les capteurs :
- Monter la platine avec les capteurs sur l’Arduino YUN
- Brancher l’Arduino YUN au réseau
- Téléverser le programme dans l’Arduino lorsque celle-ci est reliée à l’ordinateur grâce au logiciel d’Arduino téléchargeable ici
- L’Arduino est prête à envoyer des informations sur le serveur si le programme fonctionne, il ne reste qu’à la placer à l’endroit souhaité, à la relier au réseau de l’IUT et à l’alimenter une fois placée.

1) Environnement de dévellopement, c’est ici que l’on édite le code

2) Sélectionnez le type de carte Arduino à programmer (ici Arduino YUN)

3) Sélectionnez le port de l’ordinateur sur le quel est branché l’Arduino

4) Bouton pour téléverser le programme

5) Console indiquant les dernières action réalisées et les erreurs rencontrés lors de la compilation

6) Etat expliqué clairement

7) Indicateur toujours présent du port sur le quel on téléverse

Mettre en place la Raspberry PI et la maquette :
- Connecter un clavier, une souris, un écran, un câble Ethernet et la maquette à la Raspberry PI.
- Alimenter la Raspberry PI et se connecter avec l’identifiant « pi » et le mot de passe « raspberry »
- On peut modifier le programme en ouvrant le fichier avec « IDLE » et non « IDLE 3 » car le robot NAO utilise python 2.7
- Pour lancer le programme il faut le lancer en administrateur car celui-ci modifie l’état des sorties de la Raspberry PI, on ouvre donc une console, on se rend à l’emplacement du programme avec la commande ‘cd Desktop’ si le programme est sur le bureau, puis on le lance avec ‘sudo python2.7 prog_final_modif.py’ où ‘prog_final.py’ est le nom de notre fichier.

1) Ouvrir le fichier avec IDLE

2) Cette fenêtre s’ouvre et permet d’éditer son code

3) Cette fenêtre s’ouvre aussi et sert de console python

4) Terminal avec les commandes pour lancer le programme en administrateur

Mettre en place le robot NAO :
- Allumer le Robot NAO et le connecter au réseau
- Lancer le projet du logiciel Chorégraphe et se lier au Robot NAO
- Compiler et téléverser le programme

1) Espace de programmation

2) Connection au Robot NAO

3) Téléverser et lancer le programme dans le robot NAO

4) Arrêter le programme dans le robot NAO

5) Modifier le volume des Haut-parleurs du robot NAO

6) Activer/Désactiver le mode de vie autonome

7) Indicateur du niveau de la batterie du robot NAO

8) Vue d’ensemble du projet

9) Document à modifier pour modifier le dialogue Homme/Robot NAO

10) Bibliothèque des blocs de programmation

11) Bibliothèque des positions de base du robot NAO

12) Onglet pour aperçu de la caméra du robot NAO

13) Vue de la position actuelle du robot NAO

Il faut cependant vérifier que les ports définis dans le programme du robot NAO et de la Raspberry PI soient les mêmes.

Sources d’information / Bibliographie :

https://www.arduino.cc/en/Main/ArduinoBoardYu (pour des informations sur l’Arduino YUN)

http://doc.aldebaran.com/2-1/software/choregraphe/objects/dialog_box.htm (pour le fonctionnement du dialogue avec le robot NAO)

https://wiki.python.org/moin/UdpCommunicatio (pour la communication UDP entre la raspberry Pi et le robot NAO)

https://zestedesavoir.com/tutoriels/686/arduino-premiers-pas-en-informatique-embarquee/ (Tutoriel Arduino UNO)

http://evola.fr/fr/position/488-Detecteur-ouverture-porte.html (Détecteur de porte)

http://mchobby.be/wiki/index.php?title=Arduino_Yun-Guide#Linino (Tutoriel Arduino YUN)

http://pdf.datasheetcatalog.com/datasheet/perkinelmer/VT500.pdf (Datasheet photorésistance)

http://forums.futura-sciences.com/electronique/546158-photoresistance-lien-entre-lux-resistance.html (Formule photorésistance)

http://www.dsimb.inserm.fr/~fuchs/python/cours_python.pdf (Apprendre le Python 2.7)

https://blogs.msdn.microsoft.com/jdupuy/2015/01/22/zone61-guide-pour-configurer-votre-carte-arduino-yn/ (Paramétrage Arduino YUN)

Beaucoup d’informations ont étés récupérés dans le rapport de projet de nos prédécesseurs, dans le livre « Adventures in raspberry pi » , des explications de nos enseignants et de nos cours.

Annexes :

Programme du dialogue Homme <–>Robot NAO :

topic: ~dialogue1()

language: frf

u:(quelle est l’humiditÈéexterieur) veuillez patienter $sortie= »HEB22″

u:(quelle est la température exterieur)veuillez patienter $sortie= »TEB22″

u:(quelle est la luminosité exterieur) veuillez patienter $sortie= »LEB22″

u:(quelle est la température en salle [« 1 » « une »])veuillez patienter $sortie= »TB20″

u:(quelle est la luminosité en salle [« 1 » « une »]) veuillez patienter $sortie= »LB20″

u:(quelle est l’humidité en salle [« 1 » « une »]) veuillez patienter $sortie= »HB20″

u:(donne moi la température en salle 2)veuillez patienter $sortie= »TIB22″

u:(donne moi la luminositÈ en salle 2) veuillez patienter $sortie= »LIB22″

u:(donne moi l’humiditÈ en salle 2) veuillez patienter $sortie= »HIB22″

u:(La porte est elle ouverte en salle 3) veuillez patienter $sortie= »PB18″

u:(quelle est la température en salle B dix huit)veuillez patienter $sortie= »TIB18″

u:(quelle est la luminosité en salle B dix huit) veuillez patienter $sortie= »LIB18″

u: ([« bonjour » « Salut »]nao) bonjour a tous! $hello=1

u: ([« lève-toi » « debout »]) Ok je me lève $debout=1

u: ([« assis-toi » « assis »]) D’accord je m’assois $assis=1

u:(tu peux te reposer) d’accord, au revoir $fin=1

u:(maquette) Un instant s’il-vous-plait $sortie= »MAJ »

u:(Allume la lumière en salle 1) J’allume la lumière en salle 1 $sortie= »ALB20″

u:(Eteinds la lumière en salle 1) J’eteinds la lumière en salle 1 $sortie= »ELB20″

u:(Allume la lumière en salle 2) J’allume la lumière en salle 2 $sortie= »ALB22″

u:(Eteinds la lumière en salle 2) J’eteinds la lumière en salle 2 $sortie= »ELB22″

u:(Allume la lumière en salle 3) J’allume la lumière en salle 3 $sortie= »ALB18″

u:(Eteinds la lumière en salle 3) J’eteinds la lumière en salle 3 $sortie= »ELB18″

Programme de la communication Robot NAO –> Raspberry PI :

class MyClass(GeneratedClass):

def __init__(self):

GeneratedClass.__init__(self)

def onLoad(self):

#put initialization code here
pass

def onUnload(self):

#put clean-up code here
pass

def onInput_onStart(self, message):

#self.onStopped() #activate the output of the box

import socket
import sys

UDP_IP = ‘10.95.2.250’
UDP_PORT_reception = 2064
UDP_PORT_emission = 5005
#MESSAGE = message
data= » »

sock_reception = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) # UDP
sock_emission = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) # UDP
sock_reception.bind((« »,UDP_PORT_reception))

sock_emission.sendto(message, (UDP_IP, UDP_PORT_emission))

if message!= »ALB20″ or message!= »ELB20″ or message!= »ALB22″ or message!= »ELB22″ or message!= »ALB19″ or message!= »ELB19″:

data, addr = sock_reception.recvfrom(1024)

#sock_reception.close()
self.salut(data)
pass

def onInput_onStop(self):

self.onUnload() #it is recommended to reuse the clean-up as the box is stopped
self.onStopped() #activate the output of the box

def onInput_input(self, p):

pass

Programme de la communication Raspberry PI –> Robot NAO :

# -*- coding: utf-8 -*-

#pour lancer le programme sur raspberry :
#ouvrir le LXTerminal
#acceder au dossier du bureau par la commande : cd Desktop
#lancer le programme avec la commande : sudo python2.7 NOMPROGRAMME
#pour arreter le programme : Ctrl+C

#PROGRAMME FINAL
#ajout des librairies
import RPi.GPIO as GPIO
import socket
import sys
import urllib
import time

#initialisation de la connexion avec le robot NAO
UDP_IP = ‘10.95.2.225’
UDP_PORT_reception = 5005
UDP_PORT_emission = 2064

sock_reception = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) # UDP
sock_emission = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) # UDP
sock_reception.bind((« »,UDP_PORT_reception))

#initialisation des sorties pilottant les LEDs de la maquette
GPIO.setmode(GPIO.BCM)

GPIO.setup(16,GPIO.OUT,initial=GPIO.HIGH) #Température B20
GPIO.setup(26,GPIO.OUT,initial=GPIO.HIGH) #Humidité B20
GPIO.setup(20,GPIO.OUT,initial=GPIO.HIGH) #Luminosité B20
GPIO.setup(6,GPIO.OUT,initial=GPIO.HIGH) #Température B22
GPIO.setup(12,GPIO.OUT,initial=GPIO.HIGH) #Humidité B22
GPIO.setup(13,GPIO.OUT,initial=GPIO.HIGH) #Luminosité B22
GPIO.setup(17,GPIO.OUT,initial=GPIO.HIGH) #Température exterieur
GPIO.setup(18,GPIO.OUT,initial=GPIO.HIGH) #Humidité exterieur
GPIO.setup(27,GPIO.OUT,initial=GPIO.HIGH) #Luminosité exterieur
GPIO.setup(14,GPIO.OUT,initial=GPIO.HIGH) #Température Bxx
GPIO.setup(15,GPIO.OUT,initial=GPIO.HIGH) #Luminosité Bxx
GPIO.setup(4,GPIO.OUT,initial=GPIO.HIGH) #Porte Bxx

def lecture_des_donnees_NAO(data):

#choix de la page internet à ouvrir en fonction de la valeur demandée
#et lecture de la page
if data== »TB20″ or data== »LB20″ or data== »HB20″:

page=urllib.urlopen(‘http://www.mmi.iutmulhouse.uha.fr/exportxml.php?var1=1995’)
textepage=page.read()

if data== »TIB22″ or data== »LIB22″ or data== »HIB22″ or data== »HEB22″ or data== »TEB22″ or data== »LEB22″:

page=urllib.urlopen(‘http://www.mmi.iutmulhouse.uha.fr/exportxml.php?var1=1992’)
textepage=page.read()

if data== »TB18″ or data== »LB18″ or data== »PB18″:

page=urllib.urlopen(‘http://www.mmi.iutmulhouse.uha.fr/exportxml.php?var1=3000’)
textepage=page.read()

#stoquer le texte de la page travaillé pour obtenir le résultat
#sous forme d’un tableau par ligne de code
sanssigne= textepage.replace(« \n », » »)
sanssigne= sanssigne.replace(« > », »>\n »)
sanssigne= sanssigne.replace(« <« , »> »)
sanssigne= sanssigne.split(« > »)

#on efface tout ce qui reste dans les cases contenant des valeurs
#afin d’obtenir la valeur sans éléments HTML
i=0;
while i<len(sanssigne) :

sanssigne[i]=sanssigne[i].replace(« . », », »)
sanssigne[i]=sanssigne[i].strip(« /data »)
sanssigne[i]=sanssigne[i].strip(« \n »)
i+=1

#on traite le cas des capteurs de température où il faut ajouter une virgule
i=0
if data== »TB20″ or data== »TIB22″ or data== »TB19″:

i=10

elif data== »TEB22″ :

i=22

if i!=0 :

j=len(sanssigne[i])
j-=1
degre_entier=sanssigne[i][:j]
degre_decimal=sanssigne[i][j:]
sanssigne[i]= »%s%s » % (degre_entier,degre_decimal)

#création des phrases réponse en fonction de la demande :

condition_finale= » »
texte_final= » »
virgule= » »

if data== »TB20″ :

debut_phrase= »En B20 il fait »
donnee= »%s%s%s » % (degre_entier,virgule,degre_decimal)
fin_phrase= » degrés celcius se »
if float(donnee.replace(« , », ». »))>=17:

condition_finale= ». Il ne fait pas trop froid. »
GPIO.setup(16,GPIO.OUT,initial=GPIO.HIGH)

else:

condition_finale= ». Il fait plutôt frais. »
GPIO.setup(16,GPIO.OUT,initial=GPIO.LOW)

if data== »TB18″ :

debut_phrase= »En B18 il fait »
donnee= »%s%s%s » % (degre_entier,virgule,degre_decimal)
fin_phrase= » degrés celcius se »
if float(donnee.replace(« , », ». »))>=17:

condition_finale= ». Il ne fait pas trop froid. »
GPIO.setup(14,GPIO.OUT,initial=GPIO.HIGH)

else:

condition_finale= ». Il fait plutot frais. »
GPIO.setup(14,GPIO.OUT,initial=GPIO.LOW)

if data== »TIB22″ :

debut_phrase= »En B22 il fait »
donnee= »%s%s%s » % (degre_entier,virgule,degre_decimal)
fin_phrase= » degrés celcius se »
if float(donnee.replace(« , », ». »))>=17:

condition_finale= ». Il ne fait pas trop froid. »
GPIO.setup(6,GPIO.OUT,initial=GPIO.HIGH)

else:

condition_finale= ». Il fait plutot frais. »
GPIO.setup(6,GPIO.OUT,initial=GPIO.LOW)

if data== »TEB22″ :

debut_phrase= »A l’exterieur, il fait »
donnee= »%s%s%s » % (degre_entier,virgule,degre_decimal)
fin_phrase= » degrés celcius se »
if float(donnee.replace(« , », ». »))>=17:

condition_finale= ». Il ne fait pas trop froid »
GPIO.setup(17,GPIO.OUT,initial=GPIO.HIGH)

else:

condition_finale= ». Il fait froid »
GPIO.setup(17,GPIO.OUT,initial=GPIO.LOW)

if data== »HB20″ :

debut_phrase= »En B20 l’humidité est de »
donnee=sanssigne[6]
fin_phrase= » pourcent »
if float(donnee.replace(« , », ». »))>=50:

condition_finale= ». C’est beaucoup »
GPIO.setup(26,GPIO.OUT,initial=GPIO.HIGH)

else:

condition_finale= ». C’est bien »
GPIO.setup(26,GPIO.OUT,initial=GPIO.LOW)

if data== »LB20″ :

debut_phrase= »En B20 la luminosté est de »
donnee=sanssigne[14]
fin_phrase= » lux, la lumière est certainement »
if float(donnee.replace(« , », ». »))>=400:

condition_finale= »allumée »
GPIO.setup(20,GPIO.OUT,initial=GPIO.HIGH)

else:

condition_finale= »éteinte »
GPIO.setup(20,GPIO.OUT,initial=GPIO.LOW)

if data== »LB18″ :

debut_phrase= »En B18 la luminosté est de »
donnee=sanssigne[14]
fin_phrase= » lux, la lumière est certainement »
if float(donnee.replace(« , », ». »))>=400:

condition_finale= »allumée »
GPIO.setup(15,GPIO.OUT,initial=GPIO.HIGH)

else:

condition_finale= »éteinte »
GPIO.setup(15,GPIO.OUT,initial=GPIO.LOW)

if data== »HIB22″ :

debut_phrase= »En B22 l’humidité est de »
donnee=sanssigne[6]
fin_phrase= » pourcent »
if float(donnee.replace(« , », ». »))>=50:

condition_finale= ». C’est beaucoup »
GPIO.setup(12,GPIO.OUT,initial=GPIO.HIGH)

else:

condition_finale= ». C’est bien »
GPIO.setup(12,GPIO.OUT,initial=GPIO.LOW)

if data== »HEB22″ :

debut_phrase= »A l’exterieur, l’humidité est de »
donnee=sanssigne[18]
fin_phrase= » pourcent »
if float(donnee.replace(« , », ». »))>=70:

condition_finale= ». C’est beaucoup »
GPIO.setup(18,GPIO.OUT,initial=GPIO.HIGH)

else:

condition_finale= ». C’est bien »
GPIO.setup(18,GPIO.OUT,initial=GPIO.LOW)

if data== »LIB22″ :

debut_phrase= »En B22 la luminosté est de »
donnee=sanssigne[14]
fin_phrase= » lux, la lumière est certainement »
if float(donnee.replace(« , », ». »))>=400:
condition_finale= »allumée »
GPIO.setup(13,GPIO.OUT,initial=GPIO.HIGH)
else:
condition_finale= »éteinte »
GPIO.setup(13,GPIO.OUT,initial=GPIO.LOW)

if data== »LEB22″ :

debut_phrase= »A l’exterieur, la luminosté est de »
donnee=sanssigne[30]
fin_phrase= » lux, Il fait certainement «

if float(donnee.replace(« , », ». »))>=400:

condition_finale= »jour »
GPIO.setup(27,GPIO.OUT,initial=GPIO.HIGH)

else:

condition_finale= »nuit »
GPIO.setup(27,GPIO.OUT,initial=GPIO.LOW)

if data== »PB18″:

debut_phrase= »En B18 la porte est »
donnee=sanssigne[30]
if donnee== »1″:

fin_phrase= »ouverte. »
GPIO.setup(4,GPIO.OUT,initial=GPIO.HIGH)

else:

fin_message= »fermée. »
GPIO.setup(4,GPIO.OUT,initial=GPIO.LOW)

#envoie du message
MESSAGE= »%s%s%s%s%s » % (debut_phrase,donnee,fin_phrase,condition_finale,texte_final)
sock_emission.sendto(MESSAGE, (UDP_IP, UDP_PORT_emission))

def mise_a_jour_maquette():

x=0
while x<2 :

if x==0:

page=urllib.urlopen(‘http://www.mmi.iutmulhouse.uha.fr/exportxml.php?var1=1995’)
textepage=page.read()

if x==1:

page=urllib.urlopen(‘http://www.mmi.iutmulhouse.uha.fr/exportxml.php?var1=1992’)
textepage=page.read()

if x==2:

page=urllib.urlopen(‘http://www.mmi.iutmulhouse.uha.fr/exportxml.php?var1=3000’)
textepage=page.read()

sanssigne= textepage.replace(« \n », » »)
sanssigne= sanssigne.replace(« > », »>\n »)
sanssigne= sanssigne.replace(« <« , »> »)
sanssigne= sanssigne.split(« > »)

i=0;
while i<len(sanssigne) :

sanssigne[i]=sanssigne[i].replace(« . », », »)
sanssigne[i]=sanssigne[i].strip(« /data »)
sanssigne[i]=sanssigne[i].strip(« \n »)
i+=1

i=0

if x==0 or x==1 or x==2:

i=10
j=len(sanssigne[i])
j-=1
degre_entier=sanssigne[i][:j]
degre_decimal=sanssigne[i][j:]
sanssigne[i]= »%s%s » % (degre_entier,degre_decimal)

if x==1:

i=22
j=len(sanssigne[i])
j-=1
degre_entier=sanssigne[i][:j]
degre_decimal=sanssigne[i][j:]
sanssigne[i]= »%s%s » % (degre_entier,degre_decimal)

condition_finale= » »
texte_final= » »
virgule= » »

if x==0 :

debut_phrase= »En B20 il fait »
donnee= »%s%s%s » % (degre_entier,virgule,degre_decimal)
fin_phrase= » degrés celcius se »
if float(donnee.replace(« , », ». »))>=17:

condition_finale= ». Il ne fait pas trop froid »
GPIO.setup(16,GPIO.OUT,initial=GPIO.HIGH)

else:

condition_finale= ». Il fait froid »
GPIO.setup(16,GPIO.OUT,initial=GPIO.LOW)

if x==1 :

debut_phrase= »En B22 il fait »
donnee= »%s%s%s » % (degre_entier,virgule,degre_decimal)
fin_phrase= » degrés celcius se »
if float(donnee.replace(« , », ». »))>=10:

condition_finale= ». Il ne fait pas trop froid »
GPIO.setup(6,GPIO.OUT,initial=GPIO.HIGH)

else:

condition_finale= ». Il fait froid »
GPIO.setup(6,GPIO.OUT,initial=GPIO.LOW)

if x==1 :

debut_phrase= »A l’exterieur, il fait »
donnee= »%s%s%s » % (degre_entier,virgule,degre_decimal)
fin_phrase= » degrés celcius se »
if float(donnee.replace(« , », ». »))>=17:

condition_finale= ». Il ne fait pas trop froid »
#print condition_finale
GPIO.setup(17,GPIO.OUT,initial=GPIO.HIGH)

else:

condition_finale= ». Il fait froid »
GPIO.setup(17,GPIO.OUT,initial=GPIO.LOW)

if x==0 :

debut_phrase= »En B20 l’humidité est de »
donnee=sanssigne[6]
fin_phrase= » pourcent »
if float(donnee.replace(« , », ». »))>=50:

condition_finale= ». C’est beaucoup »
GPIO.setup(26,GPIO.OUT,initial=GPIO.HIGH)

else:

condition_finale= ». C’est bien »
GPIO.setup(26,GPIO.OUT,initial=GPIO.LOW)

if x==0 :

debut_phrase= »En B20 la luminosté est de »
donnee=sanssigne[14]
fin_phrase= » lux, la lumière est certainement »
if float(donnee.replace(« , », ». »))>=400:

condition_finale= »allumée »
GPIO.setup(20,GPIO.OUT,initial=GPIO.HIGH)

else:

condition_finale= »éteinte »
GPIO.setup(20,GPIO.OUT,initial=GPIO.LOW)

if x==1 :

debut_phrase= »En B22 l’humidité est de »
donnee=sanssigne[6]
fin_phrase= » pourcent »
if float(donnee.replace(« , », ». »))>=50:

condition_finale= ». C’est beaucoup »
GPIO.setup(12,GPIO.OUT,initial=GPIO.HIGH)

else:

condition_finale= ». C’est bien »
GPIO.setup(12,GPIO.OUT,initial=GPIO.LOW)

if x==1 :

debut_phrase= »A l’exterieur, l’humidité est de »
donnee=sanssigne[18]
fin_phrase= » pourcent »
if float(donnee.replace(« , », ». »))>=70:

condition_finale= ». C’est beaucoup »
GPIO.setup(18,GPIO.OUT,initial=GPIO.HIGH)

else:

condition_finale= ». C’est bien »
GPIO.setup(18,GPIO.OUT,initial=GPIO.LOW)

if x==1 :

debut_phrase= »En B22 la luminosté est de »
donnee=sanssigne[14]
fin_phrase= » lux, la lumière est certainement »
if float(donnee.replace(« , », ». »))>=400:

condition_finale= »allumée »
GPIO.setup(13,GPIO.OUT,initial=GPIO.HIGH)

else:

condition_finale= »éteinte »
GPIO.setup(13,GPIO.OUT,initial=GPIO.LOW)

if x==1 :

debut_phrase= »A l’exterieur, la luminosté est de »
donnee=sanssigne[30]
fin_phrase= » lux, Il fait certainement »
if float(donnee.replace(« , », ». »))>=400:

condition_finale= »jour »
GPIO.setup(27,GPIO.OUT,initial=GPIO.HIGH)

else:

condition_finale= »nuit »
GPIO.setup(27,GPIO.OUT,initial=GPIO.LOW)

if x==2 :

debut_phrase= »En B18 il fait »
donnee= »%s%s%s » % (degre_entier,virgule,degre_decimal)
fin_phrase= » degrés celcius se »
if float(donnee.replace(« , », ». »))>=17:

condition_finale= ». Il ne fait pas trop froid. »
GPIO.setup(14,GPIO.OUT,initial=GPIO.HIGH)

else:

condition_finale= ». Il fait plutot frais. »
GPIO.setup(14,GPIO.OUT,initial=GPIO.LOW)

if x==2 :

debut_phrase= »En B18 la luminosté est de »
donnee=sanssigne[14]
fin_phrase= » lux, la lumière est certainement «

if float(donnee.replace(« , », ». »))>=400:

condition_finale= »allumée »
GPIO.setup(15,GPIO.OUT,initial=GPIO.HIGH)

else:

condition_finale= »éteinte »
GPIO.setup(15,GPIO.OUT,initial=GPIO.LOW)

if x==2:

debut_phrase= »En B18 la porte est »
donnee=sanssigne[30]
if donnee== »1″:

fin_phrase= »ouverte. »
GPIO.setup(4,GPIO.OUT,initial=GPIO.HIGH)

else:

fin_message= »fermée. »
GPIO.setup(4,GPIO.OUT,initial=GPIO.LOW)

x+=1

sock_emission.sendto(« La maquette a été mise à jour! », (UDP_IP, UDP_PORT_emission))

def modifier_etat(data):

if data== »ALB20″:

GPIO.setup(20,GPIO.OUT,initial=GPIO.HIGH)
MESSAGE= »La lumière, en B20, à été allumée. »

if data== »ELB20″:

GPIO.setup(20,GPIO.OUT,initial=GPIO.LOW)
MESSAGE= »La lumière, en B20, à été éteinte. »

if data== »ALB22″:

GPIO.setup(13,GPIO.OUT,initial=GPIO.HIGH)
MESSAGE= »La lumière, en B22, à été allumée. »

if data== »ELB22″:

GPIO.setup(13,GPIO.OUT,initial=GPIO.LOW)
MESSAGE= »La lumière, en B22, à été éteinte. »

if data== »ALB18″:

GPIO.setup(15,GPIO.OUT,initial=GPIO.HIGH)
MESSAGE= »La lumière, en B18, à été allumée. »

if data== »ELB18″:

GPIO.setup(15,GPIO.OUT,initial=GPIO.LOW)
MESSAGE= »La lumière, en B18, à été éteinte. »

sock_emission.sendto(MESSAGE, (UDP_IP, UDP_PORT_emission))

while True :

trame, addr = sock_reception.recvfrom(1024)
if trame== »MAJ »:

mise_a_jour_maquette()

elif trame== »ALB20″ or trame== »ELB20″ or trame== »ALB22″ or trame== »ELB22″ or trame== »ALB18″ or trame== »ELB18″:

modifier_etat(trame)

else:

lecture_des_donnees_NAO(trame)

Programme de l’Arduino Yun :

/*Declaration pour la communication ethernet*/
#define NOP__asm__ __volatile__(« nop\n\t » ::)
unsigned long time;
#include <SPI.h>
#include <Ethernet.h>
String Requete;
byte mac[] = {0xB4, 0x21, 0x8A, 0xF0, 0xA0, 0x40};
char server[] = « www.mmi.iutmulhouse.uha.fr »;
IPAddress ip(10, 95, 2, 53);
byte Mask[] = {255, 255, 0, 0};
byte DNS[] = {10, 9, 0, 10};
byte Gate[] = {10, 95, 0, 1};
EthernetClient client;
unsigned int previousMillis = 0;
unsigned int interval = 600000; //Interval
unsigned int lastConnectionTime = 0; //Dernière connexion au serveur en millisecondes
boolean lastConnected = false; //Etat de la connexion a la derniere boucle
const unsigned int postingInterval = 6000; //Délai avant update en millisecondes
char c = 0;

/*Declaration du capteur LDR interieur*/
int photocellPin = 0; //Sur la broche Analog 0
int photocellReading, lumint, lumdec;
float resistance, luminosite;

/*Declaration du capteur d’ouverture de porte*/
int doorPin = 1; //Sur la broche Analog 1
float doorReading;
int doorState;

/*Declaration pour le DS18B20-Temperature*/
#include <OneWire.h>
int pinDS18S20 = 2;
OneWire ds(pinDS18S20);
float temperature;
int tempintDS, tempdecDS;

/*Declaration de variables inutilisees*/
int humint, humdec, humExtint, humExtdec, tempExtint, tempExtdec, pressint, pressdec, lumintExt, lumdecExt, UVint, UVdec, QAint, QAdec;

/*——————-*/
/* – SETUP – */
/*——————-*/

void setup()
{

Serial.begin(9600);
Ethernet.begin(mac, ip, DNS, Gate, Mask);

}

/*——————–*/
/* – LOOP – */
/*——————–*/

void loop()
{

if (client.available())
{

c = client.read();
Serial.print(c);

}

if (!client.connected() && lastConnected)
{

Serial.println();
Serial.println(« Deconnexion »);
client.stop();

}

if (!client.connected() && (millis() – lastConnectionTime > postingInterval))
{

unsigned long currentMillis = millis();

if (currentMillis – previousMillis > interval)
{

previousMillis = currentMillis;
resetEthernetShield();

}

/*Calcul de la temperature interieure-DS18B20*/
temperature = getTemperature();
tempintDS = (int)temperature;
tempdecDS = (temperature – (int)temperature) * 100;

/*Determination de l’etat de la porte*/
doorReading = analogRead(doorPin);
if (doorReading > 500) //Renvoi 1 si la porte est OUVERTE
{

doorState = 1;

}
else
{

doorState = 0;

}

/*Calcul de la luminosite interieure-LDR*/
luminosite = lumiere();
lumint = luminosite;
lumdec = (luminosite – (int)luminosite) * 100;

/*Connexion au serveur web-Requete SQL*/
if (client.connect(server, 80))
{

Serial.println(« Connexion… »);

Requete = String(« GET/insert.php?var=1 »); //var1:etat porte (1 si fermee)
Requete += boolean(doorState);
Requete += String(« & »);

Requete += String(« var2= »); //var2:temperature interieure
Requete += int(tempintDS * 1);
Requete += char(0x2e);
Requete += int(tempdecDS * 1);
Requete += String(« & »);

Requete += String(« var3= »); //var3:luminosite interieure
Requete += int(lumint * 1);
Requete += char(0x2e);
Requete += int(lumdec * 1);

Requete += String(« &var4=104&var5=105&var6=106&var7=3000 »);
Requete += String(« & »);

Requete += String(« var8= »); //var8
Requete += int(humExtint * 1);
Requete += char(0x2e);
Requete += int(humExtdec * 1);
Requete += String(« & »);

Requete += String(« var9= »); //var9
Requete += int(tempExtint * 1);
Requete += char(0x2e);
Requete += int(tempExtdec * 1);
Requete += String(« & »);

Requete += String(« var8= »); //var10
Requete += int(pressint * 1);
Requete += char(0x2e);
Requete += int(pressdec * 1);
Requete += String(« & »);

Requete += String(« var11= »); //var11
Requete += int(lumintExt * 1);
Requete += char(0x2e);
Requete += int(lumdecExt * 1);
Requete += String(« & »);

Requete += String(« var12= »); //var12
Requete += int(UVint * 1);
Requete += char(0x2e);
Requete += int(UVdec * 1);
Requete += String(« & »);

Requete += String(« var13= »); //var13
Requete += int(QAint * 1);
Requete += char(0x2e);
Requete += int(QAdec * 1);
Requete += String(« & »);

Requete += String(« HTTP/1.1 »);

client.println(Requete);
client.println(« Host:www.mmi.iutmulhouse.uha.fr »);
client.println(« Connection:close »);
client.println();

/*Temps de la derniere connexion*/
lastConnectionTime = millis();
AffichageData(); //Appel de la fonction pour afficher les donnees sur la console

}

else
{

client.stop();

}

lastConnected = client.connected();

/*Precision sur le delai d’envoi entre chaque emission*/
time = micros();
while (micros() <= time + 1000)
{

__asm__(« nop\n\t »);

}

/*———————*/
/* – FONCTIONS – */
/*———————*/

/*Fonction pour la reinitialisation de la connexion Ethernet (en cas de bug)*/
void resetEthernetShield()
{

Serial.println(« Reinitialisation Ethernet »);
Ethernet.begin(mac, ip, DNS, Gate, Mask);

}

/*Fonction pour calculer la luminosite interieure*/
float lumiere()
{

photocellReading = analogRead(photocellPin);
delay(2500);
resistance = (1024.0 * 10000 / photocellReading) – 10000; //Calcul de la resistance
luminosite = (pow(resistance / 300000, -1 / 0.90)); //Calcul de la luminosite

}

/*Fonction pour calculer la temperature interieure*/
float getTemperature() //Retourne la temperature au DS18S20 en degres celsius : Temp = ((HighByte << 8) + (LowByte) * 0.0625
{

byte data[12]; //Les donnees comprennent 12 bits
byte addr[8]; //L’adresse d’un registre comprend 8 bits
if (!ds.search(addr))
{

ds.reset_search();
return false;

}
if (OneWire::crc8(addr, 7) != addr[7]) //On verifie si le CRC est bien equivalent au CRC souhaite
{

Serial.println(« CRC non valide »);
return false;

}
#define DS18S20_ID 0x10
#define DS18B20_ID 0x28
if (addr[0] != 0x10 && addr[0] != 0x28) //On verifie que l’ID du capteur correspond, ici le capteur est un DS18B20 donc l’adresse est 0x28
{

Serial.print(« Pas de dispositif »);
return false;

}
ds.reset();
ds.select(addr);

ds.write(0x44, 1); //Pour obtenir la mesure de la temperature, nous devons d’abord la convertir
byte present = ds.reset();
ds.select(addr);

ds.write(0xBE); //Pour lire Scratchpad et acceder aux 9 octets de donnees
for (int i = 0; i < 9; i++)
{

data[i] = ds.read();

}
ds.reset_search();
byte LSB = data[0];
byte MSB = data[1];
float tempRead = ((MSB << 8) | LSB) * 0.0625;
return tempRead;

}

/*Fonction d’affichage des donnees*/
void AffichageData()
{

Serial.println(« Interieur : »);
Serial.println(« Temp : « ); Serial.print(tempintDS); Serial.print(« , »); Serial.print(tempdecDS); Serial.println(« C »);
Serial.println(« Lum : »); Serial.print(lumint); Serial.print(« , »); Serial.print(lumdec); Serial.println( » lux »);
Serial.println(« Porte : »); Serial.print(doorState); Serial.println( » ferme si 1″);
Serial.println();

}

Valeurs de « textpage » :

Valeurs de « sanssigne » sous forme de chaîne de caractère :

Valeurs de « sanssigne » sous forme de tableau avec index :

Remerciements :

Un grand merci à M. Cudel Christophe et Mme Kohler Sophie, nos enseignants chercheurs tuteurs pour ce projet, de nous avoir aidé et accompagné jusqu’au bout.

Merci au département GEII de l’IUT de Mulhouse pour le prêt du matériel nécessaire tel que le robot NAO, la Raspberry Pi et pour l’achat des capteurs et de l’Arduino YUN.

Merci au département MMI de l’IUT de Mulhouse pour l’accès aux données du serveur de l’IUT et au Service Informatique pour l’accès au réseau interne à l’IUT.

Merci à M. Wira pour nous avoir aidé à chercher une solution pour permettre à l’Arduino d’écrire sur le serveur.