Version actuelle datée du 29 mai 2015 à 14:29

Introduction

Notre projet est de concevoir une cage capable d'interagir avec les autres robots et avec l'arbitre.
Cette cage devra :

• émettre un signal infra-rouge discontinu
  
• detecter lorsque la balle rentre et le signaler à l'arbitre
  
• Puis éjecter la balle

élaboration des mécanismes de la cage

le matériel

Nous avons décidé de commencer l'élaboration du but par les différents mécanismes qui vont le composer, il nous fallait un mécanisme pour retenir la balle et un autre pour l'éjecter de la cage.

Nous avons d'abord construit le mécanisme permettant de retenir la balle en utilisant des Lego Mindstorm avec deux servomoteurs, tout simplement en créant deux bras qui se fermeront lorsque la balle rentrera dans le but, notre système permet aussi de repousser la balle au fond du but.
En choisissant la taille du mécanisme, cela nous a permis de décider de la taille du but, à la base le mécanisme couvrait une largeur de 25 cm, nous avons alors décidés de l'agrandir pour couvrir une largeur de 40 cm, qui correspondait mieux par rapport à la taille du terrain et de la balle.

Cependant, quelque semaine plus tard, nous avions de nouvelles contraintes qui nous ont obligé à changer de forme de mécanisme.
Cette contrainte est : les robots se garent à coté des cages de but.
Notre premier système s'ouvre verticalement, donc gêne les robots pour se garer. Nous sommes donc passé de bras qui s'actionner horizontalement à un système vertical.
Composé de 2 servo-moteur et d'une structure en lego les reliant, le système bloque la balle et la repousse contre le système qui permet d'ejecter la balle.

Ensuite, toujours en Lego Mindstorm, nous avons assemblé le mécanisme permettant d'éjecter la balle, il sera fixé au fond de la cage de but, en hauteur. Lorsque la balle rentrera dans le but, elle sera repoussé contre ce mécanisme qui la repoussera avec une force suffisante pour la faire sortir du but quand l'ordre sera donné par l'arbitre.

Finalement nous avons choisis le capteur qui fera réagir les mécanismes, nous avons utilisé un capteur à ultrasons qui permet de mesurer la distance à un objet pour repérer le passage de la balle.

la programmation

• Pour trouver comment programmer les bras en Langage NxC, nous avons effectuer quelques tests avec des fonctions simples. Tout d'abord nous avons essayer de faire bouger les bras sans aucun capteur pour évaluer la vitesse, la force et la position des bras, ensuite nous avons ajouté un capteur simple à utiliser : le capteur de contact, afin de fermer les bras avec une pression sur le capteur.
  

• Ensuite, nous avons ajouté le capteur à ultrasons, avec le programme que nous avions écrit pour les premiers tests, nous avons d'abord paramétré le capteur, c'est à dire que nous avons définit la distance à laquelle il réagit, distance qui correspond à un peu moins que la largeur de la cage de but.
  

• A ce point, notre programme fesait bouger les bras dès qu'un objet passait devant le capteur, ce qui posait problème si la balle rebondissait contre la cage et repassait devant le capteur.

Nous avons modifié le programme pour que les bras ne se ferment qu'une seule fois après le passage de la balle et ne s'ouvrent qu'après le signal donné par l'arbitre, en même temps que le bras éjectant la balle.

