Version actuelle datée du 4 octobre 2019 à 16:58

Projet TANK

Le sujet de cette saison 2018/2019 est celui des robots proies/chasseurs. Il est important de notifié les différences entre les deux types de robots, le robot proie et un robot muni d'un émetteur de rayons infrarouge permettant au chasseur de capter la proie ainsi d'un détecteur de distance pour lui permettre de fuir. Le robot proie est lui aussi muni d'un capteur de distance pour éviter les obstacles et aussi de capteur infra rouge pour chasser le robot.

On remarquera que dans la plupart des cas les chasseurs sont plus lourds que les proies et vont donc avoir besoin de moteurs plus puissant pour fonctionner au mieux. Nous avons choisi de partir sur le modèle chasseur et comme les tanks c'est cool, on s'en est inspiré pour fabriquer notre robot.

On a pu récupérer le cadavre d'un ancien robot pour prendre les différents éléments que nous pourrons utiliser pour notre tank, c'est ainsi que nous avons commencé à imaginer comment on allait réaliser notre robot.

Première partie: Conception/Premières idées

Cette partie concerne comme son nom l'indique, la conception globale du robot, choix des procédés ...

Le choix du genre de robot ne fut pas bien compliqué, nous étions tout les deux d'accord pour partir sur le modèle chasseur. Après avoir pu observer les différents modèles existants des années précédentes, nous avons constaté que le système de déplacement étaient redondant et dans une optique d'innovation nous avons choisi de faire déplacer notre robot à l'aide de chenilles. Les chenilles étant caractéristiques des chars, nous avons commencer à dessiner des premières formes de robots ressemblant donc à ces derniers. Nous avons prévu que notre robot fonctionnerait grâce à une carte arduino uno, ce qui implique de programmer notre robot en langage C. On a choisi de réaliser le lien entre notre carte arduino et les autres éléments du robot par un shield que l'on confectionnera de nous mêmes grâce au logiciel Freetzing.

Premier schéma de notre robot

Deuxième partie : Dessins de l'ossature du tank

Cette deuxième partie concerne le plan de l'ossature de notre robot. Nous avons décidé de partir sur une structure en trois étage de couches de plexiglas.Pour réaliser ces plans, nous avons utilisé le logiciel Inkscape qui est un format adaptée à la découpeuse laser de l'école. On a choisi de placer les moteurs sous la plaque inférieur, à la base nous étions parti sur l'idée de prévoir des fixations avec des vis mais nous sommes partis sur la colle chaude qui est largement suffisant vis a vis du jeu que va prendre le robot durant son état de marche. Nous avons tracer de chaque côté de cette dernière trois trous pour venir créer des fixations pour les roues non-motrices. Nous avons organisé la plan de sorte à ce que le boîtier de piles ce retrouve coincé entre les deux plaques inférieures et encadrés par trois petites plaques de plexi. On remarquera que le nous avons tout de même fait un trou similaire à ceux pour les petites plaques pour pouvoir laisser passer les fils des moteurs. La deuxième plaque possède la même forme que celle inférieure, elle présente néanmoins les différents trous pour pouvoir accueillir notre arduino uno. La plaque supérieure était initialement prévu pour recouvrir la deuxième plaque mais nous avons décidé durant le montage de ne pas venir la mettre pour des raisons esthétique, de plus, le rendement en terme de protection était faible.

Plaque inférieur dans le logiciel inkscape

Plaque médiane dans le logiciel inkscape

Plaque supérieur dans le logiciel inkscape

Troisième partie: Réalisation de la schematic de notre shield

Le shield est l'élément qui va permettre de faire le lien entre les différents éléments de notre robot et notre carte arduino, nous avons donc du adapter ce shield en fonction de la taille et des entrées que la carte présentent. Grâce au logiciel Fritzing nous avons pu importer un fichier correspondant à un schéma de l'arduino, nous nous en sommes servi pour dessiner les différents réseaux électriques. Il a fallu faire attention à de nombreuses choses comme par exemple éviter de se faire chevaucher deux branches ou encore faire attention aux différents trous ou nous allions venir brancher les différents composants. Cela a représenté une complexité étant donné que les pièces de notre robot ont toutes un système de fonctionnement différent les unes par rapport aux autres. Par exemple les moteurs nécessitent deux valeur, l'une digitale et l'autre analogique, la première pour savoir dans quelle sens la rotation va se faire et la deuxième pour régler la vitesse de rotation de la branche du moteur, ces paramètres sont primordiaux étant donné que les ports de la carte arduino peuvent soit envoyer soit lire une donnée, le type de donnée (digitale ou analogue) est aussi très important car un port ne peut recevoir que l'une des deux citées auparavant.

Capture d'écran de notre shield sur le logiciel fritzing

Vue schematic de notre shield

Quatrième partie : Création d'un adaptateur entre les moteurs et les roues

