Robot de compétition 4 : Différence entre versions

De Wiki de bureau d'études PeiP
(3) Mise en place de la phase de jeu)
(Le terrain de jeu)
 
(121 révisions intermédiaires par 3 utilisateurs non affichées)
Ligne 1 : Ligne 1 :
== '''Introduction''' ==
+
<include nopre noesc src="/home/pedago/ppeip/include/video-RobotCompetition4-2014-iframe.html" />
 +
__TOC__
 +
<br style="clear: both;">
 +
= '''Introduction''' =
  
 
Dans le cadre du bureau d'étude spécialité IMA, nous avons la charge de concevoir un match sportif mettant en œuvre des robots de la gamme lego mindstorms.
 
Dans le cadre du bureau d'étude spécialité IMA, nous avons la charge de concevoir un match sportif mettant en œuvre des robots de la gamme lego mindstorms.
Pour cela nous nous sommes répartit les tâches entre la conception des robots joueurs, des robot ramasseurs, des buts et de l'arbitre. Notre binôme a choisit de réaliser l'un des robots joueur, c'est à dire un robot capable de repérer puis de saisir une balle avant de l'envoyer dans les buts adverses.
+
Pour cela nous nous sommes répartis les tâches entre la conception des robots joueurs, des robot ramasseurs, des buts et de l'arbitre. Notre binôme a choisi de réaliser l'un des 4 robots joueurs, c'est-à-dire un robot capable de repérer puis de saisir une balle avant de l'envoyer dans les buts adverses.
  
 +
= Objectifs à atteindre =
  
== '''1) La conception du robot''' ==
+
D'après le cahier des charges du BE IMA, nous devions réaliser notre robot en tenant compte de certaines contraintes :
  
La conception mécanique du robot passe tout d'abord par la confection d'un châssis stable et solide, puis par le placement des différents capteurs et enfin par la mis en place d'un bras mécanique. Pour cela nous disposions d'une boite lego mindstorm avec des roues, des servomoteurs et différents types de capteurs : couleur, infrarouge, ultrasons.
+
*Les robots ont comme tâche principale de s'approcher de la balle et de la lancer vers le but adverse.  
Nous avons changer plusieurs fois le concept du robot, qu'il s'agisse du déplacement, du bras mécanique, ou du placement des capteurs pour des questions de pratique.
 
  
== 1.1) L'aspect mécanique ==
+
*Les robots ne peuvent avancer que s'ils ne détectent pas d'obstacle à faible distance.
  
La première chose à faire a été de confectionner le châssis, nous avions besoin d'une base stable pour placer le boitier Mindstorm et qui faciliterai le déplacement. Nous sommes tout d'abord parti sur l'idée d'un déplacement grâce aux chenilles, pour ensuite le changer et placer 4 roues ; en effet les différents câbles avec tendance à gêner le déplacement du robot lorsque les chenilles étaient mise en place.
+
*Un robot de jeu ne peut pas sortir du terrain.  
  
[[Fichier:20150122_165211.jpg|200px|thumb|left|Premier prototype : robot à chenille]] [[Fichier:20150122_173112.jpg|200px|thumb|center|Changement chenille pour 4 roues (vue de profile)]]
+
*Les buts faisant clignoter leurs LEDs infrarouges suivant un code pré-établi, les robots doivent pouvoir différencier les buts de la balle.
 +
 
 +
*Les communications entre les acteurs doivent s'effectuer par bluetooth.
 +
Les robots et les buts s'apparient avec l'arbitre et ne communiquent qu'avec lui.
 +
 
 +
= '''La conception du robot''' =
 +
 
 +
La conception mécanique du robot passe tout d'abord par la confection d'un châssis stable et solide, puis par le placement des différents capteurs, et enfin par la mise en place d'un bras mécanique. Pour cela nous disposions d'une boite lego mindstorm avec toutes sortes de pièces, des roues, des servomoteurs et différents types de capteurs : couleur, infrarouge, ultrasons etc.
 +
Nous avons changé plusieurs fois, pour des questions de pratique, le concept du robot ; qu'il s'agisse de l'aspect général, du bras mécanique, ou du placement des capteurs .
 +
 
 +
= Kit Lego Robot Mindstorms NXT =
 +
 
 +
 
 +
[[Fichier:boitier.jpg|400px|thumb|right|Brique, servo moteurs & capteurs]]
 +
 
 +
Pour construire notre robot, nous disposions d'un kit Lego Mindstorm.
 +
Ce kit comprend :
 +
La brique intelligente Lego Mindstorms NXT basée sur un processeur 32 bits
 +
3 servos moteurs
 +
2 capteurs de contact
 +
1 capteur de distance à ultrasons (sonar)
 +
1 capteur de lumière et de couleur
 +
1 capteur infrarouge
 +
577 pièces Lego technic
 +
1 câble USB
 +
1 plan de travail sous forme de poster
 +
 
 +
 
 +
La brique Lego Mindstorms NXT est le véritable cerveau de notre robot NXT Lego. Elle se connecte au PC via un câble USB ou le Bluetooth.
 +
 +
Il est même possible de configurer un téléphone portable ou un joystick afin de piloter votre robot.
 +
 
 +
 
 +
=  L'aspect mécanique =
 +
 
 +
La première chose à faire a été de confectionner le châssis. Nous avions besoin d'une base stable pour placer le boitier Mindstorm et pour faciliter le déplacement. Nous sommes tout d'abord partis sur l'idée d'un déplacement grâce aux chenilles, pour ensuite le changer et placer 4 roues. En effet les différents câbles avaient tendance à gêner le déplacement du robot car ils se coinçaient dans les chenilles.
 +
 
 +
[[Fichier:20150122_165211.jpg|300px|thumb|left|Premier prototype : robot à chenille]]  
 +
[[Fichier:20150122_173112.jpg|300px|thumb|center|Changement chenille pour 4 roues (vue de profil)]]
 +
 
 +
 
 +
== Les différents capteurs utilisés ==
  
== 1.2) Les différents capteurs utilisés ==
 
 
[[Fichier:20150126_090419.jpg|200px|thumb|right|Capteur couleur]]
 
[[Fichier:20150126_090419.jpg|200px|thumb|right|Capteur couleur]]
  
'''1.2.1) Le Capteur de couleur'''
+
===='''Le Capteur de couleur'''====
  
Ce capteur a été placé sous le robot, au devant de celui-ci et dirigé vers le sol. Il permet de détecter la couleur du sol sur laquelle le robot passe et permet ainsi d'empêcher le robot de sortir du terrain.  
+
Ce capteur a été placé sous le robot, au devant de celui-ci et dirigé vers le sol. Il permet de détecter la couleur du sol sur laquelle le robot passe et permet ainsi d'empêcher le robot de sortir du terrain puisqu'il est délimité par des bandes de couleur.
 +
 +
===='' Le capteur de distance à ultrasons'' ====
  
 
+
Ce capteur est composé de deux éléments : un émetteur ultrason et un récepteur. On peut ainsi mesurer la différence de temps entre l'émission d'un signal ultrason et sa réception après qu'il ait atteint l'obstacle ; ce qui permet d'estimer la distance robot/obstacle.
 +
Ce capteur a été placé sur le devant du robot, légèrement surélevé afin qu'il n’interfère pas avec la balle. Il servira à éviter toutes collisions du robot avec des obstacles. Nous avons programmé le capteur de façon à ce qu'il s'arrête lorsqu'il rencontre un objet à moins de 20 centimètres de lui.
  
'''1.2.2) Le capteur de distance à ultrasons'''
+
[[Fichier:20150202_084638.mp4‎ |200px|thumb|right|Test capteur distance avec feuille de papier]]
Ce capteur est composé de deux éléments : un émetteur ultrason et un récepteur. On peut ainsi mesurer la différence de temps entre l'émission d'un signal ultrason et sa réception après qu'il ait rebondi sur un obstacle, ce qui permet d'estimer la distance de l'obstacle.
 
Ce capteur à été placé sur le devant du robot, légèrement surélevé afin qu'il n’interfère pas avec la balle. Il servira pour éviter les collisions du robot avec des obstacles. Nous avons programmer le capteur de façon à ce que le robot s'arrête lorsqu'il rencontre un objet à moins de 20 centimètres de lui.
 
  
 
