Robots serveurs parisiens

Lors de l'option robotique de deuxième année de Télécom Saint Etienne, nous devons réaliser quatre robots. Le projet a été pensé par les professeurs d'électronique de notre école, M. Eric Verney et M. Thierry Bru, en association avec FABLABouffe. Il s'agit de robots serveurs parisiens, en effet c'est en se basant sur le comportement ingrat des serveurs parisiens que l'idée de ces quatre scénarios est née. Le premier robot est Pépé le porte-plateaux, le deuxième Le Gueulard, le troisième Chaud-Devant et enfin le dernier, Hermès. La description de chacun d'eux est donnée postérieurement.

Le workshop se tiendra sur deux semaines à la Préfabrique de l'innovation à l'ancienne manufacture de Saint Etienne, voir plan d'accès

Base robot Stinger et sa carte contrôleur

Partie commune aux robots

Documentation Technique

• Le robot fonctionne par l'intermédiaire d'une carte Teensy dont vous avez l'architecture sur le lien suivant : Carte Teensy
• PCB de la carte moteur contenant la Teensy : Fichier:PCB Project TeensyRobotL298N Orange.PDF

Déplacement du robot

• Dans un premier temps, on a installé l'environnement Teensy sous Arduino. Puis, il suffit de compiler et téléverser le programme suivant pour faire fonctionner les deux moteurs :

 - Code Teensy asservissement vitesse moteurs ( en K ) : Fichier:TeensyVSL298AsservissementVitesse.zip

A ce stade, le robot fonctionne par l'intermédiaire d'ordres donnés directement via le moniteur série.

Suiveur de ligne

Pour notre projet, nos robots doivent suivre une ligne tracée au sol. Pour effectuer cette action, on choisit d'utiliser deux capteurs "suiveurs de ligne" QRE1113 composés chacun d'un émetteur IR et d'un photo-transistor.

Capteur QRE1113 embarqué sur la base robot

Capteur QRE1113

• Vous trouverez la Datasheet du capteur QRE1113 dans le lien suivant: https://www.sparkfun.com/datasheets/Robotics/QR_QRE1113.GR.pdf

Après plusieurs tests et ajustements du code Arduino, on arrive à un résultat assez concluant que l'on vous présente dans cette vidéo :

• Code Arduino pour le suiveur de ligne : Fichier:Suiveur ligne.zip
  

Détection des obstacles

• On utilisera pour réaliser cette fonction un capteur à ultrasons SRF08 dont vous trouverez la documentation ci joint : Fichier:Capteur SRF08.docx
  
• Ce capteur est positionné au milieu à l'avant du robot :

Capteur à ultrasons

• Le capteur est branché sur le bus I2C de la carte Teensy de commande moteurs (voir pins 18 (SDA) et 19 (SCL) sur le PCB de la carte).
  
• Code pour l'arrêt du robot inclus dans le code de suiveur de ligne : Fichier:Suiveur detecteur.zip
  
• Voici la vidéo qui montre l'arrêt du robot à la détection d'un obstacle :

Scénario 1 : Pépé le porte plateau

Présentation du scénario

Ce robot a pour objectif d’apporter quelque chose à une personne qui serait alors assimilée à une source de chaleur importante. Dans ce contexte, il attendrait à son point de départ qu'on lui remette quelque chose à servir (verres, apéritifs, etc...).

Initialement positionné sur le circuit, Pépé le porte-plateau suivrait la ligne tracée devant lui tant qu'il ne détecterait pas la présence d'une personne dans son champ de vision. Une fois la personne détectée, en supposant que celle-ci reste au même endroit durant le processus, Pépé quitterait le circuit pour se diriger en ligne droite vers sa cible, s'arrêterait à une certaine distance de celle-ci et lui laisserait le temps de prendre les objets posés sur le plateau avant de faire demi-tour et de revenir à sa position initiale.
Dans l'idéal, le robot se remettrait en place sur le circuit et recommencerait les étapes décrites précédemment tant qu'il détecterait la présence d'objets sur le plateau. Si le plateau est "vide", il s'arrêterait alors et attendrait qu'on lui remette de nouveaux objets à servir.