Etant donné que nous sommes parti sur un système de chenille, il a fallu créer un adaptateur entre les roues livrées avec le kit et les moteurs. Pour se faire nous avons utilisé le logiciel FreeCAD pour réaliser le plan et nous avons directement imprimé sur les imprimantes 3D à notre disposition. Bien que nous ayons fait attention à garder de la marge par rapport aux dimensions de la pièce dont nous allions avoir besoin, les imprécisions liées à l'imprimante 3D se font fait sentir et il fallut modifier à la main nos adaptateurs. Pour se faire nous avons fait chauffer un morceau de métal puis nous l'avons approché de l'encoche de nous adaptateurs afin de ramollir le plastique et ainsi pouvoir venir les fixer facilement sur nos moteurs.

Modèlisation 3D de notre adaptateur dans le logiciel freeCAD

Imprimante 3D du Fabricarium

Cinquième partie : Découpe des plaques au Fabricarium à la découpeuse laser

Ainsi est venu le moment d'imprimer l'ossature de notre robot, se fut l'occasion pour nous de découvrir ce qu'était le fabricarium et cela nous a vraiment beaucoup plus. Nous avons été accueilli par un responsable du fab pour suivre la formation de la découpeuse laser. Suite à cela nous avons du pratiqué de suite la découpe de nos plaques de plexi et nous avons été confronté à certaines difficultés liées aux paramètres de la découpeuse, chaque matériaux doit être découpées avec des paramètres bien précis pour éviter de l'abîmé ou qu'il prenne feu au moment de la découpe.

Découpeuse laser du Fabricarium ainsi que son système de refroidissement

Sixième partie : Code de notre robot

demo robot

int dist = A0;//capteur distance
int capt_g = A1; //detecteur infrarouge gauche
int capt_d = A3; // --  --  --  --  --  droit
int capt_c = A2; // --  --   de capture
int vit_g = 11; //vitesse de rotation du moteur gauche
int vit_d = 5; // -- --  --  --  --  --  --  - droit
int av_g = 9; // moteur gauche avance
int ar_g = 10; // --  --  --  - recule
int av_d = 7; // moteur droit avance
int ar_d = 6;// --  --  --   recule
int standby = 8;
int demande_distance = 2;
int mur = 1000;
const unsigned long MEASURE_TIMEOUT = 25000UL;
int mesure_distance();
void forward();
void rotate_right();
void rotate_left();
void turn_left();
void turn_right();

 

void setup() {
   // initialize serial communication at 9600 bits per second:
 Serial.begin(115200);
 pinMode(demande_distance,OUTPUT);
 pinMode(dist,INPUT);
 pinMode(vit_g,OUTPUT);
 pinMode(vit_d,OUTPUT);
 pinMode(av_g,OUTPUT);
 pinMode(av_d,OUTPUT);
 pinMode(ar_g,OUTPUT);
 pinMode(ar_d,OUTPUT);
 pinMode(standby,OUTPUT);
 }

void loop() {
 digitalWrite(standby,1);
  
 //int distance = mesure_distance();
 //if (distance>mur) {
   forward();
   delay(2000);
   turn_left();
   delay(2000);
   rotate_right();
   delay(2000);
   forward();
   delay(2000);
   turn_right();
   delay(2000);
   rotate_left();
   delay(6000);
 //  }
 //else {
 //  rotate_left();
 //  delay(500);
 //}
 delay(1);
}

void rotate_right() {
 analogWrite(vit_g,100);
 digitalWrite(av_g,1);
 digitalWrite(ar_g,0);
 analogWrite(vit_d,100);
 digitalWrite(av_d,0);
 digitalWrite(ar_d,1);
 
}

void rotate_left() {
 analogWrite(vit_g,100);
 digitalWrite(av_g,0);
 digitalWrite(ar_g,1);
 analogWrite(vit_d,100);
 digitalWrite(av_d,1);
 digitalWrite(ar_d,0); 
} 

void turn_left() {
 analogWrite(vit_g,100);
 digitalWrite(av_g,1);
 digitalWrite(ar_g,0);
 analogWrite(vit_d,200);
 digitalWrite(av_d,1);
 digitalWrite(ar_d,0);
}
  
void turn_right() {
 analogWrite(vit_g,200);
 digitalWrite(av_g,1);
 digitalWrite(ar_g,0);
 analogWrite(vit_d,100);
 digitalWrite(av_d,1);
 digitalWrite(ar_d,0);
}

void forward() {
 analogWrite(vit_g,100);
 digitalWrite(av_g,1);
 digitalWrite(ar_g,0);
 analogWrite(vit_d,100);
 digitalWrite(av_d,1);
 digitalWrite(ar_d,0);
}

int mesure_distance() {
 digitalWrite(demande_distance,1);
 long distance= pulseIn(dist, HIGH, MEASURE_TIMEOUT);
 delay(10);
 digitalWrite(demande_distance,0);
 Serial.println(distance);
 return distance;
}

test ultrasons

const unsigned long MEASURE_TIMEOUT = 25000UL; // 25ms = ~8m à 340m/s

void setup() {
  Serial.begin(115200); 
  pinMode(2,OUTPUT);
  pinMode(A0,INPUT);
}