[[Fichier:1422867827514.jpg|200px|thumb|right|Capteur infrarouge placé au sommet du robot & capter ultrasons]]
 
[[Fichier:1422867827514.jpg|200px|thumb|right|Capteur infrarouge placé au sommet du robot & capter ultrasons]]
  
'''1.2.3) Le capteur infrarouge'''
+
===='''Le capteur infrarouge'''====
  
 
Ce capteur permet de détecter la distance d'une source émettant dans l'infrarouge dans six directions différentes. Il est donc pratique pour localiser une source en fonction de l'angle avec le capteur et sa distance.  
 
Ce capteur permet de détecter la distance d'une source émettant dans l'infrarouge dans six directions différentes. Il est donc pratique pour localiser une source en fonction de l'angle avec le capteur et sa distance.  
Nous avons placer le capteur à plusieurs endroits différents. En effet nous avons rencontrer certains problèmes : lorsque l'objet à localiser (la balle ici, les buts n'étant pas prêts à testés) se trouvait à distance inférieure à 15 centimètres du capteur, les valeurs étaient erronées. Il devenait alors difficile au robot de déterminer avec exactitude la direction dans laquelle se rendre.
+
Nous avons placé le capteur à plusieurs endroits différents. En effet nous avons rencontré certains problèmes : lorsque l'objet localisait un objet (la balle ici, les buts n'étant pas prêts à être testés)qui se trouvait à distance inférieure à 15 centimètres du capteur, les valeurs étaient erronées. Il devenait alors difficile au robot de déterminer avec exactitude la direction dans laquelle se rendre.
[[Fichier:20150202_084638.mp4‎ |200px|thumb|right|Test capteur infrarouge avec feuille de papier]]
+
 
 +
[[Fichier:20150216_100111.mp4‎ |200px|thumb|right|Test capteur infrarouge]]
 +
 
 +
===='''Le capteur de contact'''====
 +
 
 +
Le capteur de contact est constitué d'un simple bouton poussoir, qui lorsqu’il est pressé, envoie un simple signal au robot. Il va permettre de vérifier que la balle est bien capturée.
 +
Nous l'avons utilisé dans une seule optique : lorsque le robot actionnait le bras mécanique pour attraper a balle, il devait savoir si oui ou non il l'avait bel et bien attrapé. Nous l'avons donc programmé pour que lorsque la balle appuie sur le capteur, le robot s'arrête et effectue une rotation.
  
  
'''1.2.4) Le capteur de contact'''
+
== '''Bras mécanique''' ==
  
Le capteur de contact est constitué d'un simple bouton poussoir, qui lorsqu’il est pressé, envoie un simple signal au robot. Il va permettre de vérifier que la balle est bien capturé.
+
Lors de la conception du robot, nous avions dans un premier temps construit le châssis, puis très vite le bras robotique. Ne pensant qu'il ne servirait qu'à tirer dans la balle, un simple appareil était suffisant, néanmoins nous nous sommes vite rendu compte qu'il y avait plus à faire!
Nous l'avons utiliser dans une seule optique : lorsque le robot actionner le bras mécanique pour attraper a balle, il devait savoir si oui ou non il l'avait bel et bien attrapé. Nous l'avons donc programmer pour que lorsque la balle appuierait sur le capteur, le robot s'arrête et effectue une rotation.
 
  
== '''1.3) Bras mécanique''' ==
 
  
Lors de la conception du robot, nous avions dans un premier temps construit le châssis, puis très vite le bras robotique. Ne pensant qu'il ne servirai qu'a tirer dans la balle, un simple appareil était suffisant, néanmoins nous nous sommes vite rendus compte qu'il avait plus à faire!
+
== '''Problématiques rencontrées''' ==
  
== '''1.3.1) Problématiques rencontrées''' ==
+
Le problème principal auquel nous avons été confronté fut la conception du bras mécanique. En effet au début il ne nous servait qu'à frapper la balle d'un coup sec mais il ne pouvait pas garder la balle. Nous avons donc changé radicalement notre façon de penser ; il était question de garder la balle lors d'un quelconque déplacement du robot.
 +
Il fallait que la balle puisse entrer facilement dans une sorte d'entonnoir où elle viendrait se glisser jusqu'au tir.
 +
S'en est donc suivi plusieurs conceptions différentes du bras mécanique.
  
Le problème principal auquel nous avons été confronté fut la conception du bras. En effet au début il ne nous servait qu'à frapper la balle d'un coup sec mais il ne pouvait pas garder la balle. Nous avons donc changer radicalement notre façon de penser ; il était question de garder la balle lors d'un quelconque déplacement du robot.
 
Il fallait que la balle puisse entrer facilement dans une sorte d'entonnoir où elle viendrait se glisser jusqu'au tire.
 
Se sont donc suivis plusieurs conception du bras mécanique.
 
  
 
Le dernier prototype ci-dessous semblait le plus performant, néanmoins lors des tests, la balle n'entrait pas correctement et le bras mécanique frappait donc dans le vent.
 
Le dernier prototype ci-dessous semblait le plus performant, néanmoins lors des tests, la balle n'entrait pas correctement et le bras mécanique frappait donc dans le vent.
 +
[[Fichier:1423471872321.jpg|200px|thumb|right|Quatrième prototype]]
 
   
 
   
 
[[Fichier:1423471208694.jpg|200px|thumb|left|Deuxième prototype]]  
 
[[Fichier:1423471208694.jpg|200px|thumb|left|Deuxième prototype]]  
 
[[Fichier:1423471733942.jpg|200px|thumb|center|Troisième prototype]]
 
[[Fichier:1423471733942.jpg|200px|thumb|center|Troisième prototype]]
[[Fichier:1423471872321.jpg|Quatrième prototype]]
 
  
== '''1.3.2) Version aboutie''' ==
 
  
  
[[Fichier:20150216_100111.mp4‎ |200px|thumb|left|Premier test avec bras à engrenage]]
 
  
Pour cette dernière version du bras mécanique nous avons choisi d'utiliser des engrenages. En effet les précédents essais ne nous permettaient pas de garder la balle. Nous avons donc aligner 4 engrenages de tailles différentes, l'une faisant tourner toutes les autres grâce à une barre placer en son centre qui s'actionne avec le servomoteur.  
+
= '''Version aboutie''' =
Il a alors fallu trouver le bon écart entre les engrenages. Il fallait également avoir des pinces assez longues pour ramener la balle vers le robot mais faire attention à ce qu'elle ne reste pas coincés. Avec la force du servomoteur, après plusieurs utilisation les engranges se décalaient donc il fallait les bloquer de manière à ce qu'ils ne partent pas n importe comment.
+
 
 +
[[Fichier:1424681769721.jpg |160px|thumb|right|Vue de face]]
 +
[[Fichier:1424681793686‎.jpg |350px|thumb|left|Vue de profil]]
 +
 
 +
Pour cette dernière version du bras mécanique nous avons choisi d'utiliser des engrenages.
 +
En effet les précédents essais ne nous permettaient pas de garder la balle. Nous avons donc aligné 4 engrenages de tailles différentes, l'une faisant tourner tous les autres grâce à une barre placer en son centre et qui s'actionne avec l'un des servomoteur.  
 +
Il a alors fallu trouver le bon écart entre les engrenages.  
 +
 
 +
Il fallait également avoir des pinces assez longues pour ramener la balle vers le robot mais faire attention à ce qu'elles ne restent pas coincées. Avec la force du servomoteur, après plusieurs utilisation les engrenages se décalaient donc il fallait les bloquer de manière à ce qu'ils ne partent pas n'importe comment.
 +
 
 +
Cette solution est assez économique car elle permet d'une part d'attraper la balle en refermant les pinces mais également de l'éjecter en les ouvrant. En effet chaque pince est plus ou moins en forme de V avec l'axe de rotation situé au niveau de la pointe.
 +
Ce système permet donc de "faire une pierre deux coups".
 +
 
 +
 
 +
 
 +
 
 +
 
 +
 
 +
[[Fichier:BE IMA‎.png |5000px|thumb|centre|Mécanisme pinces]]
 +
 
 +
 
 +
[[Fichier:20150526 111846.jpg |450px|thumb|centre|Version finale]]
 +
 
 +
 
 +