Documentation technique

Pour faire fonctionner ce robot nous allons utiliser une seule carte Teensy qui sera responsable de la commande des moteurs, et de la gestion des différents capteurs associés au suivi de ligne, à la détection d'obstacle et à la détection de personne.

Datasheets:

• Teensy 3.1: Voir "Partie commune aux robots" > "Documentation Technique".
• QRE1113: Voir "Partie commune aux robots" > "Suiveur de ligne".
• Capteur à ultrasons SRF08: Voir "Partie commune aux robots" > "Détection d'obstacles".
• Grid-Eye: Fichier:GrideyeDatasheet1.pdf + Fichier:GrideyeDatasheet2.pdf

Etapes de réalisation

Etape 1 : Visualisation des données fournies par le GridEye

Les environnements qui ont été utilisés pour ce projet sont Arduino IDE, Teensyduino, et Processing.

Arduino & Teensyduino
Cette partie permet de retourner les données numériques du GridEye.

1. Télécharger la dernière version de Arduino IDE sur le site officiel: https://www.arduino.cc/
2. Télécharger Teensyduino: https://www.pjrc.com/teensy/td_download.html
3. Télécharger et compiler sous Arduino IDE le code suivant: Fichier:Grid-eye.zip
4. Effectuer les branchements entre la carte Teensy et le capteur GridEye selon le schéma ci-dessous:
5. Connecter le tout à votre ordinateur, vérifier que la carte est bien reconnue et sélectionner le bon port dans Arduino IDE (MenuBar>Tools).
6. Téléverser le code qui a été compilé précédemment.

Schéma du branchement

Selon les besoins, on pourra visualiser les données telles quelles grâce au moniteur série fourni par Arduino IDE ou les visualiser via le GUI développé sous Processing (voir ci-dessous)

Processing

1. Télécharger la version 2.0 de Processing sur le site officiel: https://processing.org/
2. Lier Arduino IDE à Processing en suivant les étapes décrites dans ce lien: http://playground.arduino.cc/Interfacing/Processing
3. Télécharger le code permettant de générer le GUI sous Processing: Fichier:Gui.zip
4. Charger le code. Vérifier que Processing prend en compte le bon port (en liaison série, c'est le même qu'utilise Arduino IDE).
   Veiller avant de lancer Processing à ce que le moniteur série d'Arduino IDE ne soit pas ouvert.
5. Lancer le tout et enjoy!

Charte de couleurs

Ci-dessus la charte de couleur du GUI, de gauche à droite les couleurs correspondent au froid et au chaud, la dernière colonne (blanche) étant réservée aux valeurs aberrantes (comme 500 celsius).

Cette étape nous a surtout permis de récupérer les valeurs des pixels que l'on pouvait associer à la présence d'humains. L'environnement (température ambiante, présence de radiateurs ou non) étant évolutif, il était important de réadapter les seuils de températures en début de chaque journée pour que le fonctionnement du robot, en asservissement, soit optimal.

L'étape 1 peut aussi être retrouvée en suivant ce lien Github: https://github.com/racoon-tse/GridEye-Teensy3.1.git
< Nota Bene > : pour ceux qui voudraient reprendre le code GUI, notez bien qu'un des pixels a été assignée à une valeur aberrante (500 en celsius). Ce pixel correspond à un pixel mort, spécifique au GridEye que nous avons utilisé au cours de ce projet. Il sert surtout de repère au niveau software pour faire la différence entre le début et la fin de chaque matrice de valeurs retournée par le capteur. Nous conseillons en conséquence de garder le code tel quel.

Etape 2 : Suivi de personne simple dans un environnement ouvert.