void loop() {
   digitalWrite(2,1);
   long distance= pulseIn(A0, HIGH, MEASURE_TIMEOUT);
   delay(10);
   digitalWrite(2,0);
   Serial.println(distance);
}

robot BE

int dist = A0;//capteur distance
int capt_g = A1; //detecteur infrarouge gauche
int capt_d = A3; // --  --  --  --  --  droit
int capt_c = A2; // --  --   de capture
int vit_g = 11; //vitesse de rotation du moteur gauche
int vit_d = 5; // -- --  --  --  --  --  --  - droit
int av_g = 9; // moteur gauche avance
int ar_g = 10; // --  --  --  - recule
int av_d = 7; // moteur droit avance
int ar_d = 6; // --  --  --   recule
int standby = 8;
int demande_distance = 2;
int mur = 1000;
const unsigned long MEASURE_TIMEOUT = 25000UL;
//Prototypes des fonctions :
void forward(); //tout droit
void turn_left(); //avance vers la gauche
void turn_right(); // -- -- -- --  droite
void rotate_right(); //tourne sur lui-meme vers la droite
void rotate_left(); // -- -- -- -- -- -- -- -- --  gauche
long mesure_distance(); //mesure de la distance par le capteur a ultrasons
int proie_g(); //detection d'une proie par le capteur gauche (renvoie 1 si detection, 0 sinon)
int proie_d(); // -- -- -- -- -- -- -- -- -- -- -- -- droit -- -- -- -- -- -- -- -- -- -- --

void setup() {
   // initialize serial communication at 9600 bits per second:
 Serial.begin(115200);
 pinMode(demande_distance,OUTPUT);
 pinMode(dist,INPUT);
 pinMode(vit_g,OUTPUT);
 pinMode(vit_d,OUTPUT);
 pinMode(av_g,OUTPUT);
 pinMode(av_d,OUTPUT);
 pinMode(ar_g,OUTPUT);
 pinMode(ar_d,OUTPUT);
 pinMode(standby,OUTPUT);
}

void loop() {
 digitalWrite(standby,1);
 digitalWrite(demande_distance,1);
 int distance= mesure_distance();
 if (distance>mur) {
   if (proie_g() && proie_d()) {
     forward();
     delay(500);
   }
   else if (proie_g()) {
     turn_left();
     delay(500);
   }
   else if (proie_d()) {
     turn_right();
     delay(500);
   }
   else {
     rotate_right();
     delay(500);
   }
 }
 else {
   rotate_left();
 }
 delay(1);
}

void rotate_right() {
 analogWrite(vit_g,1023);
 digitalWrite(av_g,1);
 digitalWrite(ar_g,0);
 analogWrite(vit_d,1023);
 digitalWrite(av_d,0);
 digitalWrite(ar_d,1); 
}

void rotate_left() {
 analogWrite(vit_g,1023);
 digitalWrite(av_g,0);
 digitalWrite(ar_g,1);
 analogWrite(vit_d,1023);
 digitalWrite(av_d,1);
 digitalWrite(ar_d,0); 
}

void turn_left() {
 analogWrite(vit_g,511);
 digitalWrite(av_g,1);
 digitalWrite(ar_g,0);
 analogWrite(vit_d,1023);
 digitalWrite(av_d,1);
 digitalWrite(ar_d,0);
}
 
void turn_right() {
 analogWrite(vit_g,1023);
 digitalWrite(av_g,1);
 digitalWrite(ar_g,0);
 analogWrite(vit_d,511);
 digitalWrite(av_d,1);
 digitalWrite(ar_d,0);
}

void forward() {
 analogWrite(vit_g,1023);
 digitalWrite(av_g,1);
 digitalWrite(ar_g,0);
 analogWrite(vit_d,1023);
 digitalWrite(av_d,1);
 digitalWrite(ar_d,0);
}

long mesure_distance()
{
 digitalWrite(demande_distance,1);
   long distance = pulseIn(dist, HIGH, MEASURE_TIMEOUT);
   delay(10);
   digitalWrite(demande_distance,0);
   Serial.println(distance); 
}

Septième partie : Finalisation du robot

Le robot est prêt à être assembler, le shield est prêt, tout les connecteurs sont soudés, nous avons réalisés les jonctions entre les plaques de plexi et les moteurs à l'aide de colle chaude. Nous avons réussi a organiser proprement le passage des câbles entre les différentes couches du robot. Les programmes sont tous prêts pour que le robot fonctionne normalement mais nous avons un problème avec les détecteurs avant le montage. Cependant le robot est capable de se déplacer, de recevoir et d'appliquer un programme.

Huitième partie : Conclusion

Malheureusement notre robot n'a pas pu être totalement opérationnel, lié à des soucis que nous avons eu avec notre shield ce qui a ralenti notre progression. Néanmoins ce bureau d'étude a été pour nous l'occasion de faire plus de pratique et d'apprendre les différentes phases de conception et déroulement d'un projet orienté vers la création d'un robot. De nombreuses compétences on été mises en œuvres pour réaliser ce travail, des aspects design, formes, électronique et informatique dans la programmation de notre tank.