Les dernières modifications effectuées le robot relèvent plus d'un côté pratique.
 +
Tout d'abord nous avons replacé notre capteur de contact et notre capteur infrarouge afin d'optimiser leur efficacité.
 +
Nous avons ensuite fixé au mieux tout les capteurs et nous nous sommes assuré de la stabilité du robot.
 +
Enfin, les différents câbles gênant le mouvement des chenilles et le multiplexer n'étant pas vraiment fixé au robot, nous avons accroché ensemble ces éléments afin de ne point endommager le robot. Enfin nous avons enroulé un morceau de papier autour du capteur de couleur ; cela permet au capteur de ne pas être gêné par la lumière autour de lui et cela boost donc ses capacités.
 +
 
 +
= Le multiplexer =
 +
 
 +
Certains problèmes sont apparus lorsque nous avons commencé le programme pour trouver et attraper la balle.
 +
Tout d'abord le robot devait repérer la balle grâce à l'infrarouge, ensuite il devait se diriger vers elle et enfin, à la distance adéquate, attraper la balle. Néanmoins le robot n'arrivait pas à savoir si oui ou nous il tenait la balle entre ses pinces.
 +
Nous avons alors penser à utiliser un capteur de plus. Mais nous n'avions plus de place sur le robot, le nombre de prises étant limité.
 +
 
 +
 
 +
La solution proposée par l'enseignant fut l'utilisation d'un Multiplexer.
 +
En effet le multiplexer a fait office de multiprise et nous a permis de brancher plus de capteurs que prévu.
 +
Finalement nous disposions donc d'un capteur couleur, d'un capteur contact, d'un capteur infrarouge et de deux capteur de distance.
 +
 
 +
 
 +
Le gros problème était que nous ne savions pas du tout programmer ce multiplexer. Venant s'ajouter à ça le fait que plusieurs versions étaient disponibles sur internet sans que nous sachions vraiment laquelle commander. De nous étions incapable de trouver un exemple type de programmation pour le multiplexer.
 +
 
 +
 
 +
Nous avons donc pris beaucoup de retard par rapport aux autres groupes. Pendant que certains tentaient de faire la différentiation infrarouge entre la balle et les buts, nous étions toujours entrain de programmer notre multiplexer!
 +
Pour le programmer, il ne fallait pas brancher deux capteurs de même nature sur le multiplexer (exemple : 2 capteurs de contact). La programmation était également très rigoureuse et nous avons dû télécharger des fichiers contenant des phrases de code type afin de faciliter notre travail.
 +
 
 +
 
 +
Afin de pouvoir continuer à programmer les capteurs qui sont branchés sur le multiplexeur de capteurs, il convient de télécharger de nouveaux blocs NXT-G pour chacun des capteurs que l'on souhaite utiliser afin de pouvoir préciser l'adresse I2C de chacun d'eux. En effet, la brique intelligente a besoin de pouvoir les différencier étant donné qu'ils sont branchés sur le même port.
 +
 
  
[[Fichier:1424681769721.jpg |200px|thumb|left|Vue de face]]
+
On peut observer ci-dessous trois images :
[[Fichier:1424681793686‎.jpg |200px|thumb|right|Vue de profile]]
 
  
== '''2) Programmation''' ==
+
La première représente le premier prototype de multiplexer que notre enseignant nous avait confié. On ne pouvait brancher qu'un seul capteur supplémentaire et il s'est avéré que cela ne marchait que pour les moteurs.
  
/ A compléter avec capture d'écran
+
La seconde photo représente notre actuel multiplexer (gentiment commandé par notre enseignant). Il est constitué de deux boitiers ; l'un étant la batterie, et l'autre la "partie multiprise". On peut actuellement brancher 6 capteurs supplémentaires avec ce modèle, mais nous n'en avions pas besoin de tant, et cela n'était pas bon pour le robot et son ergonomie.
  
Expliquer :
+
Finalement, nous pouvons voir les deux capteurs supplémentaires installés. Il s'agit d'un capteur de distance et d'un capteur de contact. Le capteur de distance permet au robot de savoir quand la balle est très proche de lui pour avancer un peu et actionner ses pinces. Et le capteur de contact permet au robot de savoir exactement s'il détient ou non la balle : le principe étant que la balle fasse pression sur le capteur lorsqu'elle est attrapée.
  
*programme pour suivre une ligne : pour se garer
 
*programme pour faire demi tour si rencontre ligne d'une certaine couleur : ne pas sortir du terrain + ne pas entrer dans la surface de réparation
 
*programme pour trouver et se diriger vers la balle
 
*programme pour envoyer la balle vers le but
 
  
/
+
[[Fichier:2_capteurs.jpg|150px|thumb|right|Capteurs contact & distance]]
 +
[[Fichier:fake_multiplexer.jpg|150px|thumb|left|Multiplexer pour moteur]]
  
== '''3) Mise en place de la phase de jeu''' ==
+
[[Fichier:multiplexer.jpg|250px|thumb|center|Boitier multiplexer]]
 +
 
 +
 
 +
= '''Programmation''' =
 +
 
 +
Tout d'abord nous avons essayé de comprendre comment fonctionnait le langage nxc.
 +
Les premières commandes étaient assez simples en fait ; nous avons fait avancer le robot, le faire s'arrêter, le faire tourner etc.
 +
 
 +
Le programme final se décompose donc en deux parties principales :
 +
 
 +
- un programme qui permet au robot de s'arrêter devant un obstacle, d'attraper la balle, de la tirer vers le but et qui empêche le robot de sortir des limites du terrain.
 +
 
 +
- un programme qui entre deux matchs permet au robot de se garer sur un emplacement en dehors du terrain.
 +
 
 +
Les sources du programme écrites en C sont disponibles sur le wiki mais pour pour faciliter la compréhension elles seront détaillées en pseudo-code.   
 +
 
 +
 
 +
 
 +
== Structure principale du programme ==
 +
Voici le main du programme principal :
 +
 
 +
//Initialisation des variables pour les différents capteurs
 +
couleur = variable de couleur du capteur couleur
 +
distance1 = variable du premier capteur ultrasonique pour détecter les obstacles
 +
distance2 = variable du deuxième capteur de couleur pour détecter la balle
 +
direction = direction où se trouve la balle avec le capteur infrarouge
 +
 
 +
//Boucle principale
 +
TANT QUE (vrai) FAIRE //boucle infinie
 +
{
 +
    couleur = lire_capteurCouleur
 +
    distance1 = lire_capteurUS1
 +
    distance2 = lire_capteurUS2
 +
    direction = lire_capteurIR
 +
   
 +
    SI (distance1 < 30)  //S'il y a un obstacle devant le robot
 +
        ALORS
 +
            Eteindre moteur1
 +
            Eteindre moteur2
 +
        SINON
 +
            SI (direction != 5) //5 correspond à la balle e face du robot
 +
                ALORS
 +
                    cherche() //fonction de recherche de la balle
 +
                SINON
 +
                    SI (distance2 < 15) //cas ou la balle se trouve devant les pinces du robot
 +
                        avancer pendant 100ms
 +
                        chope() //fonction pour saisir la balle
 +
                    SINON
 +
                          SI (couleur != rouge OU couleur != vert) //cas ou le robot ne sort pas tu terrain
 +
                            Allumer moteur1(Speed)
 +
                            Allumer moteur2(Speed)
 +
                          SINON
 +
                            demitour()
 +
    Attendre 500ms
 +
}
 +
FIN TANT QUE
 +
 
 +
Détaillons un peu ce programme :
 +
 
 +
Le programme commence par lire les valeurs des différents capteurs. Ensuite il vérifie s'il n'y pas d'obstacles a moins de quelques centimètres du robot (la valeur 30 est arbitraire, c'est plus ou moins 10 centimètres). Si c'est le cas le robot s'arrête. Sinon il teste la position de la balle par rapport au capteur infrarouge. S'il n'est pas en face de celle-ci le programme exécute la fonction cherche() qui permet d'orienter le robot face à la balle. Une fois face à la balle le robot avance à la vitesse Speed (constante de préprocesseur définie au début du programme). Si le robot dévie légèrement, sa position est à nouveau corrigé avec la fonction cherche(). Ensuite si la distance lue avec le deuxième capteur ultrason est à inférieure à 15, cela signifie que la balle se situe devant le robot. Celui-ci va donc avancer pendant 100 ms pour mettre la balle dans ses pinces et le programme exécute la fonction chope() pour l'attraper. A chaque cycle de la boucle, le programme vérifie également, à l'aide du capteur de couleur, que le robot ne sort pas des limites du terrain en détectant du rouge ou du vert (cf Le terrain de jeu).
 +
 
 +
 
 +