Le programme qui intéragit avec l'arbitre :

 #define NEAR 40 //cm
 #define CODE_REQTYPE            0 // demander le type de l'acteur
 #define CODE_EJECTER            1 // ordonne l'éjection de la balle
 #define TYPE_BUT                0
 #define CODE_BUT                3 // un but est marqué
 #define MAILBOX_BUT             1
 #define MAILBOX_ARBITRE         2 
 // on définit la distance jusque laquelle le capteur peut apercevoir la balle et les paramètres pour communiquer avec le but.
 

 int but=0;

 sub ball_gate()  // tache servant à bloquer la balle dans le but
 {  SetSensorLowspeed(IN_1);
   while (but==0)
    {
    if (SensorUS(IN_1)<=NEAR)
     {
       OnFwd(OUT_AB, -60); 
       Wait(440);
       Off(OUT_AB);
       but++;
     }
    }  
 }

 sub eject()   // tache éjectant la balle 
 {
   ONfwd(OUT_AB, 60);
   Wait(440);
   Off(OUT_AB);
   ONfwd(OUT_C, 75);
   Wait(440);
   Off(OUT_C);
   but=0;
   ONfwd(OUT_C, 75);
   Wait(440);
   Off(OUT_C);
 }

 task main()
 {
 int result;
 string buffer;
 while (true)
 {
   result=ReceiveMessage(MAILBOX_BUT,true,buffer); // on regarde si le but reçoit un message
   if(result==0)
     {
     int requete=StrToNum(buffer);
     if(requete==CODE_REQTYPE) // on regarde si la requete est de donner son type à l'arbitre ( est-on un ramasseur, un joueur ou la cage).
       {
       string type;
       type=NumToStr(TYPE_BUT); // on dit qu'on est un but
       SendMessage(MAILBOX_ARBITRE+10,type); // on envoie le message à l'arbitre
       }
     }
   if(but==1)
   { 
      string type;
       type=NumToStr(CODE_BUT); // il y a un but
       SendMessage(MAILBOX_ARBITRE+10,type); // on envoie le message à l'arbitre
    }
       result=ReceiveMessage(MAILBOX_BUT,true,buffer); // l'arbitre demande l'ejection de la balle
       int requete=StrToNum(buffer);
       if (requete==CODE_EJECTER )
         {
        eject(); // ici, on ejecte
        but = 0 ;
        }
    ball_gate() ; // ici, on attend la balle et on la bloque en cas de but
   } // et on recommence jusqu'à tant qu'on ne coupe pas le circuit.
 }

Le signal infrarouge

le circuit

Nous avons commencé par fabriquer un circuit "brouillon" afin de pouvoir le tester avec différents programme, nous avons suivis un tutoriel sur internet pour composer un circuit permettant d'émettre un signal infrarouge controlé par un microcontroleur programmable, en plus de ce qui était indiqué sur le tutoriel, nous avons rajouté un bouton et une LED rouge pour pouvoir modifier la fréquence de clignotement des LED infrarouge à la main à tout moment, sans changer le programme à chaque fois.

les composants utiles pour la programmation et pour tester le circuit sont :

• Une LED verte pour vérifier que le circuit est alimenté.
  
• Le microcontroleur.
  
• Un bouton.
  
• Une LED rouge.
  
• 4 LED infrarouge.
  

La programmation

• Au début, nous n'avions pas à disposition le programmateur du microcontroleur, pour tester nos programmes, nous avons remplacés le microcontroleur par une carte Arduino, qui se programme de la même façon.
  

• Nous avons commencé par écrire un programme permettant de faire alterner les clignotement de la LED rouge et des LED infrarouges en utilisant une simple boucle infinies, le clignotement était régulier et ne changeait jamais, cela ne suffisait donc pas.
  

• Nous avons ensuite rajouté l'utilisation du bouton dans la programmation, tout d'abord avec quelques programmes pour le tester : en appuyant sur le bouton les LED s'allumaient, en rappuyant elles s'éteignaient et ainsi de suite. Ensuite dans notre programme principal, nous avons fais en sorte que le clignotement s'arrète lorsque l'on appuie sur le bouton afin de pouvoir programmer le clignotement à la main : en appuyant X fois sur le bouton puis en appuyant dessus pendant 3 secondes, les LED clignotent avec une fréquence de X secondes.
  

