Version du 28 mai 2015 à 14:52

Introduction

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

• emettre un signal infra-rouge discontinu
  
• detecter lorsque la balle rentre et le signaler à l'arbitre
  
• Puis ejecter 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.

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 signal infrarouge

le circuit

Nous avons commencer 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é

Notre circuit actuel étant un brouillon, il fallait donc réaliser un circuit imprimé, tout d'abord en le dessinant à l'aide d'un logiciel. 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.