Voici maintenant la fonction cherche :
 +
 
 +
Celle-ci permet au robot de s'orienter face à la balle et de corriger la trajectoire du déplacement le plus rapidement possible.
 +
 
 +
 
 +
//Initialisation des variables
 +
distance1 = valeur de la distance du premier capteur US
 +
distance2 = valeur de la distance du deuxième capteur US
 +
k = coefficient appliqué à la vitesse des moteurs pour optimiser le mouvement
 +
direction = angle entre la balle et le capteur IR
 +
 +
//Boucle principale
 +
TANT QUE (direction != 5) FAIRE //on sort de la boucle dès que le robot est face à la balle
 +
{
 +
      distance1 = lire_capteurUS1  //actualisation des distances
 +
      distance2 = lire_capteurUS2
 +
      SI (distance1 > 20) //On vérifie toujours qu'il n'y a pas d'obstacles
 +
        ALORS
 +
              direction = lire_capteurCouleur
 +
              k = absolue(5 - dir) + 1  //coefficient pour faire varier la vitesse en fonction de l'angle
 +
              SI (direction < 5)
 +
                ALORS
 +
                    Allumer moteur1(25 * k)
 +
                    Allumer moteur2(-25 * k)
 +
                SINON SI (direction > 5
 +
                          ALORS
 +
                              Allumer moteur1(-25 * k)
 +
                              Allumer moteur2(25 * k)
 +
        SINON
 +
              éteindre moteur 1 et 2
 +
      Attendre 200 ms
 +
      SI (distance2 < 15) //cas ou la balle serait dans les pinces
 +
          ALORS
 +
              chope()
 +
}
 +
FIN TANT QUE
 +
 
 +
 
 +
On commence de nouveau par lire les valeurs des différents capteurs, puis on vérifie à nouveau qu'il n'y a pas d'obstacles devant le robot. Maintenant le programme récupère l'angle entre la balle et le capteur IR : on a direction < 5 si l'a balle se trouve à gauche du robot, direction > 5 si elle se trouve à droite et direction = 5 si elle se trouve en face.
 +
La variable direction prend des valeurs entre 1 et 9 (cf Le capteur IR). Le robot va donc tourner a gauche ou a droite en fonction de la variable direction avec une vitesse proportionnelle a son éloignement de la balle. S'il est face à la balle on quitte la fonction et on retourne dans la boucle principale qui le fait avancer droit vers la balle. On vérifie également si la balle se trouve dans les pinces au moment de l’exécution de cette fonction. Dans ce cas, on referme les pinces.
 +
 
 +
== Initialisation des périphériques ==
 +
 
 +
*Initialisation des capteurs :
 +
 
 +
L'utilisation des capteurs via un programme NXC requiert une initialisation (où l'on indique au robot à quel port les capteurs sont branchés) et une lecture.
 +
 
 +
*Pour le capteur infrarouge:
 +
 
 +
SetSensorLowspeed(IN_1) et SetHTIRSeeker2Mode(IN_1, HTIR2_MODE_600)  ou  SetHTIRSeeker2Mode(IN_1, HTIR2_MODE_1200)
 +
result = ReadSensorHTIRSeeker2AC(IN_2,dir,s1,s2,s3,s4,s5);
 +
 
 +
*Pour le capteur d'ultrasons:
 +
 
 +
SetSensorUltrasonic(IN_2)
 +
dist = SensorUS(IN_2); 
 +
 
 +
*Pour le capteur de contact :
 +
 
 +
SetSensorMSPressure(IN_4) 
 +
 
 +
*Pour le capteur de couleur :
 +
 
 +
SetSensorColorFull(IN_3)
 +
SV = ReadSensorColorEx(IN_3, cval, rawData, normData, scaledData);
 +
 
 +
=== Se garer ===
 +
 
 +
void garer()
 +
{
 +
  int i = 0;
 +
 
 +
  rejoindre_bord(); //fonction qui fait avancer le robot jusqu’à rencontrer une ligne rouge
 +
    OnFwd(OUT_A, 0);
 +
  OnFwd(OUT_B, 0);
 +
 
 +
  do
 +
  {
 +
    result = ReadSensorColorEx(IN_3, cval, rawData, normData, scaledData);
 +
    if(cval == INPUT_REDCOLOR)
 +
    {
 +
      OnFwd(OUT_A, Speed);
 +
      OnFwd(OUT_B, Speed);
 +
    }
 +
    else
 +
      if ((i % 12000) < 5000) //timer qui fait tourner le robot à gauche ou à droite
 +
      {
 +
        OnFwd(OUT_A, 65);
 +
        OnFwd(OUT_B, -65);
 +
      }
 +
      else
 +
        {
 +
          OnFwd(OUT_A, -65);
 +
          OnFwd(OUT_B, 65);
 +
        }
 +
        i++;
 +
      }
 +
      while (cval != INPUT_BLACKCOLOR)
 +
  }
 +
 
 +
Lorsque le robot a envoyé la balle vers le but et qu'il a marqué, la phase de jeu est finie. L'arbitre commande alors au robot d'aller se garer. Pour cela le robot s'avance vers le but adverse jusqu'à ce qu'il rencontre une ligne verte. Ensuite il effectue une rotation à 90° et recommence à avancer. Il rencontre alors une ligne rouge. Pour ce garer, le robot va suivre cette ligne rouge!
 +
S'il rencontre alors du blanc, le robot effectue une légère rotation pour retourner sur la bande rouge qu'il suivra en ligne droite.
 +
Finalement lorsque le robot a atteint une bande de couleur noire, il se gare et s'arrête.
 +
 
 +
La phase de jeu est maintenant terminée et ça sera l'arbitre qui donnera l'ordre au robot de sortir de son garage et de recommencer une partie!
 +
 
 +
[[Media:garer.mp4|Vidéo : Le robot contourne la ligne verte et va se garer en suivant la ligne rouge]]
 +
 
 +
== Différentiation entre la balle et les buts ==
 +
 
 +
Cette partie n'a pas pu être entièrement abordée à cause de nombreux problèmes rencontrés. En effet, nous avons tenter de différencier la balle des buts afin de permettre au robot de marquer. Les buts, tout comme la balle émettent des rayons infrarouges mais à différentes fréquences et par intermittence. Nous avons donc exploité le fait que le capteur infrarouge possède plusieurs modes pour différentes fréquences. Il fallait donc prendre une balle émettant à 600 Hz et des buts émettant à 1200 Hz par exemple. Une fois que le robot avait attrapé  la balle on changeait le mode du capteur à l'aide d'une simple commande et on pouvait ainsi localiser les buts.
 +
 
 +
Le problème était que malgré le changement de fréquence du capteur, il continuait de percevoir la balle ce qui rendait la localisation des buts impossibles. De plus il fallait également prendre en compte la différenciation des deux buts en plus de la différenciation de la balle et des buts. Cette partie n'a donc pas pu être finalisée.
 +
 
 +
== Communication avec l'arbitre ==
 +
 
 +
Cette partie n'a pas pu être abordée par manque de temps.
 +
 
 +
== Le multiplexeur ==
 +
 
 +
Comme indiqué précédemment nous avons eut le besoin d’implémenter un multiplexeur à notre robot. Cette étape nous à coûtée énormément de temps, pas tant à cause de l'algorithme lui-même mais surtout au niveau des recherches effectuée pour l’utiliser. De plus nous avons essayé différents modèles et fait de nombreux tests.
 +
 
 +
Finalement, nous avons pu trouver un driver sur le net constitué d'un fichier header en langage C (extension .h)
 +
 
 +
= ''' Le terrain de jeu ''' =
 +
 
 +
 
 +
La réalisation du terrain de jeu s'est faite avec la participation de tous les binômes.
 +