• Cependant, l'utilisation du bouton n'était pas très évidente pour les personnes ne connaissant pas le programme, nous avons donc essayé de le rendre plus ergonomique en utilisant la LED rouge. Nous avons donc modifié notre programme pour que la LED rouge clignote rapidement lorsque le programme est réinitialisé et prêt à enregistrer le nombre de pression sur le bouton, la LED rouge clignote à chaque pression sur le bouton puis clignote avant que les LED infrarouges ne s'allument.
  

 /* initialisation des ports du micro-controleur */
 int LED_PIN = 2;
 int IR = 1;
 int BOUTON = 0;
 /* initialisation de la chaine de caractères permettant de lancer la fonction de clignotement*/
 char *st_pr;
 /* variable permettant de compter le nombre de clics */
 int compt = 0;
 /* variable permettant de connaitre le temps actuel du programme (start = millis) */
 long start;
 /* setup permettant de communiquer avec le micro-controleur et les composants du circuit */
 void setup() 
 { 
 pinMode(BOUTON, INPUT_PULLUP);
 pinMode(LED_PIN, OUTPUT); 
 pinMode(IR, OUTPUT);  
 }
 /* fonction principal */    
 void tpsclignotement()
 {
 /* on allume la led pour signaler que le programme est lancé */
 digitalWrite(LED_PIN,LOW);
 /* 
 dans cette fonction, il y a 3 boucles :
 la boucle permettant d'initialiser le temps de clignotement par rapport aux clics (fonction 1)
 la boucle qui contient la fonction 2 qui fait clignoter les led
 la bouble permettant de passer d ela fonction 2 à la fonction 1
 */ 
 while (st_pr != "start")
   {
     delay(500);
 /* si on appuie sur le bouton */
     if (digitalRead(BOUTON)==LOW)
        { 
          start = millis();
 /* on compte chaque clic */
          compt = compt + 1;
 /* on signale que le clic a été pris en compte en clignotant la led */
          digitalWrite(LED_PIN,HIGH);
          delay(100);
          digitalWrite(LED_PIN,LOW);
 /* tant qu'on laisse appuyer, on ne sort pas de cette condition comme cela on ne compte qu'une fois un clic */
            while (digitalRead(BOUTON)==LOW)
              { 
                if (millis()-start >= 3000) /* on attends 3 secondes avec le bouton enfoncé*/
                   {
                     digitalWrite(LED_PIN,HIGH); /* on éteint pour prévenir que la fonction 2 va se lancer */
                     st_pr = "start";
                     delay(1000);
                   }
        
               }
          }
       }
 /*on a mis st_pr sur "start" donc on arrive sur les 2 autres boucles */
 /* la deuxième boucle (sur les 3) fait clignoter les led*/
 /* la troisième boucle permet de réinitialiser et de modifier le temps de clignotement */
 while ((st_pr == "start") && (digitalRead(BOUTON)==HIGH))
    {
      digitalWrite(LED_PIN,LOW);
      delay( compt * 1000 );
      digitalWrite(LED_PIN,HIGH);
      tone(IR, 1200, 1000 * compt);
      delay( compt * 1000 ); /* les led s'allument (le nombre de clics) secondes et s'éteignent pendant la même durée*/
     }
  while ((st_pr=="start") && (digitalRead(BOUTON)==LOW))
        { 
          st_pr = "off"; /* grâce à ça, on passe de la fonction 2 à la fonction 1 */
          compt=0; /* on remet à zero, le compteur de clics, permettant de modifier le temps de clignotement*/
 /* on fait clignoter très vite les led pour signaler le passage entre la fontion 2 et la fonction 1 */
          digitalWrite(LED_PIN,LOW);
          delay(100);
          digitalWrite(LED_PIN,HIGH);
          delay(100);
          digitalWrite(LED_PIN,LOW);
          delay(100);
          digitalWrite(LED_PIN,HIGH);
          delay(100);
        } 
 }

 /* la fonction tourne dans une boucle infini */
 void loop() 
 {
 tpsclignotement();
   }

Le circuit imprimé

Nous avons pris comme base le dessin réalisé par le groupe 1 avec l'aide d'élèves d'IMA 5 avec pour objectif de le modifier afin de pouvoir mettre en pause le circuit manuellement, par une intervention de l'arbitre.
Nous nous servi du logiciel eagle pour concevoir la plaque du circuit.

A ceux-ci, on a rajouter un transistor et un interrupteur qui permet d'éteindre ou non les led IR pour qu'il n'y ait pas de conflits de communication entre les ramasseurs et la balles.
Avec l'aide d'un professeur, on a pu terminer la plaque car il fallait changer la bibliothèque des éléments composant notre circuit.
On a donc envoyé notre schéma pour réaliser la plaque.