Cette étape a consisté à caractériser le "champ de vision" du robot, et à asservir celui-ci en déplacement. Pour ce faire, nous avons utilisé les codes de motorisation communs à l'ensemble des robots serveurs parisiens et nous les avons combinés avec la récupération des données fournies par le GridEye. Cette étape était cruciale car elle permettait de réguler la sensibilité du robot, et d'adapter sa vitesse de déplacement à sa capacité de détection de personne.

Nous avons défini de manière arbitraire 5 sous-matrices 8x2 (voir ci-dessous) pour décomposer le champ de vision du robot (une matrice 8x8 fournie par le GridEye). Chaque sous-matrice correspond à une direction spécifique. De manière naturelle, on comprend que si un humain apparaît dans le rectangle le plus à gauche, et s'il n'y a rien dans les autres, alors le robot devra aller à gauche. Si il y a plus d'une personne dans le champ de vision, le robot s'arrêtera momentanément, et manifestera une préférence pour la personne la plus à droite. S'il ne trouve rien, il tournera indéfiniment à droite.

Une personne est détectée lorsque le nombre de pixels qui la localisent, soit compris dans une fourchette de température "humaine", dépasse un certain seuil.

Champs de vision

Pour l'instant, le robot n'était pas en mesure de détecter les obstacles. Cependant, celui-ci parvenait parfaitement à cibler une personne dans son champ de vision et à se déplacer dans sa direction. Voir vidéo ci-dessous:

Cette étape nous a permis de faire une première version du robot porte-plateau.

Code: Fichier:Robot v1.zip

Etape 3 : Scénario complet

Voir "Pépé, le robot porte-plateau" > "Présentation du scénario". Voici un diagramme SDL permettant d'expliciter chaque étape dans l'asservissement du robot:

Le scénario étant assez complexe, nous avons voulu décomposer l'asservissement en fonctions que nous avons réalisées une par une. Aussi, nous avons écrit différentes versions d'un robot à chaque fois plus élaboré.

Afin de réaliser le suivi de ligne, nous avons tout simplement repris le même code qui était utilisé par tous les autres robots.

Etape 4 : [Bonus] Liaison Bluetooth

Puisque nous avions développé un GUI, il était intéressant d'établir une liaison bluetooth afin de voir ce que le robot "voyait" via le GridEye. Nous avons utilisé un module HC-06 pour mettre cette liaison sans fil.

Datasheet: Fichier:Hc06 datasheet.pdf

1. Effectuer les branchements entre la carte Teensy et le module selon le schéma ci-dessous:
2. Modifier le code pour établir la liaison bluetooth, en fonction des broches Tx/Rx utilisées.
3. Téléverser le code ainsi modifié.
4. Passer en mode Bluetooth sur l'ordinateur, afin que celui-ci retrouve le module. Pour une première connexion, un mot de passe sera demandé. Par défaut, c'est 1234.
5. Regarder sur quel port virtuel l'ordinateur a placé le module.
6. Éventuellement, regarder si l'ordinateur reçoit bien des données en utilisant Putty: http://www.putty.org/
7. Ouvrir Processing, charger le code du GUI et vérifier que celui-ci lit les données sur le bon port.
8. Démarrer le robot, et lancer Processing en parallèle.

Ci-dessous un test en vidéo du code Arduino Fichier:Grid-eye.zip avec le code Processing Fichier:Gui.zip pour faire fonctionner le GUI en liaison bluetooth:

Nous avons mise en oeuvre cette liaison un peu avant d'avoir fini de coder le scénario complet du robot, ce qui nous a bien servis pour débugger, car on pouvait retourner des messages en temps réel sur la console d'erreur de nos ordinateurs sans que ceux-ci soient connectés en filiaire au robot.

Robot opérationnel

Voici l'allure de notre robot final:

Entouré en rouge: carte Teensy 3.1.
Entouré en blanc: batterie servant à alimenter la carte Teensy 3.1.
Entouré en bleu: batterie servant à alimenter les moteurs.
Entouré en vert: GridEye.
Entouré en orange: capteur à ultrasons.
Entouré en rose: module Bluetooth.

Schéma final des branchements:

Scénario 2 : Le Gueulard

Présentation du scénario

Ce robot a pour objectif de stopper le bruit en « gueulant » sur les gens. Le robot se déplacera comme les autres le long du parcours tracé avec une ligne noire. Son capteur, un microphone, sera placé sur celui ci. Lorsque le signal sonore dépassera un seuil donné, le robot se stoppera alors et une phrase préenregistrée sera émise via les haut-parleurs afin de faire taire le perturbateur. Il ne reprendra alors son chemin que lorsque le bruit sera en dessous du seuil.

Il s'agira également d'un robot lunatique, mi-ange, mi-démon. Le robot sera muni d'un capteur couleur. La ligne noire sera parsemée de tâches de couleur (cf photo ci-après). Lorsque le robot détectera la couleur bleu, il énoncera une phrase préenregistrée "gentille" et lorsqu'il détectera du rouge, ce sera alors une phrase préenregistrée "méchante" qui sera émise.

Le robot sera également muni des fonctions "suivi de ligne" et "détection d'obstacles".

Documentation technique

Nous utiliserons deux cartes Arduino Teensy pour la réalisation de ce robot : une responsable de la commande moteurs, du suivi de ligne, de la détection d'obstacles par capteurs ultrasons et de la détection sonore (détection de bruit) et la deuxième responsable de l'envoi de messages audio avec une audio-cape Arduino.

• Capteur sonore SEN 12642 (capteur de base non disponible): Fichier:Résumé datasheet.docx
  
• Microphone ADMP401 (en remplacement) : Fichier:ADMP401 datasheet.pdf
  
• Capteur couleur :

Fichier:TSC3200 Resumefonctionnement.pdf
Fichier:TSC3200 Datasheet.pdf

Étapes de réalisation

Microphone

Etape 0 : Test du microphone

Cette étape permet de vérifier que le capteur fonctionne correctement. Le but du programme test est d'allumer une LED à partir d'un certain seuil.

Matériel :

• Une carte Teensy 3.1/3.2
• Un microphone ADMP401
• Une LED
• Fils

Branchements :

• Brancher VCC (3.3V) et la masse GND à la carte Teensy.
• Brancher la sortie analogique du microphone à une des pins analogiques de la carte Teensy.
• Brancher la LED à la masse et à un pin digital de la carte Teensy.

Code : Fichier:Microphone admp401.zip

Vidéo :

Etape 1 : Mise en oeuvre du microphone

Matériel :

• Une carte Teensy 3.1/3.2
• Un microphone ADMP401
• Fils femelle/femelle

Branchements :

Code : Fichier:???.zip

Le robot est alors capable de suivre la ligne, émettre une phrase lorsqu'il entend un bruit trop fort ainsi que se stopper lorsqu'un obstacle se trouve devant lui.

Vidéos :

Capteur couleur

Etape 0 : Test du capteur couleur

Cette étape permet de vérifier que le capteur fonctionne correctement. Le but du programme test est d'allumer la LED de la couleur du scotch détectée par le capteur. Nous avons deux LEDs, une rouge et une bleu.

Matériel :

• Une carte Teensy 3.1/3.2
• Un capteur couleur TCS3200
• Une LED rouge et une LED bleu
• Fils
• Scotch de couleur bleu et rouge

Mécanique :

• Il faut stabiliser le capteur à une distance constante du support sur lequel sera placé le scotch de couleur. Nous avons accroché le capteur couleur sous le robot (cf photo). Si cette étape n'est pas réalisée les valeurs ne seront pas stabilisées. Lors de l'étalonnage et lors de la mesure du test final, il y aura des valeurs trop éloignées les unes des autres ce qui impliquera un non fonctionnement du test.

