Version actuelle datée du 26 mai 2019 à 08:48

Objectif à atteindre

Dans ce bureau d'études, il nous est demandé de réaliser un robot dans une optique d'interaction chasseur-proie ; un robot (la proie) doit échapper à son poursuivant (le chasseur). Le robot doit être soit autonome, soit dirigé par une télécommande.

Nous sommes partis sur un robot prédateur autonome, car le frisson de la chasse est une sensation tellement ... irrésistible. Le nom du projet : Hunting Viper, ou la vipère chassante.

Le bureau d'étude peut se décomposer en 3 parties : une partie châssis, une autre électronique et une dernière programmation. La réalisation du châssis, le corps du robot, a été réalisé par Robin ; la seconde a été plus un travail collectif, tandis que la dernière fut exécutée par Alexandre (rédacteur principal du wiki).

Journal de bord

Entrée 1 : 14 janvier 2019

Au cours de cette séance, les encadrants nous ont expliqués les principales composantes de notre robot : la réalisation d'un châssis, la création d'une carte électronique et la programmation du mouvement de chasse. Pour notre projet, nous nous concentrerons sur la fabrication du cadre du robot par imprimante 3D. Pour les 2 dernières parties, nous utiliserons une carte Arduino, couplées à un bouclier de notre fabrication, pour réaliser les connexions entre les différents composants.

Entrée 2 : 31 janvier 2019

Durant cette séance, nous avons développé les premiers plans de notre machine ; nous sommes partis sur une reproduction d'un 4x4 de type exploration safari, souvent utilisé pour la chasse de bêtes exotiques.

Entrée 3 : 4 février 2019

Nous avons étudié l'architecture et la programmation de la carte Arduino afin de procéder à la gestion des capteurs nécessaires à l'évolution de notre prédateur dans son environnement.

• 

  Bouclier : schéma original

• 

  Bouclier : circuit imprimé original

Tout d'abord, nous avons téléchargé les fichiers présents sur le wiki, et étudié le bouclier du robot avec Fritzing. Nous avons aussi récupéré un robot pour "emprunter " ses pièces. Nous avons modélisé ces pièces pour les intégrer dans le plan 3D de la structure de notre robot.

Entrée 4 : 11 février

Robin a commencé la modélisation de certains composants pour notre robot, notamment les roues, la roue folle, les capteurs IR et ultrason, les servomoteurs et le modèle Arduino. Cette virtualisation permettra par la suite de modéliser une première version du châssis en 3D, afin de potentiellement le réaliser à l'aide d'une imprimante 3D. Nous avons continué l'étude du shield du robot. Nous avons ajouté un second capteur ultrason pour le déplacement, et 3 capteurs IR pour détecter la présence ou non de la proie.

• 

  L'ensemble des pièces vitualisées

• 

  Le cache pour les capteurs IR

Entrée 5 : 25 février

Au cours de cette séance, nous avons continué la prise en main de Fritzing et des plans du bouclier de notre robot ; cela nécessitera des optimisations dans les schémas, ce que l'on continuera à faire au cours des prochaines séances. Nous avons également commencé la prise en main des capteurs IR ; nous allons, la prochaine séance, tester le code pour maîtriser cette technologie.

Entrée 6 : 28 février

