Projet IMA3 P3, 2015/2016, TD2

Projet IMA3-SC 2015/2016 : Cartographie

Cahier des charges

Dans le cadre de notre projet Systèmes Communicants, nous avons décidé de nous orienter vers un système permettant de cartographier une salle à l'aide d'un capteur de distance tournant sur lui-même par un servomoteur. Pour cela, nous avons pensé à utiliser un sonar ultra-sons pour la détection des "murs" de la salle. De cette façon, nous pourrions récupérer les positions de chaque obstacle et ainsi les tracer.

Matériel nécessaire

Par conséquent, afin de pouvoir mener à bien notre projet, nous aurions besoin du matériel suivant :

• Une nanoboard
• Une Raspberry Pi
• Un sonar ultra-sons
• Un servomoteur

Séance 1

Pour débuter, nous avons d'abord réalisé un schéma représentant les différentes parties du projet, ce qui nous permettra de mieux nous répartir les tâches et comprendre ce qu'on attend de nous lors de ce projet.

Schéma global du travail à réaliser

Simulation du fonctionnement

Vidéo simulant le fonctionnement de notre montage : ici

Le résultat escompté de cette simulation :

Partie électronique

• Concernant la partie électronique, nous avons commencé la séance par créer un prototype Arduino pour pouvoir tester le bon fonctionnement du sonar ultra-sons et du servomoteur, et de voir comment s'utiliser ces 2 composants. Nous avons donc réussi à faire tourner le servomoteur en continu pour un angle de 0 à 180° tout en récupérant la distance de l'obstacle le plus proche avec le sonar.

(mettre photo programme Arduino)

Test des différents composants

• Nous avons ensuite été travailler sur Altium pour pouvoir commencer la conception de notre circuit électronique qui est pour le moment remplacé pour un prototype Arduino. Comme nous ne savions pas par où commencer ce travail, nous avons décidé de nous initier avec le tutoriel décrit dans les ressources mises à disposition pour ce projet. Cela nous a permis de nous familiariser avec les composants logiques disponibles sur Altium et de voir les différentes étapes pour intégrer un schéma sur la FPGA.

Initiation aux composants logiques sur Altium

Partie informatique

• Cette première séance a été dédiée à installer une partie des outils nécessaires pour la partie informatique. Nous avons donc commencé par nous connecter via une liaison série au raspberry pi afin de modifier la configuration réseau nous permettant ainsi de nous connecter au raspberry pi en SSH (secure shell). Nous avons ensuite installé les outils tels que Apache2 un serveur web et libwebsocket une librairie C pour la manipulation des sockets. Quelques problèmes sont survenus notamment au niveau des mises a jour des dépôts raspian mais ont été rapidement corrigés.

• Le reste de la séance à dédié à la mise en place du prototype Arduino (cf image ci-dessus) ainsi qu'a sa programmation. Notre programme Arduino est donc le suivant après avoir subit quelques modifications au cours des séances :

Utilisation de la librairie servo.h pour le contrôle su servo-moteur

#include <Servo.h>

Définitions des pins

#define trigger 9
#define echo 7
#define servo 11

Définitions des variables globales utilisées

long lecture_echo; //durée entre l'émission et la réception d'un signal pour le capteur de distance
long cm; //distance en centimètre 
bool sens=1; //sens de rotation du servo-moteur utilisé pour un balayage gauche-droite
bool active=false; //variable état du système permettant sont activation et sa désactivation
Servo servo1; //definition su servo-moteur
int pos = 1; //variable indiquant la position du servi de 0 à 180 degrés

Initialisation setup()

pinMode(trigger,OUTPUT); //définition du pin trigger en sortie
pinMode(echo,INPUT);     //définition du pin echo en entrée
digitalWrite(trigger, LOW); // mettre le pin trigger à 0
servo1.attach(servo);    //init servo

Serial.begin(9600);      //initialisation de la liaison série à 96600 bauds

Boucle principale loop() :

Partie réception liaison série

if(Serial.available() > 0) //si le buffer n'est pas vide
   {
     char buffer =Serial.read(); //lecture
         if (buffer=='1')        //on active le système si on reçoit '1'
           active =true;
           else if (buffer='0')  //on désactive le système si on reçoit '0' 
             active = false;
    }