Il a d'abord fallu mesurer les buts et les robots afin de savoir quel espace laisser entre les différentes limites de la plaque. En effet il était nécessaire de laisser assez de place aux robots joueurs et ramasseurs pour se garer.
 +
On a ensuite tracer au crayon gris les différentes limites sur les plaques. Puis nous avons collé les bandes de scotch colorés aux emplacements adéquates.
 +
 
 +
Les bandes vertes correspondent à la surface de réparation devant les buts. Les robots de compétitions ne peuvent pas y accéder. Les bandes rouges permettent de délimiter le terrain ainsi que de permettre aux robots ramasseur et de compétition de se replacer ou de se garer. Les bandes bleues, avec à leur intersection un point jaune, permettent aux robots ramasseur de replacer la balle au centre.
 +
 
 +
[[Fichier:Terrain au bois.jpg|200px|left|]]
 +
[[Fichier:Terrain.jpg|300px|center|]]
 +
 
 +
 
 +
 
 +
 
 +
 
 +
 
 +
[[Media:fail.mp4|Vidéo : Problème lors du passage du robot de plaque en plaque]]
 +
 
 +
 
 +
La vidéo ci-dessous nous prouve que la disposition du terrain n'est pas forcément la bonne.
 +
En effet lorsqu'il passe de plaque en plaque, le robot a tendance à détruire le terrain car les plaques sont mal fixées. Il faut donc tenir le terrain lors d'un match ce qui est plutôt contraignant...
 +
 
 +
= '''Mise en place de la phase de jeu''' =
  
 
Ce bureau d'étude nous permet surtout de travailler en équipe. Une fois la conception mécanique et la programmation du robot assez avancées, il nous fallait penser à la partie de football entre les robots! En effet dans la phase de jeu chacun a un rôle à tenir ; pour chaque terrain
 
Ce bureau d'étude nous permet surtout de travailler en équipe. Une fois la conception mécanique et la programmation du robot assez avancées, il nous fallait penser à la partie de football entre les robots! En effet dans la phase de jeu chacun a un rôle à tenir ; pour chaque terrain
Ligne 96 : Ligne 395 :
 
Nous devions être conscients de plusieurs choses :
 
Nous devions être conscients de plusieurs choses :
  