Après avoir (péniblement et avec l'aide des encadrants) réussi à récupérer la librairie de gestion des infrarouges, nous avons effectué quelques tests avec une télécommande. Nous avons constaté que, au moindre trou devant l'émetteur de rayons IR, le capteur annonçait des valeurs, et ce dans n'importe quelle direction ; les caches pour nos capteurs seront donc d'une grande utilité, afin de limiter le faisceau de vision de ces derniers. Il faudra également, à la prochaine séance, se renseigner sur la librairie pour savoir sur quel port on peut brancher le capteur, pour avoir plusieurs capteurs IR sur notre robot.

Entrée 7 : 4 mars

De nouveaux essais pour les capteurs IR fructueux ! Nous avons réussi à définir les ports Arduino qui permettent de capter un signal IR, en utilisant des ports avec interruptions externes. Nous avons utilisé une librairie issue de Adafruit (https://github.com/cyborg5/IRLib2), puis employé une fonction Rawrecv pour effectuer nos tests. Nous allons désormais nous consacrer à créer notre shield, en prenons en compte les différents éléments.

Entrée 8 : 7 mars

Après nos essais fructueux avec les capteurs infrarouges, nous avons essayé les détecteurs ultrason. Le code que nous avons récupéré fonctionne bien, et marche avec 2 capteurs. Mais dans une optique de robot chasseur, utiliser les ultrasons n'est pas une priorité ; en effet, il suffira à notre robot de suivre sa proie, qui doit elle éviter les obstacles. Ainsi, la maîtrise des capteurs ultrason n'est pas notre priorité. Les prochaines séances seront consacrés à la finalisation du circuit imprimé de la carte Arduino. Il faudra le réaliser vite, pour l'utiliser le plus tôt possible.

Entrée 9 : 11 mars

Au cours de cette séance, nous nous sommes concentrés sur le bouclier de notre robot. Il faudra le terminer pour la prochaine séance, et le faire corriger pour que l'on puisse l'obtenir avant la fin du BE. Robin a également, à l'aide du logiciel Fusion 360, gratuit pour les étudiants, réalisé la conception 3D des composants de notre robot.

• 

  Version initiale du Hunting Viper

Entrée 10 : 14 mars

Au cours de cette séance, nous avons complétement réorganisé les connexions sur notre shield. Malheureusement, nous n'avons pas pu terminé la carte à la fin de cette séance. Nous allons donc la finir au cours de la prochaine séance, pour qu'elle puisse nous parvenir avant la fin du Bureau d'étude.

Entrée 11 : 18 mars

Toujours sur le bouclier ; nous avons ajouté les LED de contrôle, afin de vérifier si le shield est bien connecté et l'Arduino bien alimenté (via les piles ou le câble de connexion ordinateur-carte) pour effectuer les tests sur les composants, un bouton et une LED IR pour que les proies puissent nous repérer pour tenter de nous échapper.

Entrée 12 : 21 mars

Nous avons (enfin !) terminé le bouclier pour notre robot, qui prendra en charge 2 moteurs et leur contrôleur, 6 capteurs infrarouge, 2 capteurs à ultrason, 2 LED de contrôle, une LED infrarouge, un bouton et un servomoteur (à l'origine pour contrôler la tourelle qui faisait tourner les capteurs IR). Pour la réalisation en elle-même, nous souderons les éléments que nous garderons pour la version finale de notre Hunting Viper. Robin a de son côté optimisé le châssis dans cette optique : les supports pour les capteurs à ultrason, ou bien le servomoteur sont présents, mais ne seront pas utilisés dans la version finale de notre robot.

• 

  Bouclier : schéma final

• 

  Bouclier : circuit imprimé final

Entrée 13 : 25 mars

J'ai commencé à étudier le code pour le robot, notamment la gestion des capteurs en lien avec les moteurs.

Entrée 14 : 28 mars

Nous nous sommes concentrés sur le code pour Hunting Viper ; c'est un travail de longue haleine, et qui ne pourra se concrétiser qu'à la réalisation du support du robot.

Entrée 15 : 1 avril

Robin a commencé les soudures de notre shield. J'ai étudié avec Nathan, élève d'un autre binôme, le code pour le robot.

Entrée 16 : 4 avril

Les soudures sont finies ; après vérification avec les enseignants, celles-ci semblent correctes. Cette séance ne fut guère productive ; le groupe a toujours été à moitié absent (CPP puis départ anticipé). Nous avons quand même réussi à avancer un peu sur le code.

Entrée 17 : 25 avril

Au cours de cette séance (double), nous avons pu déterminer un châssis de base pour le robot, et nous avons commencé à effectuer des tests pour la gestion de la librairie infrarouge avec les caches ; ces derniers sont très efficaces, les capteurs n'étant capable que de signaler un retour que dans une très fine bande, à la hauteur du capteur. Nous allons essayer ce code pour les 3 capteurs en simultané. Nous lancerons également la construction du châssis au cours de la prochaine séance.

Entrée 18 : 29 avril

Durant les essais, tripler le nombre de capteurs IR avec le code actuel ne semble pas fonctionner ; je reprendrais le code pour régler ce problème. De plus, il faudra également s'intéresser au code pour la gestion des moteurs ; car un robot qui capte, c'est bien, mais un robot qui roule en plus, c'est mieux !

Entrée 19 : 2 mai

Robin a dû recommencer le châssis ; celui en 3D prenant trop de temps en impression (30 heures), il faut désormais réaliser un châssis avec la découpeuse 3D X, présente dans le Fabricarium. De mon côté, j'ai essayé d'utiliser le code pour les IR avec 3 capteurs, malheureusement la librairie utilisée précédemment ne supportait pas d'utiliser 3 capteurs sur 3 ports Arduino différents ; je devrais donc choisir une autre librairie pour l'utiliser dans l'optique initiale.

Entrée 20 : 6 mai

L'heure de la réussite est enfin arrivée : j'ai trouvé une librairie (https://github.com/Neco777/Arduino-IRremote) qui permet de gérer 3 capteurs IR en même temps sur 3 broches différentes, et elle fonctionne ! Le code peut donc entrer dans sa phase finale : dès que le capteur du milieu réagit à une impulsion, le robot chargera dans sa direction ; dans le cas contraire, il tournera pour rechercher le signal. Couplé aux caches pour les capteurs, le robot aura donc une détection spatiale des infrarouges de précision. De son côté, Robin a modélisé un châssis en bois et lui a fait prendre forme. Malheureusement, ce dernier est trop petit, il faudra donc en réaliser un de plus grande taille.

• 

  Le châssis final assemblé, version 3D

Entrée 21 : 9 mai

Au cours de cette séance, Robin a réalisé le nouveau châssis en bois plus grand, en ayant pris en compte le problème de dimensionnement par rapport à la première impression de découpe bois ; il l'assemblera au cours de la séance suivante. De mon côté, j'ai terminé une première version du code ; il faudra le tester quand le robot sera assemblé.

• 

  Le châssis final assemblé

#include "IRremote.h"
#include "CppList.h"
#include <SparkFun_TB6612.h>
#define AIN1 36
#define BIN1 40
#define AIN2 34
#define BIN2 42
#define PWMA 6
#define PWMB 5
#define STBY 38
const int offsetA = 1;
const int offsetB = 1;
Motor motor1 = Motor(AIN1, AIN2, PWMA, offsetA, STBY);
Motor motor2 = Motor(BIN1, BIN2, PWMB, offsetB, STBY);
bool _initialized = false;
int rcv_count;
IRrecv **all_rcv;
void setup() {
  if (_initialized) return;  
  Serial.begin(9600);
  pinMode(A0,OUTPUT);
  rcv_count = 3;
  all_rcv = (IRrecv **)malloc(rcv_count*sizeof(int));
  all_rcv[0] = new IRrecv(4);
  all_rcv[1] = new IRrecv(3);
  all_rcv[2] = new IRrecv(18);
  for (int i=0; i<rcv_count; ++i){
    all_rcv[i]->enableIRIn();
  }
  _initialized = true;
}
void loop() {
  digitalWrite(A0,HIGH);
  for (int i=0; i<rcv_count; ++i){
    decode_results results;
    if (all_rcv[i]->decode(&results)) {
      if (i==1) {
      forward(motor1, motor2, 150);
      delay(1000);
      brake(motor1, motor2);
      int btn = DecodeButton(results.value);
      Serial.print("Rcv_");
      Serial.print(i);
      Serial.print(":");
      Serial.println(btn);
      all_rcv[1]->resume(); 
      }       
      else if (i==0) {
      left(motor1,motor2,100);
      delay(100);
      brake(motor1, motor2);
      int btn = DecodeButton(results.value);
      Serial.print("Rcv_");
      Serial.print(i);
      Serial.print(":");
      Serial.println(btn);
      all_rcv[0]->resume();
      }
     else {
     right(motor1,motor2,100);
     delay(1000);
     brake(motor1, motor2);
     int btn = DecodeButton(results.value);
     Serial.print("Rcv_");
     Serial.print(i);
     Serial.print(":");
     Serial.println(btn);
     all_rcv[2]->resume();
     }
   }
   else {
     right(motor1, motor2, 10);
     delay(1);
     brake(motor1, motor2);
   }
   }
 digitalWrite(A0,LOW);
 for (int i=0; i<rcv_count; ++i){
       all_rcv[i]->resume();
  }
  }
const int BTN_EMPTY = 0;
const int BTN_POWER = 99;
const int BTN_0 = 10;
const int BTN_1 = 1;
const int BTN_2 = 2;
const int BTN_3 = 3;
const int BTN_4 = 4;
const int BTN_5 = 5;
const int BTN_STOP = 6;
const int BTN_DOWN = 7;
const int BTN_UP = 8;
const int BTN_BACK = 9;
const int BTN_FWD = 11;
const int BTN_EQ = 12;
const int BTN_REPEAT = 100;
const int BTN_UNKNOWN = 101;
const int BTN_ERROR = 102;
int DecodeButton(unsigned long param){
  int rez = BTN_UNKNOWN;
  switch (param){
  case 0x0: {
            rez = BTN_ERROR;
            break;
        }
  case 0x00FD00FF:
  case 0x00FF728D:
  case 0x20DF4EB1: {
            rez = BTN_POWER;
            break;
           }
  case 0x00FD30CF:{
            rez = BTN_0;
            break;
          }
  case 0x00FD08F7:{
            rez = BTN_1;
            break;
          }
  case 0x00FD8877:{
            rez = BTN_2;
            break;
          }
  case 0x00FD48B7:{
            rez = BTN_3;
            break;
          }
  case 0x00FD28D7:{
            rez = BTN_4;
            break;
          }
  case 0x00FDA857:{
            rez = BTN_5;
            break;
          }
  case 0x00FD40BF:{
            rez = BTN_STOP;
            break;
          }
  case 0x00FD10EF:{
            rez = BTN_DOWN;
            break;
          }
  case 0x00FD50AF:{
            rez = BTN_UP;
            break;
          }
  case 0x00FD20DF:{
            rez = BTN_BACK;
            break;
          }
  case 0x00FD609F:{
            rez = BTN_FWD;
            break;
          }
  case 0x00FDB04F:{
            rez = BTN_EQ;
            break;
          }
  case 0xFFFFFFFF:{
            rez = BTN_REPEAT;
            break;
           }
   }
  return rez;
}

Entrée 22 : 16 mai

J'ai terminé un autre code semblable mais un peu différent ; le travail de vérification ne pourra se faire que quand le Hunting Viper aura pris forme.

#include "IRremote.h"
#include "CppList.h"
#include <SparkFun_TB6612.h> 
#define AIN1 36
#define BIN1 40
#define AIN2 34
#define BIN2 42
#define PWMA 6
#define PWMB 5
#define STBY 38
const int offsetA = 1;
const int offsetB = 1;
Motor motor1 = Motor(AIN1, AIN2, PWMA, offsetA, STBY);
Motor motor2 = Motor(BIN1, BIN2, PWMB, offsetB, STBY);
bool _initialized = false;
int rcv_count;
IRrecv **all_rcv;
void setup() {
  if (_initialized) return; 
  Serial.begin(9600);
  pinMode(A0,OUTPUT);
  rcv_count = 3;
  all_rcv = (IRrecv **)malloc(rcv_count*sizeof(int));
  all_rcv[0] = new IRrecv(4);
  all_rcv[1] = new IRrecv(3);
  all_rcv[2] = new IRrecv(18); 
  for (int i=0; i<rcv_count; ++i){
    all_rcv[i]->enableIRIn();
  }
  _initialized = true;
}
void loop() {
  digitalWrite(A0,HIGH);
  for(int i=0;i<rcv_count;i++){
        decode_results results;
    while(all_rcv[i]->decode(&results)) {
      if(i==1) {
      forward(motor1, motor2, 150);
      delay(500);
      digitalWrite(A0,LOW);
      int btn = DecodeButton(results.value);
      Serial.print("Rcv_");
      Serial.print(i);
      Serial.print(":");
      Serial.println(btn);
      all_rcv[1]->resume(); 
    }
    if (i==0) {
      left(motor1,motor2,100);
      delay(100);
      brake(motor1, motor2);
      int btn = DecodeButton(results.value);
      digitalWrite(A0,LOW);
      Serial.print("Rcv_");
      Serial.print(i);
      Serial.print(":");
      Serial.println(btn);
      all_rcv[0]->resume();
      }
    else {
      right(motor1,motor2,100);
      delay(100);
      brake(motor1, motor2);
      digitalWrite(A0,LOW);
      int btn = DecodeButton(results.value);
      Serial.print("Rcv_");
      Serial.print(i);
      Serial.print(":");
      Serial.println(btn);
      all_rcv[2]->resume();
      }
    }
      else {
        right(motor1, motor2, 10);
        delay(1);
        brake(motor1, motor2);
        for (int i=0; i<rcv_count; ++i){
          all_rcv[i]->resume();
            }
      }
}
} 
const int BTN_EMPTY = 0;
const int BTN_POWER = 99;
const int BTN_0 = 10;
const int BTN_1 = 1;
const int BTN_2 = 2;
const int BTN_3 = 3;
const int BTN_4 = 4;
const int BTN_5 = 5;
const int BTN_STOP = 6;
const int BTN_DOWN = 7;
const int BTN_UP = 8;
const int BTN_BACK = 9;
const int BTN_FWD = 11;
const int BTN_EQ = 12;
const int BTN_REPEAT = 100;
const int BTN_UNKNOWN = 101;
const int BTN_ERROR = 102; 
int DecodeButton(unsigned long param){
  int rez = BTN_UNKNOWN;
  switch (param){
  case 0x0: {
            rez = BTN_ERROR;
            break;
        }
  case 0x00FD00FF:
  case 0x00FF728D:
  case 0x20DF4EB1: {
            rez = BTN_POWER;
            break;
           }
  case 0x00FD30CF:{
            rez = BTN_0;
            break;
          }
  case 0x00FD08F7:{
            rez = BTN_1;
            break;
          }
  case 0x00FD8877:{
            rez = BTN_2;
            break;
          }
  case 0x00FD48B7:{
            rez = BTN_3;
            break;
          }
  case 0x00FD28D7:{
            rez = BTN_4;
            break;
          }
  case 0x00FDA857:{
            rez = BTN_5;
            break;
          }
  case 0x00FD40BF:{
            rez = BTN_STOP;
            break;
          }
  case 0x00FD10EF:{
            rez = BTN_DOWN;
            break;
          }
  case 0x00FD50AF:{
            rez = BTN_UP;
            break;
          }
  case 0x00FD20DF:{
            rez = BTN_BACK;
            break;
          }
  case 0x00FD609F:{
            rez = BTN_FWD;
            break;
          }
  case 0x00FDB04F:{
            rez = BTN_EQ;
            break;
          }
  case 0xFFFFFFFF:{
            rez = BTN_REPEAT;
            break;
           }
   }
  return rez;
}

Entrée 23 (finale) : 23 mai

Cette dernière séance est consacrée à la finalisation du Hunting Viper et du wiki associé.

Première image : la face avant

Robot assemblé - Le besoin de tourelle utilisant un servomoteur a été revu pour remplacer le servomoteur par le déplacement du robot lui-même, évitant de rajouter un surplus de composants pour un rendu équivalent. Le tri-cache permet de détecter l'orientation exacte de la proie par rapport au robot. (Si celle-ci n'est pas détectée, le robot tournera afin de savoir ci celui ci est à gauche, ou à droite grâce aux capteurs IR d'angle.)

Deuxième image : la face arrière

Les troues de "ventilations" sont utilisés afin de permettre de facilement sortir et rentrer les câbles du châssis. La grille arrière est amovible et permet d'accéder aux piles, ou de passer le câble Arduino sans la retirer.

Troisième image : la face avant ouverte

Le châssis a été réalisé pour être bien sectorisé: le première étage contenant les moteurs à l'avant, et les piles à l'arrière, les fils passant par une fente de la plaque de bois soutenant le second étage. Le second étage contient, quant à lui, la carte Arduino et se voit fermé par deux "couvercles" en bois afin de cacher celle-ci. Le couvercle avant supporte les capteurs IR avec caches pour les orienter. La carte Arduino, les piles et les moteurs on étaient fixés à l'aide de colliers qui se ferment via les trous prévus à cet effets. Le tout était stable.

Quatrième image : la face arrière ouverte

Ici nous voyons la fixation des piles et le support à bille de l'arrière. Le robot comporte donc deux roues motrices et un roulement à bille. De plus gros moteurs ont étés choisis afin d'obtenir une vitesse plus importante que la proie qui lui utilise des servomoteurs. Et la bille permet d'équilibrer parfaitement le tout.

• 

  Face Avant

• 

  Face Arrière

• 

  Face Avant ouverte

• 

  Face Arrières ouverte

Malheureusement, nous n'avons pas pu terminer le Hunting Viper ; en effet, un bug mystérieux ne faisait tourner qu'un seul moteur sur les deux. Avec l'aide précieuse de nos encadrants, nous avons passé un temps (très important) à vérifier de nombreux points dans le fonctionnement de notre robot : le code (changé 3 fois), la carte Arduino, le contrôleur de moteur, le bouclier et le PCB. C'est sur ces 2 éléments que les problèmes ont été découverts. Concernant le shield, une soudure semblait un peu plus fragile que les autres ; nous en avons profité pour un refaire quelque unes. Là où le problème se concentrait était sur le PCB : les ports de la carte Arduino ont été mal numérotés dans le fichier Fritzing ; ainsi, les correspondances spatiales bouclier-carte Arduino étaient bonnes, mais lors de la production du code, les associations des ports avec leur utilisation étaient fausses, rendant la transmission d'informations impossibles entre les différents composants. Quand nous avons résolu ce problème, nous n'avons pas eu la possibilité de faire la vidéo associée à ce wiki. Ainsi, il comportera tous les détails nécessaire à la bonne représentation du projet. C'est ainsi que nous pouvons conclure que, malgré de très nombreuses difficultés, le projet a plutôt été mené à bien.

Avis et conclusion sur le Bureau d'Etude IMA-2

Alexandre

Ce Bureau d'Etude m'a permis de m'investir dans un grand projet, et de m'approprier des connaissances dans plusieurs domaines, et ce dans le cadre d'une utilisation directe. De plus, Même si je ne souhaite pas intégrer le département d'IMA de Lille, cela m'a donné une idée du travail que l'on peut faire en tant qu'ingénieur. Ce bureau d'études m'a permis d'apprendre, sans vraiment m'en rendre compte ; en plus, il s'agit de choses tout à fait inédite, que je n'aurais pas forcément appris en autodidacte. Le BE m'a également conforté dans mon choix de départment (Polytech Sorbonne, département Robotique) ; en effet, l'un des points forts de la robotique est sa polyvalence, ce que j'apprécie particulièrement.

Robin

Ce Bureau d'Etude a été une opportunité pour moi de m'introduire à l'IMA. Etant la spécialité que je vise depuis un certain nombre d'années, j'ai été particulièrement ravi de pouvoir participer à ce Bureau d'Etude, et de plus, avec des camarades travailleurs, investis et ouverts à tout types de suggestions. De nombreux domaines ont étés abordés durant ce BE: informatique, hardware, conception 3D, réflexion à des problématiques techniques et de design. Nous sommes ainsi passés par une bonne partie des étapes que nous pourrions trouver dans un Bureau d'étude tel que l'observation de ce qui a été précédemment réalisés, les bases vitales dans l'élaboration du projet et les innovations que nous pourrions faire via nos propres connaissances. Nous avons ainsi conçu d'abord les plans du projet, le design général, le PCB pour l'impression du Shield et la programmation du robot via les différents composants et l'interface Arduino. J'ai été chargé pour ma part de la partie "Hardware" qui regroupe principalement la création du PCB et donc du Shield, ainsi que celle du châssis du Robot et de la disposition des composants. J'ai pris en compétence sur l'utilisation du logiciel Fritzing afin de créer le PCB et l'utilisation de Fusion 360 pour l'élaboration du châssis d'abord en 3D puis en Bois. J'ai appris à me servir de nouveaux outils tel que la découpeuse laser. Et le faire en autodidacte, avec l'aide précieuse des encadrants, m'a été grandement enrichissant.

J'ai pris du plaisir durant ce BE, et espère pouvoir participer de nouveau à ce type de projet. Dans l'espoir d'intégrer IMA l'année prochaine.

Conclusion

Ce Bureau d'Etude a été un gain très important de connaissances et de réalisations pratiques dans plusieurs domaines. Il nous a permis de se projeter, durant plus de 40 heures, dans un travail d'ingénieur, et plus précisément dans le domaine de la robotique. L'un des points auquel nous aurions pu prêter plus attention est la vérification, à chaque étape, de l'élément que l'on vient de réaliser ; ainsi, certains problèmes que l'on a rencontré tard dans le BE auraient pu être régler plus tôt dans notre avancement.