Partie émission, lecture du sonar et contrôle du servo-moteur

if (active)                       //Si le système est actif
  {
         
     if(pos==0) sens =true;       //Si on atteint une "butée" (0 ou 180) du servo on change de sens de rotation
    else if(pos==180) sens=false;

    if (sens) pos++;              //Incrémentaion ou décrémentation de la position en fonction du sens de rotation
    else pos--;

     servo1.write(pos);           //on indique la position au servo-moteur 
   
  
     digitalWrite(trigger, HIGH); //Emission d'une onde ultrason sur le sonar
     delayMicroseconds(10);       //Délai minimum entre émission et lecture (cf datasheet du capteur)
     digitalWrite(trigger, LOW);  //Fin d'émission
     lecture_echo = pulseIn(echo, HIGH,100000); //Utilisation d'une interruption afin de récupérer la durée entre l’émission et la réception avec une durée max pour éviter de rendre la fonction bloquante 
     cm = lecture_echo/58;        //Conversion en centimètre 
      Serial.write(cm);           //émission de la distance via la liason série
       
      Serial.write(pos);          //émission de la position du servo via la liason série
      Serial.print('\n');
     
  }

delay(100); //temporisation

• L'envoi et la réception de données se fait relativement simplement sur Arduino avec les fonctions write et read, avec seule contrainte de tester pour cette dernière si il y a vraiment des données à lire.
• L'asservissement du servo-moteur en position se fait également assez simplement grâce à la librairie servo.h
• L'utilisation du capteur ultrason requiert quand même de comprendre son fonctionnement afin de pouvoir l'utiliser. En effet, celui-ci ne renvoie pas simplement une distance mais il nous permet, grâce à un émetteur connecté à une broche trigger, d’émettre une impulsion (minimum 10 micro secondes) puis de recevoir le signal sonore répercuté par un obstacle via un micro grâce à la broche echo. On a ainsi la durée de parcours du signal sonore jusqu’à l'obstacle

