Version du 28 mai 2015 à 18:48

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.

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 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é

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.