Fixation du capteur couleur sous le robot

• Il faut impérativement que la taille du scotch soit supérieure à la distance séparant les photodiodes. Sinon le capteur ne pourra pas fonctionner. Nous mesurons ??????mm.

Branchements :

• carte Teensy.

Brochage pour le test du capteur avec les LED

• On choisit d'allumer la LED du capteur. La zone colorée est alors éclairée. On élimine ainsi les quelques problèmes liés à l'éclairage environnant non contrôlable qui influenceraient les données du capteur. On a donc une certaine constance dans les données couleur renvoyées par le capteur.
• Après avoir effectuer les branchements, vérifiez et téléversez le code suivant :

Code : Fichier:Test capteur couleur TCS3200.zip

• Il faut maintenant étalonner. Positionnez le capteur sur le scotch de couleur, ouvrez le moniteur série. Les quatre valeurs White, Red, Green et Blue s'affichent alors. Il y a un léger écart dû à la sensibilité du capteur entre deux mesures. C'est pourquoi il faut choisir une plage de valeurs pour chaque composante couleur : +/-5 de la valeur plus ou moins stable. Entrez ces valeurs dans le code (boucle if). Faites de même avec l'autre scotch coloré.
• Vous avez terminé.

Vous pouvez observer que lorsque la capteur se trouve au dessus du scotch de couleur, la LED de la même couleur s'allume.

Vidéo résultat:

Etape 1 : Mise en oeuvre du capteur couleur

Matériel :

• Une carte Teensy 3.1/3.2
• Un capteur couleur TCS3200
• Fils
• Scotch de couleur bleu et rouge

Mécanique :

• Comme vu dans l'étape précédente, le scotch doit être assez large pour que les photodiodes reçoivent les informations de la couleur. Nous décidons alors de réaliser un circuit de ce type :

Circuit avec scotchs de couleur

Les scotchs de couleur rouge et bleu sont à différents endroits, de largeur suffisante (photodiodes) mais pas excessive (suivi de ligne) et d'une longueur choisie de telle façon que le capteur puisse détecter la couleur sachant que le robot est en marche. Branchements :

Code : Fichier:???.zip METTRE CODE CAPTEUR COULEUR

Vidéo :

Robot opérationnel

Voici l'allure de notre robot final :

Robot Gueulard vu de dessus

Robot Gueulard vu de dessous

Scénario 3 : Chaud-Devant

Présentation du scénario

Le robot parisien "Chaud-Devant" est un robot suiveur de ligne qui va suivre un itinéraire tracé sur le sol jusqu'à ce qu'il rencontre un obstacle. Le robot va alors s'arrêter et diffuser des messages audios pour qu'on lui libère le passage. Une fois le passage libéré, "Chaud-Devant" reprend sa route.

Documentation technique

Ce robot, de la même façon que le robot Gueulard, aura besoin de deux cartes Arduino Teensy pour fonctionner : la première pour gérer la commande des moteurs, le suivi de ligne et la détection d'obstacles par capteurs ultrasons et une deuxième pour l'envoi de messages audio grâce à une audio-cape.

Partie Motrice

Le déplacement du robot se base sur le code Arduino présent au début du wiki. On utilise donc le suiveur de ligne avec la détection d'obstacles.

Partie Audio

Pour la partie audio, la solution retenue pour le moment est l'utilisation d'une teensy munie d'un shield audio pour la lecture et la diffusion du message audio. Le message audio, de type .wav, sera enregistré dans une carte SD.

Code pour lancer un message audio préalablement enregistré dans une carte SD (adapté pour le shield audio) : Fichier:Teensy audio.ino.zip

Code pour lancer différents messages audio depuis la carte SD : Fichier:WavFilePlayer.ino.zip

Etapes de réalisation

Montage global

Notre robot suiveur de ligne est composé de deux Teensy 3.2, un shield audio, 2 capteurs suiveur de ligne, 2 télémètres à ultrasons et d'un petit haut-parleur. Les datasheets des différents capteurs ainsi que les sketchs arduino sont disponibles dans la partie "Documentation technique".