qu'on divise par deux (car le signal effectue un allé-retour) et qu'on ramène à une distance connaissant la vitesse du son (approximativement 340 m/s car cela dépend de la température et de la pression de l'air).

Séance 2

Partie électronique

• Après s'être entraînés avec le tutoriel sur Altium, dès le début de la seconde séance nous nous sommes attaqués à la conception du circuit électronique que nous devons réaliser pour remplacer le fonctionnement du programme Arduino. Nous avons donc à assurer la commande du servomoteur ainsi que du sonar parallèlement. Nous nous sommes premièrement intéressé au servomoteur, qui fonctionne avec un signal PWM, généré par la FPGA. Nous avons alors fait des recherches sur le modèle du servomoteur utilisé pour obtenir ses caractéristiques et nous avons trouvé la datasheet suivante :

Datasheet du servomoteur HS-422

• En lisant ce document, nous avons pu remarquer que la rotation du servomoteur s'effectuait en indiquant une certaine période au signal PWM (400 microsecs pour un angle de 45°). Du coup, nous avons réalisé un circuit permettant seulement d'émettre un signal PWM en faisant varier la fréquence de ce signal afin de retrouver la période indiquée. En utilisant l'analyseur logique branché sur une des broches externes de la FPGA, nous avons relevé une fréquence d'environ 50 kHz pour une période proche de 400 microsecs. A la fin nous n'avons pas eu le temps de tester et d'envoyer ce signal sur le servomoteur pour vérifier nos observations. Après avoir discuté avec un professeur, nous nous sommes rendus compte que nous n'avions pas encore réfléchi à l'alimentation du servomoteur, et que celle-ci poserait problème si on l'alimentait seulement avec la FPGA. En effet, le courant délivré par la NanoBoard ne dépasse pas les 10 mA, alors que selon la datasheet, le servomoteur a besoin d'un courant de 150 mA pour fonctionner convenablement. A la prochaine nous devrons donc réfléchir à un éventuel montage à transistors afin de booster le courant délivré par la FPGA.

Schéma Altium pour l'émission d'un signal PWM

Partie informatique

• Cette deuxième séance nous a permis de mettre en place le serveur websocket ainsi que la liaison série entre la Raspberry et l'Arduino. Nous avons donc commencé par récupérer les fichiers d'exemples ainsi que librairie sur la liaison série, afin d'effectuer quelques tests, ainsi que le code source du serveur websocket. Après ces quelques tests, nous avons donc pu intégrer les fonctions d'ouverture, d'écriture et de lecture de la liaison série au serveur websocket.

Notre protocole est simple :

Pour rappel, notre objectif final sera de tracer les contours d'un environnement tel qu'une pièce meublée par exemple. Pour cela, nous devons à chaque angle associer une distance et ainsi, avec l'aide de quelques fonctions trigonométriques simples, dessiner le point correspondant.

Ainsi, dans un sens nous allons demander à utilisateur d'envoyer 0 ou 1 correspondant respectivement à l'activation ou la désactivation du système. L'information passe du navigateur internet au serveur websocket qui le transmet via la liaison série de la Raspberry à l'Arduino ou la nanoboard qui traite ensuite cette information.

Dans l'autre sens, l'Arduino ou la nanoboard envoie les données de position et de distance au serveur websocket grâce à la liaison série et le serveur envoie les données au navigateur qui les trace ensuite à l'écran.

Nous avons commencé par apporter une modification a la librairie serial.c fournie afin de rendre la fonction "read" non bloquante. En effet, afin de ne pas bloquer le serveur en attendant une donnée cette modification était nécessaire.

On ajoute donc le flag O_NONBLOCK à la fonction d'ouverture de la liaison série :

int fd=open(device,flags|O_NOCTTY|O_NONBLOCK);

Voici les modifications apportées au code du serveur websocket afin de prendre en charge la liaison série ainsi que l'envoi et la réception des données :

On commence par la définition des librairies utilisées

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <libwebsockets.h>
#include <strings.h>
#include <unistd.h>
#include <termios.h>

#include "serial.h"

On définit ensuite le port série de la raspberry à utiliser

#define SERIAL_DEVICE           "/dev/ttyUSB0"

On définie en global la variable d'ouverture de la liaison série ainsi que les variables de position et de distance

int sd;
unsigned char sonar,position;

Ouverture du port série dans le main

printf("connexion port serie en %s ...    ",SERIAL_DEVICE); 
sd=serialOpen(SERIAL_DEVICE,SERIAL_BOTH);	
serialConfig(sd,B9600); //vitesse de communication à 9600 Bauds
sleep(2); //attente pour la connexion serie (necessaire apres tests)
printf("Done !\n");

Fermeture de la liaison série lorsqu'on ferme le serveur

serialClose(sd);

Envoie d'une donnée reçu par le navigateur via la liaison série

case LWS_CALLBACK_RECEIVE:
               // Ici sont traites les messages envoyes par le navigateur
   printf("received data: %s\n",(char *)in);
   if(write(sd,(unsigned char *)in,sizeof(char))!=1){perror("main.write"); exit(-1); } //écriture sur le port série
   break;

Envoie d'une donnée reçu via la liaison série au navigateur

case LWS_CALLBACK_SERVER_WRITEABLE:
               // Ici sont envoyes les messages au navigateur
   if(read(sd,&sonar,sizeof(char))==1){                            //Si on reçoit une distance on reçoit ensuite la position
     char *out=message + LWS_SEND_BUFFER_PRE_PADDING;
     read(sd,&position,sizeof(char));
     sprintf(out,"%03d %03d",sonar,position);                      //formatage des données pour avoir la position et la distance sur 3 chiffres
     libwebsocket_write(wsi,(unsigned char *)out,TAILLE_MESSAGE,LWS_WRITE_TEXT); //envoi au navigateur
     }
   libwebsocket_callback_on_writable(this,wsi);
   break;

La compilation s'effectue en exécutant la commande

gcc -lwebsockets serial.c serveur.c -o serveur 

Séance 3

Partie électronique

• Lors de cette dernière séance, nous avons finalisé les tests que nous voulions faire sur le fonctionnement du servomoteur. Nous avons donc finalement réaliser un montage suiveur composé d'un AOP plutôt que du montage à transistors que l'on avait prévu de faire. Nous avions mal compris la datasheet puisqu'en fait lorsqu'on parlait de 150 mA à délivrer, c'était en réalité le courant consommé par le servomoteur lorsqu'il tournait à plein régime. Nous avions en réalité seulement besoin de lui fournir une tension continue de 4,8V (ou 6V selon le modèle de moteur). D'où le montage suiveur avec l'AOP, qui permet quand même de protéger le servomoteur et d'éviter les perturbations du signal PWM.

Datasheet de l'amplificateur opérationnel TL082

• Le montage consiste donc à faire passer le signal PWM de la Nanoboard par un AOP avant d'être connecté au moteur. Nous avons utilisé deux générateurs de tension pour alimenter l'AOP en +Vcc et -Vcc, puis une troisième pour simuler l'alimentation de la Nanoboard et s'assurer du bon fonctionnement du moteur avant de l'alimenter directement avec la Nanoboard, puisque nous n'étions pas sûr du bon fonctionnement de la broche d'alimentation de la FPGA. Pour faire ceci, on réutilisera le même schematic Altium que précédemment pour l'émission d'un signal PWM où l'on fait varier le rapport cyclique de ce signal. On utilisera cependant une fréquence de 20 kHz plutôt que 50 kHz pour le signal. Après avoir regardé de nouveau le signal sur un oscilloscope, nous avons pensé que cette fréquence serait plus adaptée à nos besoins.

Le montage réalisé est le suivant :

Réalisation des tests pour le moteur

Avec ce montage nous avons alors réussi à faire tourner le servomoteur pas à pas en augmentant le rapport cyclique progressivement. Puisque l'on passe par Altium pour le modifier, ce rapport cyclique est écrit sur 8 bits. Cela nous a permis, en allant jusqu'aux angles limites du servomoteur, de connaître la valeur min et max du rapport cyclique en 8 bits pour aller de 0° à 180°(rotation maximale que peut effectuer le moteur). Nous avons donc fini notre travail sur le test du moteur.

Après avoir compris son fonctionnement, nous en sommes revenus au but de notre projet, c'est-à-dire faire tourner un sonar sur le servomoteur pivotera continuellement pour réaliser une cartographie de l'espace. Nous devons donc trouver un moyen via Altium pour que le servomoteur puisse réaliser cette tâche. Puisque le servomoteur tourne en faisant varier le servomoteur, nous avons alors pensé à faire un compteur puis décompteur une fois que l'angle maximum est atteint, pour que le moteur puisse tourner en continu. Voici le shematic Altium construit pour essayer de répondre à ce besoin:

Schéma Altium pour le fonctionnement du servo-moteur

Nous avons aussi par la suite fait un autre schematic, celui-ci pour le fonctionnement du sonar, qui n'a besoin que de récupérer la distance entre chaque obstacle le plus souvent possible. Voici un fichier qui pourrait être utilisé :

Schéma Altium pour le sonar

Pour le moment, nous n'avons pas encore pu tester si nos schémas Altium fonctionnaient correctement. Nous essayerons de le faire prochainement.

Partie informatique

Cette dernière séance à été dédiée à la mise en place de la page HTML permettant l'activation et la désactivation du système ainsi que le cartographie de la pièce. La page HTML est hébergée sur la Raspberry grâce au serveur web Apache2.

L'interface finale est constituée d'un titre "Cartographie Sonar" qui s'affiche en vert ou en rouge en fonction de si le navigateur a pu se connecter au serveur websocket ou non, deux boutons "activer" ou déactiver" et un canvas de 300 sur 300 pixels pour effectuer le tracé.

Pour rendre la page HTML accessible à n'importe quelle machine connectée sur le même réseau que la raspberry, il faut mettre l'intégralité des codes HTML et Javascript dans le dossier /var/www/ (ou /var/www/html/ selon les versions d'Apache2) de la rapberry pour qu'elles soient hébergées par Apache. Le premier fichier "chargé" par Apache et qui représente la racine de la hiérarchie des fichiers HTML se nomme "index.html". N'ayant qu'un seul fichier HTML nous avons mis l'intégralité du code dans ce fichier.

Avant toute chose il a fallu télécharger et installer la librairie jquery.js qui permet de lancer des requêtes HTTP asynchrones mais aussi de faciliter la programmation JavaScript.

Voici comment est constitué notre code index.html (les scripts javascript ont directement été incorporé dedans) :

ATTENTION : l'essentiel de ce code n'est pas exécutable car il été modifié pour que les balises du code HTML n’interfèrent pas avec celles utilisées par le wiki. Le code complet et intact sera joint au wiki et se trouve également sur la Raspberry Pi

Connexion au serveur websocket à l'ip 172.26.79.10 au port 9000

window.WebSocket=(window.WebSocket||window.MozWebSocket);
var websocket=new WebSocket('ws://172.26.79.10:9000','myprotocol');

Changement de couleur du titre en cas d’échec de connexion

websocket.onopen=function(){ $('h1').css('color','green'); };
websocket.onerror=function(){ $('h1').css('color','red'); };

Définition et initialisation à 0 du tableau contenant toute les distances pour chaque angle (taille 180)

var distances=[];
for (var i=0;i<180;i++) distances[i]=0;

Déclaration et fonction d'initialisation du canvas et de son contexte

var canvas;
var context;

function create_canvas(){
    canvas=document.getElementById("canvas");
    context=canvas.getContext('2d');
}

Traitement des données reçues grâce à l'event websocket.onmessage

websocket.onmessage=function(message){
    distances[parseInt(message.data.substring(4,7))]=parseInt(message.data.substring(0,3));
    draw(distances);
    $('messages').append(('<p',{ text: message.data }));
};

• Cette fonction permet de stocker une distance à chaque angle grâce au tableau distances tel que distances[angle]=distance avec angle allant de 0 à 180.
• Le message reçu, contenu dans message.data, est une chaîne de caractères au format "%03d %03d" c'est à dire qu'on à la distance sur trois chiffres suivit d'un espace suivit par la position également sur trois chiffres. On doit donc découper la chaîne pour récupérer indépendamment la distance et la position grâce à la méthode "substring".
• Néanmoins ces deux données sont toujours du type chaîné de caractères, on les convertit donc en entier grâce à la méthode "parseInt".
• On redessine tout le tableau dès qu'on reçoit une nouvelle donnée.

Fonction d'envoi de message

function sendMessage(signal){
   websocket.send(signal);
   (signal).val();
}

Fonction de dessin de la cartographie

function draw(distances)
{	
   //effacage du canvas avant de redessiner
   context.clearRect(0, 0,300,300);

   //tracé de tout les points
   context.strokeStyle = "black";
   for(var i=0;i < 180;i++)
   {
     context.fillRect(distances[i]*Math.cos((i*Math.PI)/180)+150,distances[i]*Math.sin((i*Math.PI)/180)+150,3,3);
   }	
}

• Cette fonction permet de dessiner l'intégralité du tableau distances qui est mis a jour dès qu'on reçoit un message
• Pour dessiner on fait appel à la méthode fillRect(origineX,origineY,tailleX,tailleY) qui trace un rectangle de 3 sur 3 pixels
• On détermine les coordonnées x et y à partir de l'angle et de la distance grâce aux fonctions cosinus et sinus et que $x=dist * cos(angle)$ et $y=dist * sin(angle)$. Il faut donc convertir l'angle i qui est en degrés en radians. On ajoute de plus 150 à chacune de ces coordonnées pour les centrer sur le canvas.

Script HTML sans les balises car sinon reconnu par le wiki comme du script

 body  onload="create_canvas();"                               //init du canvas au chargement (event "onload")
  h1>Cartographie sonar</h1                                    //Titre en rouge ou en vert
   button onclick="sendMessage(1);">Activer</button            //bouton "activer" qui envoie 1 au serveur websocket
   button onclick="sendMessage(0);">Desactiver</button         //bouton "désactiver" qui envoie 0 au serveur websocket
   canvas id="canvas" width="300" height="300" ></canvas       //création du canvas
 /body>

Le tracé une fois effectué ressemble à cela :

Démonstration

Voici une démonstration de notre système prototypé avec une Arduino

Nous utilisons ici une Arduino nano ainsi qu'un servo-moteur avec une amplitude maximale plus faible que celle utilisé d'habitude :

Voici l'intégralité de nos codes sources :

Fichier:Sonar.ino.txt Fichier:Serial.c Fichier:Serial.h Fichier:Serveur.c Fichier:Index.html