*Détecter la balle (muni de led infrarouge) et les cages de buts (muni de led infrarouge)
+
*Détecter la balle et les cages de buts (les deux émettant dans l'infrarouge)
 
*Différencier ces deux derniers.
 
*Différencier ces deux derniers.
 
*Détecter les limites du terrain (ruban adhésifs colorés)
 
*Détecter les limites du terrain (ruban adhésifs colorés)
Ligne 102 : Ligne 401 :
 
*S'orienter vers la bonne cage de but  
 
*S'orienter vers la bonne cage de but  
 
*Envoyer la balle vers le but
 
*Envoyer la balle vers le but
 +
*Se replacer
  
Détecter les limites du terrain semblait chose facile, mes les professeurs nous ont donné pour contraintes de devoir "garer" les robots lorsqu'ils ne jouent pas. Il faut donc créer un programme pour ne pas sortir du terrain en faisant faire demi-tour au robot lorsqu'il rencontre certaines couleurs, et un autre pour suivre une ligne et pour qu'il se gare correctement.
+
Détecter les limites du terrain semblait chose facile, mes les professeurs nous ont donné pour contraintes de devoir "garer" les robots lorsqu'ils ne jouent pas. Il a donc fallu créer un programme pour que les robots ne sortent pas du terrain. Un autre pour qu'ils effectuent un demi-tour lorsqu'ils rencontrent certaines bandes de couleurs. Et enfin un autre pour suivre une ligne et pour qu'ils se garent correctement.
  
 
Le plus grand challenge pour notre robot est de différencier la balle des buts! Tel qu'il est maintenant, notre programme ne nous permet pas cela ; le robot se dirigera automatiquement vers l'objet (émettant un signal infrarouge) le plus proche de lui...Ce qui est plutôt contraignant pour la phase de jeu.
 
Le plus grand challenge pour notre robot est de différencier la balle des buts! Tel qu'il est maintenant, notre programme ne nous permet pas cela ; le robot se dirigera automatiquement vers l'objet (émettant un signal infrarouge) le plus proche de lui...Ce qui est plutôt contraignant pour la phase de jeu.
 +
Nous devons donc collaborer avec les autres binômes pour trouver une solution !
 +
 +
Il a était question de deux options :
 +
* Premièrement : faire émettre aux cages de but et à la balle des signaux différents. Ainsi le robot devra chercher la balle selon la fréquence qu'elle émet et se concentrera seulement après sur les buts.
 +
*Deuxièmement : utiliser l'arbitre! En effet l'arbitre pourrait "demander" aux buts de s'éteindre tant que l'un des deux robots n'a pas attraper la balle. Il faudrait donc programmer le robot afin que lorsqu'il a la balle, il s'arrête et envoi un signal à l'arbitre pour lui confirmer que les buts peuvent fonctionner.
 +
 +
 +
= Conclusion =
 +
 +
Pour ce bureau d'étude, nous avons choisie de réaliser un robot attrapeur.
 +
La conception de ce projet s'est déroulée en trois grandes étapes.
 +
 +
Tout d'abord, la construction d'un point de vue mécanique :
 +
Il a fallu construire un robot assez solide. Nous devions également trouver une place pour chacun des capteurs et avoir des pinces assez solides et capables de garder la balle en leur sein.
 +
 +
Ensuite, nous sommes passés à la programmation. Il s'agissait de la partie que nous appréhendions le plus! En effet s'il y avait des failles dans le programme, le robot ne serait jamais capable de réaliser un match.
 +
 +
Enfin, la dernière étapes a consisté à la création du terrain et à la réalisation des derniers tests. Il s'agissait avant tout d'être sur du bon fonctionnement du robot et de régler les derniers problèmes.
 +
(exemple : attacher les câbles entre eux pour qu'ils ne se coincent pas dans les chenilles)
 +
 +
 +
Ce projet nous a avant tout permis d'avoir une première approche de ce que pourrait être le département IMA et de travailler dans des conditions d'ingénieur. En effet nous avons mené à bien un projet du début jusqu'à la fin en travaillant en toute autonomie en binôme, mais également en équipe. Il nous a fallu mettre en place des objectifs dès le début pour réaliser ce projet dans les meilleures conditions qui soient.
 +
Le BE IMA Foot nous aura donc beaucoup apporté jusqu'à la fin.
 +
 +
= Voir Aussi =
 +
 +
[http://fr.wikipedia.org/wiki/Lego_Mindstorms Lego Mindstorm]
 +
 +
[http://fr.wikipedia.org/wiki/Lego_Mindstorms_NXT Lego Mindstorm NXT]
 +
 +
[http://www.hitechnic.com/cgi-bin/commerce.cgi?preadd=action&key=NSX2020 HiTechnic Sensor Multiplexer ]
 +
 +
[http://www.lisyc.univ-brest.fr/pages_perso/babau/cours/robotnxc.pdf Cours Robot NXC]
 +
 +
[http://ahcene.mezine.free.fr/projets/robotic/guide_nxc.pdf Guide NXC]

Version actuelle datée du 30 mai 2015 à 09:12


Vidéo HD


Introduction

Dans le cadre du bureau d'étude spécialité IMA, nous avons la charge de concevoir un match sportif mettant en œuvre des robots de la gamme lego mindstorms. Pour cela nous nous sommes répartis les tâches entre la conception des robots joueurs, des robot ramasseurs, des buts et de l'arbitre. Notre binôme a choisi de réaliser l'un des 4 robots joueurs, c'est-à-dire un robot capable de repérer puis de saisir une balle avant de l'envoyer dans les buts adverses.

Objectifs à atteindre

D'après le cahier des charges du BE IMA, nous devions réaliser notre robot en tenant compte de certaines contraintes :

  • Les robots ont comme tâche principale de s'approcher de la balle et de la lancer vers le but adverse.
  • Les robots ne peuvent avancer que s'ils ne détectent pas d'obstacle à faible distance.
  • Un robot de jeu ne peut pas sortir du terrain.
  • Les buts faisant clignoter leurs LEDs infrarouges suivant un code pré-établi, les robots doivent pouvoir différencier les buts de la balle.
  • Les communications entre les acteurs doivent s'effectuer par bluetooth.

Les robots et les buts s'apparient avec l'arbitre et ne communiquent qu'avec lui.

La conception du robot

La conception mécanique du robot passe tout d'abord par la confection d'un châssis stable et solide, puis par le placement des différents capteurs, et enfin par la mise en place d'un bras mécanique. Pour cela nous disposions d'une boite lego mindstorm avec toutes sortes de pièces, des roues, des servomoteurs et différents types de capteurs : couleur, infrarouge, ultrasons etc. Nous avons changé plusieurs fois, pour des questions de pratique, le concept du robot ; qu'il s'agisse de l'aspect général, du bras mécanique, ou du placement des capteurs .

Kit Lego Robot Mindstorms NXT

Brique, servo moteurs & capteurs

Pour construire notre robot, nous disposions d'un kit Lego Mindstorm. Ce kit comprend :

La brique intelligente Lego Mindstorms NXT basée sur un processeur 32 bits
3 servos moteurs
2 capteurs de contact
1 capteur de distance à ultrasons (sonar)
1 capteur de lumière et de couleur
1 capteur infrarouge
577 pièces Lego technic
1 câble USB
1 plan de travail sous forme de poster


La brique Lego Mindstorms NXT est le véritable cerveau de notre robot NXT Lego. Elle se connecte au PC via un câble USB ou le Bluetooth.

Il est même possible de configurer un téléphone portable ou un joystick afin de piloter votre robot.


L'aspect mécanique

La première chose à faire a été de confectionner le châssis. Nous avions besoin d'une base stable pour placer le boitier Mindstorm et pour faciliter le déplacement. Nous sommes tout d'abord partis sur l'idée d'un déplacement grâce aux chenilles, pour ensuite le changer et placer 4 roues. En effet les différents câbles avaient tendance à gêner le déplacement du robot car ils se coinçaient dans les chenilles.

Premier prototype : robot à chenille
Changement chenille pour 4 roues (vue de profil)


Les différents capteurs utilisés

Capteur couleur

Le Capteur de couleur

Ce capteur a été placé sous le robot, au devant de celui-ci et dirigé vers le sol. Il permet de détecter la couleur du sol sur laquelle le robot passe et permet ainsi d'empêcher le robot de sortir du terrain puisqu'il est délimité par des bandes de couleur.

Le capteur de distance à ultrasons

Ce capteur est composé de deux éléments : un émetteur ultrason et un récepteur. On peut ainsi mesurer la différence de temps entre l'émission d'un signal ultrason et sa réception après qu'il ait atteint l'obstacle ; ce qui permet d'estimer la distance robot/obstacle. Ce capteur a été placé sur le devant du robot, légèrement surélevé afin qu'il n’interfère pas avec la balle. Il servira à éviter toutes collisions du robot avec des obstacles. Nous avons programmé le capteur de façon à ce qu'il s'arrête lorsqu'il rencontre un objet à moins de 20 centimètres de lui.

Fichier:20150202 084638.mp4

Capteur infrarouge placé au sommet du robot & capter ultrasons

Le capteur infrarouge

Ce capteur permet de détecter la distance d'une source émettant dans l'infrarouge dans six directions différentes. Il est donc pratique pour localiser une source en fonction de l'angle avec le capteur et sa distance. Nous avons placé le capteur à plusieurs endroits différents. En effet nous avons rencontré certains problèmes : lorsque l'objet localisait un objet (la balle ici, les buts n'étant pas prêts à être testés)qui se trouvait à distance inférieure à 15 centimètres du capteur, les valeurs étaient erronées. Il devenait alors difficile au robot de déterminer avec exactitude la direction dans laquelle se rendre.

Fichier:20150216 100111.mp4

Le capteur de contact

Le capteur de contact est constitué d'un simple bouton poussoir, qui lorsqu’il est pressé, envoie un simple signal au robot. Il va permettre de vérifier que la balle est bien capturée. Nous l'avons utilisé dans une seule optique : lorsque le robot actionnait le bras mécanique pour attraper a balle, il devait savoir si oui ou non il l'avait bel et bien attrapé. Nous l'avons donc programmé pour que lorsque la balle appuie sur le capteur, le robot s'arrête et effectue une rotation.


Bras mécanique

Lors de la conception du robot, nous avions dans un premier temps construit le châssis, puis très vite le bras robotique. Ne pensant qu'il ne servirait qu'à tirer dans la balle, un simple appareil était suffisant, néanmoins nous nous sommes vite rendu compte qu'il y avait plus à faire!


Problématiques rencontrées

Le problème principal auquel nous avons été confronté fut la conception du bras mécanique. En effet au début il ne nous servait qu'à frapper la balle d'un coup sec mais il ne pouvait pas garder la balle. Nous avons donc changé radicalement notre façon de penser ; il était question de garder la balle lors d'un quelconque déplacement du robot. Il fallait que la balle puisse entrer facilement dans une sorte d'entonnoir où elle viendrait se glisser jusqu'au tir. S'en est donc suivi plusieurs conceptions différentes du bras mécanique.


Le dernier prototype ci-dessous semblait le plus performant, néanmoins lors des tests, la balle n'entrait pas correctement et le bras mécanique frappait donc dans le vent.

Quatrième prototype
Deuxième prototype
Troisième prototype



Version aboutie

Vue de face
Vue de profil

Pour cette dernière version du bras mécanique nous avons choisi d'utiliser des engrenages. En effet les précédents essais ne nous permettaient pas de garder la balle. Nous avons donc aligné 4 engrenages de tailles différentes, l'une faisant tourner tous les autres grâce à une barre placer en son centre et qui s'actionne avec l'un des servomoteur. Il a alors fallu trouver le bon écart entre les engrenages.

Il fallait également avoir des pinces assez longues pour ramener la balle vers le robot mais faire attention à ce qu'elles ne restent pas coincées. Avec la force du servomoteur, après plusieurs utilisation les engrenages se décalaient donc il fallait les bloquer de manière à ce qu'ils ne partent pas n'importe comment.

Cette solution est assez économique car elle permet d'une part d'attraper la balle en refermant les pinces mais également de l'éjecter en les ouvrant. En effet chaque pince est plus ou moins en forme de V avec l'axe de rotation situé au niveau de la pointe. Ce système permet donc de "faire une pierre deux coups".




Mécanisme pinces


Version finale


Les dernières modifications effectuées le robot relèvent plus d'un côté pratique. Tout d'abord nous avons replacé notre capteur de contact et notre capteur infrarouge afin d'optimiser leur efficacité. Nous avons ensuite fixé au mieux tout les capteurs et nous nous sommes assuré de la stabilité du robot. Enfin, les différents câbles gênant le mouvement des chenilles et le multiplexer n'étant pas vraiment fixé au robot, nous avons accroché ensemble ces éléments afin de ne point endommager le robot. Enfin nous avons enroulé un morceau de papier autour du capteur de couleur ; cela permet au capteur de ne pas être gêné par la lumière autour de lui et cela boost donc ses capacités.

Le multiplexer

Certains problèmes sont apparus lorsque nous avons commencé le programme pour trouver et attraper la balle. Tout d'abord le robot devait repérer la balle grâce à l'infrarouge, ensuite il devait se diriger vers elle et enfin, à la distance adéquate, attraper la balle. Néanmoins le robot n'arrivait pas à savoir si oui ou nous il tenait la balle entre ses pinces. Nous avons alors penser à utiliser un capteur de plus. Mais nous n'avions plus de place sur le robot, le nombre de prises étant limité.


La solution proposée par l'enseignant fut l'utilisation d'un Multiplexer. En effet le multiplexer a fait office de multiprise et nous a permis de brancher plus de capteurs que prévu. Finalement nous disposions donc d'un capteur couleur, d'un capteur contact, d'un capteur infrarouge et de deux capteur de distance.


Le gros problème était que nous ne savions pas du tout programmer ce multiplexer. Venant s'ajouter à ça le fait que plusieurs versions étaient disponibles sur internet sans que nous sachions vraiment laquelle commander. De nous étions incapable de trouver un exemple type de programmation pour le multiplexer.


Nous avons donc pris beaucoup de retard par rapport aux autres groupes. Pendant que certains tentaient de faire la différentiation infrarouge entre la balle et les buts, nous étions toujours entrain de programmer notre multiplexer! Pour le programmer, il ne fallait pas brancher deux capteurs de même nature sur le multiplexer (exemple : 2 capteurs de contact). La programmation était également très rigoureuse et nous avons dû télécharger des fichiers contenant des phrases de code type afin de faciliter notre travail.


Afin de pouvoir continuer à programmer les capteurs qui sont branchés sur le multiplexeur de capteurs, il convient de télécharger de nouveaux blocs NXT-G pour chacun des capteurs que l'on souhaite utiliser afin de pouvoir préciser l'adresse I2C de chacun d'eux. En effet, la brique intelligente a besoin de pouvoir les différencier étant donné qu'ils sont branchés sur le même port.


On peut observer ci-dessous trois images :

La première représente le premier prototype de multiplexer que notre enseignant nous avait confié. On ne pouvait brancher qu'un seul capteur supplémentaire et il s'est avéré que cela ne marchait que pour les moteurs.

La seconde photo représente notre actuel multiplexer (gentiment commandé par notre enseignant). Il est constitué de deux boitiers ; l'un étant la batterie, et l'autre la "partie multiprise". On peut actuellement brancher 6 capteurs supplémentaires avec ce modèle, mais nous n'en avions pas besoin de tant, et cela n'était pas bon pour le robot et son ergonomie.

Finalement, nous pouvons voir les deux capteurs supplémentaires installés. Il s'agit d'un capteur de distance et d'un capteur de contact. Le capteur de distance permet au robot de savoir quand la balle est très proche de lui pour avancer un peu et actionner ses pinces. Et le capteur de contact permet au robot de savoir exactement s'il détient ou non la balle : le principe étant que la balle fasse pression sur le capteur lorsqu'elle est attrapée.


Capteurs contact & distance
Multiplexer pour moteur
Boitier multiplexer


Programmation

Tout d'abord nous avons essayé de comprendre comment fonctionnait le langage nxc. Les premières commandes étaient assez simples en fait ; nous avons fait avancer le robot, le faire s'arrêter, le faire tourner etc.

Le programme final se décompose donc en deux parties principales :

- un programme qui permet au robot de s'arrêter devant un obstacle, d'attraper la balle, de la tirer vers le but et qui empêche le robot de sortir des limites du terrain.

- un programme qui entre deux matchs permet au robot de se garer sur un emplacement en dehors du terrain.

Les sources du programme écrites en C sont disponibles sur le wiki mais pour pour faciliter la compréhension elles seront détaillées en pseudo-code.


Structure principale du programme

Voici le main du programme principal :

//Initialisation des variables pour les différents capteurs
couleur = variable de couleur du capteur couleur
distance1 = variable du premier capteur ultrasonique pour détecter les obstacles
distance2 = variable du deuxième capteur de couleur pour détecter la balle
direction = direction où se trouve la balle avec le capteur infrarouge
//Boucle principale
TANT QUE (vrai) FAIRE //boucle infinie
{
    couleur = lire_capteurCouleur
    distance1 = lire_capteurUS1
    distance2 = lire_capteurUS2
    direction = lire_capteurIR
    
    SI (distance1 < 30)   //S'il y a un obstacle devant le robot
       ALORS
            Eteindre moteur1
            Eteindre moteur2
       SINON
            SI (direction != 5) //5 correspond à la balle e face du robot
               ALORS
                    cherche() //fonction de recherche de la balle
               SINON
                    SI (distance2 < 15) //cas ou la balle se trouve devant les pinces du robot
                       avancer pendant 100ms
                       chope() //fonction pour saisir la balle
                    SINON
                         SI (couleur != rouge OU couleur != vert) //cas ou le robot ne sort pas tu terrain
                            Allumer moteur1(Speed)
                            Allumer moteur2(Speed)
                         SINON
                            demitour()
    Attendre 500ms
}
FIN TANT QUE

Détaillons un peu ce programme :

Le programme commence par lire les valeurs des différents capteurs. Ensuite il vérifie s'il n'y pas d'obstacles a moins de quelques centimètres du robot (la valeur 30 est arbitraire, c'est plus ou moins 10 centimètres). Si c'est le cas le robot s'arrête. Sinon il teste la position de la balle par rapport au capteur infrarouge. S'il n'est pas en face de celle-ci le programme exécute la fonction cherche() qui permet d'orienter le robot face à la balle. Une fois face à la balle le robot avance à la vitesse Speed (constante de préprocesseur définie au début du programme). Si le robot dévie légèrement, sa position est à nouveau corrigé avec la fonction cherche(). Ensuite si la distance lue avec le deuxième capteur ultrason est à inférieure à 15, cela signifie que la balle se situe devant le robot. Celui-ci va donc avancer pendant 100 ms pour mettre la balle dans ses pinces et le programme exécute la fonction chope() pour l'attraper. A chaque cycle de la boucle, le programme vérifie également, à l'aide du capteur de couleur, que le robot ne sort pas des limites du terrain en détectant du rouge ou du vert (cf Le terrain de jeu).


Voici maintenant la fonction cherche :

Celle-ci permet au robot de s'orienter face à la balle et de corriger la trajectoire du déplacement le plus rapidement possible.


//Initialisation des variables
distance1 = valeur de la distance du premier capteur US
distance2 = valeur de la distance du deuxième capteur US
k = coefficient appliqué à la vitesse des moteurs pour optimiser le mouvement 
direction = angle entre la balle et le capteur IR

//Boucle principale
TANT QUE (direction != 5) FAIRE //on sort de la boucle dès que le robot est face à la balle
{
     distance1 = lire_capteurUS1   //actualisation des distances
     distance2 = lire_capteurUS2
     SI (distance1 > 20) //On vérifie toujours qu'il n'y a pas d'obstacles
        ALORS 
             direction = lire_capteurCouleur
             k = absolue(5 - dir) + 1  //coefficient pour faire varier la vitesse en fonction de l'angle
             SI (direction < 5)
                ALORS
                    Allumer moteur1(25 * k)
                    Allumer moteur2(-25 * k)
                SINON SI (direction > 5
                         ALORS
                              Allumer moteur1(-25 * k)
                              Allumer moteur2(25 * k)
        SINON
             éteindre moteur 1 et 2
      Attendre 200 ms
      SI (distance2 < 15) //cas ou la balle serait dans les pinces
         ALORS 
              chope()
}
FIN TANT QUE


On commence de nouveau par lire les valeurs des différents capteurs, puis on vérifie à nouveau qu'il n'y a pas d'obstacles devant le robot. Maintenant le programme récupère l'angle entre la balle et le capteur IR : on a direction < 5 si l'a balle se trouve à gauche du robot, direction > 5 si elle se trouve à droite et direction = 5 si elle se trouve en face. La variable direction prend des valeurs entre 1 et 9 (cf Le capteur IR). Le robot va donc tourner a gauche ou a droite en fonction de la variable direction avec une vitesse proportionnelle a son éloignement de la balle. S'il est face à la balle on quitte la fonction et on retourne dans la boucle principale qui le fait avancer droit vers la balle. On vérifie également si la balle se trouve dans les pinces au moment de l’exécution de cette fonction. Dans ce cas, on referme les pinces.

Initialisation des périphériques

  • Initialisation des capteurs :

L'utilisation des capteurs via un programme NXC requiert une initialisation (où l'on indique au robot à quel port les capteurs sont branchés) et une lecture.

  • Pour le capteur infrarouge:
SetSensorLowspeed(IN_1) et SetHTIRSeeker2Mode(IN_1, HTIR2_MODE_600)  ou  SetHTIRSeeker2Mode(IN_1, HTIR2_MODE_1200)
result = ReadSensorHTIRSeeker2AC(IN_2,dir,s1,s2,s3,s4,s5); 
  • Pour le capteur d'ultrasons:
SetSensorUltrasonic(IN_2) 
dist = SensorUS(IN_2);   
  • Pour le capteur de contact :
SetSensorMSPressure(IN_4)   
  • Pour le capteur de couleur :
SetSensorColorFull(IN_3) 
SV = ReadSensorColorEx(IN_3, cval, rawData, normData, scaledData);

Se garer

void garer()
{
 int i = 0;
 
 rejoindre_bord(); //fonction qui fait avancer le robot jusqu’à rencontrer une ligne rouge
   OnFwd(OUT_A, 0);
  OnFwd(OUT_B, 0);
 
 do
 { 
   result = ReadSensorColorEx(IN_3, cval, rawData, normData, scaledData);
   if(cval == INPUT_REDCOLOR)
   {
     OnFwd(OUT_A, Speed);
     OnFwd(OUT_B, Speed); 
   }
   else 
     if ((i % 12000) < 5000) //timer qui fait tourner le robot à gauche ou à droite
     {
       OnFwd(OUT_A, 65);
       OnFwd(OUT_B, -65);
     }
     else
       {
         OnFwd(OUT_A, -65);
         OnFwd(OUT_B, 65);
       } 
       i++;
     }
     while (cval != INPUT_BLACKCOLOR)
 }

Lorsque le robot a envoyé la balle vers le but et qu'il a marqué, la phase de jeu est finie. L'arbitre commande alors au robot d'aller se garer. Pour cela le robot s'avance vers le but adverse jusqu'à ce qu'il rencontre une ligne verte. Ensuite il effectue une rotation à 90° et recommence à avancer. Il rencontre alors une ligne rouge. Pour ce garer, le robot va suivre cette ligne rouge! S'il rencontre alors du blanc, le robot effectue une légère rotation pour retourner sur la bande rouge qu'il suivra en ligne droite. Finalement lorsque le robot a atteint une bande de couleur noire, il se gare et s'arrête.

La phase de jeu est maintenant terminée et ça sera l'arbitre qui donnera l'ordre au robot de sortir de son garage et de recommencer une partie!

Vidéo : Le robot contourne la ligne verte et va se garer en suivant la ligne rouge

Différentiation entre la balle et les buts

Cette partie n'a pas pu être entièrement abordée à cause de nombreux problèmes rencontrés. En effet, nous avons tenter de différencier la balle des buts afin de permettre au robot de marquer. Les buts, tout comme la balle émettent des rayons infrarouges mais à différentes fréquences et par intermittence. Nous avons donc exploité le fait que le capteur infrarouge possède plusieurs modes pour différentes fréquences. Il fallait donc prendre une balle émettant à 600 Hz et des buts émettant à 1200 Hz par exemple. Une fois que le robot avait attrapé la balle on changeait le mode du capteur à l'aide d'une simple commande et on pouvait ainsi localiser les buts.

Le problème était que malgré le changement de fréquence du capteur, il continuait de percevoir la balle ce qui rendait la localisation des buts impossibles. De plus il fallait également prendre en compte la différenciation des deux buts en plus de la différenciation de la balle et des buts. Cette partie n'a donc pas pu être finalisée.

Communication avec l'arbitre

Cette partie n'a pas pu être abordée par manque de temps.

Le multiplexeur

Comme indiqué précédemment nous avons eut le besoin d’implémenter un multiplexeur à notre robot. Cette étape nous à coûtée énormément de temps, pas tant à cause de l'algorithme lui-même mais surtout au niveau des recherches effectuée pour l’utiliser. De plus nous avons essayé différents modèles et fait de nombreux tests.

Finalement, nous avons pu trouver un driver sur le net constitué d'un fichier header en langage C (extension .h)

Le terrain de jeu

La réalisation du terrain de jeu s'est faite avec la participation de tous les binômes. Il a d'abord fallu mesurer les buts et les robots afin de savoir quel espace laisser entre les différentes limites de la plaque. En effet il était nécessaire de laisser assez de place aux robots joueurs et ramasseurs pour se garer. On a ensuite tracer au crayon gris les différentes limites sur les plaques. Puis nous avons collé les bandes de scotch colorés aux emplacements adéquates.

Les bandes vertes correspondent à la surface de réparation devant les buts. Les robots de compétitions ne peuvent pas y accéder. Les bandes rouges permettent de délimiter le terrain ainsi que de permettre aux robots ramasseur et de compétition de se replacer ou de se garer. Les bandes bleues, avec à leur intersection un point jaune, permettent aux robots ramasseur de replacer la balle au centre.

Terrain au bois.jpg
Terrain.jpg




Vidéo : Problème lors du passage du robot de plaque en plaque


La vidéo ci-dessous nous prouve que la disposition du terrain n'est pas forcément la bonne. En effet lorsqu'il passe de plaque en plaque, le robot a tendance à détruire le terrain car les plaques sont mal fixées. Il faut donc tenir le terrain lors d'un match ce qui est plutôt contraignant...

Mise en place de la phase de jeu

Ce bureau d'étude nous permet surtout de travailler en équipe. Une fois la conception mécanique et la programmation du robot assez avancées, il nous fallait penser à la partie de football entre les robots! En effet dans la phase de jeu chacun a un rôle à tenir ; pour chaque terrain il y a :

  • deux cage de buts
  • deux robots de compétition
  • un arbitre
  • un robot ramasseur de balle


Nous devions être conscients de plusieurs choses :

  • Détecter la balle et les cages de buts (les deux émettant dans l'infrarouge)
  • Différencier ces deux derniers.
  • Détecter les limites du terrain (ruban adhésifs colorés)
  • Ne pas foncer dans les autres robots
  • S'orienter vers la bonne cage de but
  • Envoyer la balle vers le but
  • Se replacer

Détecter les limites du terrain semblait chose facile, mes les professeurs nous ont donné pour contraintes de devoir "garer" les robots lorsqu'ils ne jouent pas. Il a donc fallu créer un programme pour que les robots ne sortent pas du terrain. Un autre pour qu'ils effectuent un demi-tour lorsqu'ils rencontrent certaines bandes de couleurs. Et enfin un autre pour suivre une ligne et pour qu'ils se garent correctement.

Le plus grand challenge pour notre robot est de différencier la balle des buts! Tel qu'il est maintenant, notre programme ne nous permet pas cela ; le robot se dirigera automatiquement vers l'objet (émettant un signal infrarouge) le plus proche de lui...Ce qui est plutôt contraignant pour la phase de jeu. Nous devons donc collaborer avec les autres binômes pour trouver une solution !

Il a était question de deux options :

  • Premièrement : faire émettre aux cages de but et à la balle des signaux différents. Ainsi le robot devra chercher la balle selon la fréquence qu'elle émet et se concentrera seulement après sur les buts.
  • Deuxièmement : utiliser l'arbitre! En effet l'arbitre pourrait "demander" aux buts de s'éteindre tant que l'un des deux robots n'a pas attraper la balle. Il faudrait donc programmer le robot afin que lorsqu'il a la balle, il s'arrête et envoi un signal à l'arbitre pour lui confirmer que les buts peuvent fonctionner.


Conclusion

Pour ce bureau d'étude, nous avons choisie de réaliser un robot attrapeur. La conception de ce projet s'est déroulée en trois grandes étapes.

Tout d'abord, la construction d'un point de vue mécanique : Il a fallu construire un robot assez solide. Nous devions également trouver une place pour chacun des capteurs et avoir des pinces assez solides et capables de garder la balle en leur sein.

Ensuite, nous sommes passés à la programmation. Il s'agissait de la partie que nous appréhendions le plus! En effet s'il y avait des failles dans le programme, le robot ne serait jamais capable de réaliser un match.

Enfin, la dernière étapes a consisté à la création du terrain et à la réalisation des derniers tests. Il s'agissait avant tout d'être sur du bon fonctionnement du robot et de régler les derniers problèmes. (exemple : attacher les câbles entre eux pour qu'ils ne se coincent pas dans les chenilles)


Ce projet nous a avant tout permis d'avoir une première approche de ce que pourrait être le département IMA et de travailler dans des conditions d'ingénieur. En effet nous avons mené à bien un projet du début jusqu'à la fin en travaillant en toute autonomie en binôme, mais également en équipe. Il nous a fallu mettre en place des objectifs dès le début pour réaliser ce projet dans les meilleures conditions qui soient. Le BE IMA Foot nous aura donc beaucoup apporté jusqu'à la fin.

Voir Aussi

Lego Mindstorm

Lego Mindstorm NXT

HiTechnic Sensor Multiplexer

Cours Robot NXC

Guide NXC