• Voici le schéma pour relier les deux Teensy :

Schéma branchement 2 teensy

Faites bien attention d'avoir une masse commune.

Une Teensy va commander le robot et être connectée à tous les capteurs, c'est sur elle que l'on va uploader le programme servant à asservir les moteurs et qui traitera les différentes données communiquées par les capteurs. La deuxième Teensy sera munie du shield audio et connectée à la carte SD contenant les divers messages vocaux. La Teensy "moteur" va relayer l'information des télémètres via un port digital en émission et un port analogique en réception vers la Teensy "audio", cette information permettra de piloter la diffusion des messages audio.

Le shield audio occupe la majeure partie des pins de la Teensy, seul un port purement analogique est disponible (le port A14), ce qui explique qu'on traite le signal logique envoyé par la Teensy motrice de façon analogique. En pratique, on envoie donc des 0 et des 1 et on reçoit un signal valant approximativement 0 ou 1024. En somme, il y a donc deux fils reliant les teensy, un pour relayer l'information des capteurs et l'autre pour assurer une masse commune.

Etape 1 : Mise en place des capteurs à ultrasons

Tout d'abord, il est nécessaire de mettre en place vos capteurs à ultrasons afin que votre robot puisse détecter un objet se trouvant devant lui. Les capteurs doivent être reliés à l'aide d'une liaison I2C à la Teensy. Voir "Partie commune" pour plus de détails.

Etape 2 : Emission du message vocal

Pour cette partie, il est nécessaire d'avoir la librairie arduino "Audio", qui est normalement téléchargée lors de l'installation du logiciel Teensyduino cependant il peut arriver qu'elle ne se soit pas bien installée. Copiez aussi quelques fichiers .wav sur votre carte SD.

Une fois la Teensy connectée au shield audio, téléversez le code arduino "Teensy audio.ino" et testez la lecture d'un unique fichier .wav ainsi que la connexion à la carte SD. Si des erreurs surviennent, cela peut être dû à un problème lors du chargement des librairies Audio et SD ou dû au micro-contrôleur branché dans le mauvais sens. Votre fichier .wav doit durer plus de quelques secondes (au moins 5s) sinon il n'a pas le temps d'être traité par la Teensy. Si tout fonctionne, téléversez le sketch "WavFilePlayer.ino" qui permet de lire différents fichiers .wav (mais pas de façon simultanée). L'insertion de votre code dans des boucles if() permet de ne diffuser vos messages vocaux que si la Teensy audio reçoit un signal de la Teensy moteur.

Robot opérationnel

• Voici la vidéo qui résume ce scénario :

Scénario 4 : Hermès

Présentation du scénario

Ce dernier robot est un robot porteur de messages. Le robot, tout comme les autres, se déplacera le long du parcours avec dans celui-ci un point de départ. Les clients peuvent enregistrer un son et le charger via internet afin que le robot délivre ce message. Le robot parcourrait alors la ligne noire formant son parcours à la recherche d’une source de chaleur, donc une personne, afin de lui délivrer le message. Il repartirait alors sur la ligne et retournerait à son point de départ. On peut imaginer aussi que les clients passent leur commande via le robot et que celui-ci délivre leur message au point de départ étant les cuisines.

Documentation technique

Nous allons donc avoir besoin de trois cartes pour ce robot : Une carte Raspberry Pi1 qui va se charger de la partie communication internet (implémentation d'un serveur web) et deux cartes Arduino Teensy : Une pour la commande moteurs, le suivi de ligne, la detection d'obstacle par capteurs ultrasons et le suivi de personnes par capteur Grid-Eye et une pour l'enregistrement et l’émission de messages audio via une audio-cape Arduino.

Etapes de réalisation

Etape 1 : titre étape 1

(Façon tuto)