Une fois, la plaque en main, nous avons pu commencer à souder. Une de nos composantes a du être soudé à l'envers car il y a eu une erreur au moment de la conception : Les pattes du microcontroleur ne correspondait pas aux éléments auxquelles elle étaient rattachés par le circuit, si on le mettait ce sens.
Lorque l'on a fini de souder, on s'est rendu compte de certaines anomalies. Le circuit ne fonctionnait pas. Nous avons cherchait à l'aide d'un voltmètre pour savoir d'où venait le ou les problème et on s'est rendu compte que la masse était coupé en 2. Nous avons, donc, décidé de percer un trou sur les 2 parties de la masse pour y souder un fil. Ce fil permet de faire la connexion entre les deux parties.

Cette fois, la led verte et la led rouge s'allument. Ce qui signifie que l'on a réglé le problème. Cependant, lorsque l'on lance le programme, les led IR ne fonctionnent pas. Comme notre programme a été testé avant sur arduino, le problème se trouve sur le circuit. Nous avons encore cherché le problème et on s'est rendu compte que le problème venait des transistors. Conseillé par un professeur nous avons regardé sur internet comment fonctionnait le transistor en question et nous nous sommes rendu compte que le schéma sur eagle était erroné et qu'il fallait retourné les 2 transistors. Cette fois si notre circuit fonctionne.

La construction

La cage a pour surface intérieur 40 cm x 20 cm. Nous avons, tout d'abord, fait un schéma sur papier.
Pour la fabrication de notre cage, il nous a fallu 2 tasseaux de sapin (0.19 m x 0.19 m x 2.40 m) et une plaque en contreplaqué.
Avec les tasseaux, on a coupé à la scie-sauteuse 8 bâtons de 20 cm et 3 de 40 cm (soit au total 2m80 de tasseaux).
Au départ, on a essayé de fixer le but avec des vis, cependant le bois ne l'a pas supporter et s'est fendu. Par la suite, on a décidé de fixer le but à l'aide de colle "ni clou ni vis". On a tout d'abord formé un pavé (40 cm x 20 cm * 18 cm intérieur) puis on a placé la plaque, découpé à la scie-sauteuse au préalable, sur le dessus, fixée à l'aide de clou. Nous avons ajouter 2 baton à l'intérieur du but permettant à la balle de se diriger vers le bras ejecteur.
Puis, on a fait des petits système avec les legos qui permette de fixer les éléments sur la plaque. On a posé les legos à l'endroit où ils sont censé être et on a fait des marques sur la plaque qui ont permis de percer des trous dans la plaque (perçeuse).

On peut, maintenant, fixé les éléments sur la plaque en visant les éléments sur la plaque. Pour la brique nxt et les servo-moteur qui servent à bloquer la balle, il suffit de mettre des legos, fixés à ceux-ci, avec face à la plaque. Par contre, pour l'autre servo-moteur, on a du percer un trou pour laisser passer le fil de connexion avec la brique nxt car il est attaché sous la plaque. Et, pour le capteur ultrason, on a dû ajouter une plaque de la taille du capteur pour pouvoir la poser à coté d'un poteau. Cette plaque est aussi fixé à l'aide de clous.

servo-moteur bloqueur------------------------------------------------servo-moteur ejecteur-----------------------------------------------capteur ultrason-------------------------------------------------------------brique nxt

Conclusion

Malgrè les contraintes et les problèmes survenus aux cours de notre parcours, nous sommes parvenus à réaliser la cage de but en respectant le cahier des charges.

Cela nous a permis :

• d'apprendre à coder sur nxc (langage C spécifique aux lego mindstorm)
• d'utiliser et comprendre l'arduino
• d'être autonome, de chercher soi-même les information, de comprendre par soi-même les fonctionnements de chaque logiciel.
• de concevoir un structure (ici, le support en bois de la cage)
• de concevoir un circuit imprimé (avec eagle)
• de travailler en équipe, de communiquer entre groupe (communication avec les groupes de joueur ou de ramasseur)

Ce Bureau d'étude est très enrichissant et permet de mettre en pratique ce que l'on apprend théoriquement.