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

Introduction

Notre projet dans ce bureau d'étude à été de fabriquer des robots dans le domaine des proies ou prédateurs.

Les prédateurs doivent repérer et rattraper des proies. Ils sont donc lourd et on besoin de moteurs puissants. Les proies émettent un signal qui permet aux prédateurs de les détecter et sont donc ainsi identifiées grâce aux tsops. Les prédateurs possèdent un système de réception infra-rouge directionnel permettant de s'orienter dans la phase de poursuite. Les prédateurs émettent aussi un signal infra-rouge permettant ainsi aux proies de savoir qu'elles sont prises en chasse. Les prédateurs n'ont pas besoin de connaître le relief de la pièce une fois la poursuite lancée. En effet, comme les proies ne savent pas voler, c'est à elle d'éviter les murs ce qui permet d’alléger le programme des robots prédateurs.

Les proies et les prédateurs doivent être clairement autonome.

La taille du robot n'est pas fixé. Mais il est préférable d'avoir un robot plus rapide pour les proies là où un robot plus massif sera conseillé pour les robots prédateurs. Nous avons choisi pour notre projet de faire un robot prédateur.

Compétences et matériel utilisé

Compétences :

• avancer et tourner ;

• s'orienter par rapport aux signaux que les tsops lui transmettent lors d'une course poursuite ;

• éventuellement émettre des signaux pour complexifier et rendre plus tacte la chasse ;

Matériel ;

• Nous avons pu nous inspirer des robots des années précédentes pour construire notre robot. Nous étions même autorisé à les détruises pour récupérer leur matos. Ces robots ne sont pas forcément totalement fonctionnels mais les parties déjà réalisées nous ont fait gagner du temps que nous avons pu consacrer à la programmation du robot.

• Pour faire le support du robot c'est à dire son châssis nous avion utilisé du plexiglas. Pour faire la découpe du support, nous avons utilisé la découpe laser.

Il faut faire attention de bien optimiser l'espace de son châssis. Dans l'absolue il vaut mieux faire trop grand et faire tenir le tout avec des ajouts non prévus que d'avoir un support trop petit et de devoir retirer du matos initialement prévu pour le robot.

• Les montages photographiques proposent une construction de robot simple et les composants de base pour construire un robot plus optimisé et personnalisé.

Chassis, Arduino Mega, récepteur infra-rouge, sonar, contrôleur moteurs

Apercu de castor robot et de ses composants

Logiciels

Pour concevoir un schéma propre du câblage de notre robot, nous avons utlisé fritzing. Tous les composants de notre robot ne sont pas modélisés dans fritzing car certains ont du être rajouté en cours de route.

• détecteur ultrason : Fichier:UltrasonicSensor HCSR04.zip
• contrôleur de moteurs : Fichier:MotorDriver Pololu md08a.zip

Pour la découpe laser nous avons utilisé ce logiciel inkscape.

3D solidwork est très utilisé pour construire le support de notre robot. Mais nous ne l'avons pas utilisé. Notre programme a été realisé en C++ ce qui est relativement abordable. Il y a de nombreux site internet qui proposent de claires explication.

Pour nous aider dans la conception des circuits imprimés, nous avons utilisé fritzing. cela nous a permis de personnaliser notre circuit imprimé

Système embarqué

Il n'y a pas de télécommandes pour controler le robot. Autrement dit, il doit être 100% autonome. Il possède donc un sonar, un détecteur infrarouge et une batterie.

Répartition des tâches

Valentin a travaillé sur la strcuture du robot. Pour ma part, je me suis chargé du programme informatique.

Programme informatique

Ajout des bibliothèques

 #include <boarddefs.h>
 #include <IRremote.h>
 #include <IRremoteInt.h>
 #include <ir_Lego_PF_BitStreamEncoder.h>   //Ici nous importons toutes les bibliothèques que notre programme utilisera au fur et à mesure

Connexion des composants aux pins du robot

 int MotorG1=8;
 int MotorG2=7;
 int MotorD1=4;
 int MotorD2=A5;
 int SpeedG=6;
 int SpeedD=10;
 int echo=A3;
 int trigger=A4;      //On relie les pins aux microprocesseurs
 int Tsop1=A0;
 int Tsop2=A1;
 int Stop = 9;
 int tsop1=digitalRead(Tsop1);
 int tsop2=digitalRead(Tsop2);                                                           
 const unsigned long MEASURE_TIMEOUT = 25000UL;//variable pour le sonar
 const float SOUND_SPEED = 340.0 / 1000;// vitesse du son dans l'air
 int IR = 1024;
 IRrecv irrecv(Tsop1);     
 decode_results results;    /valeur du tsop a la frequence infrarouge d'une proie (inconnue pour l'instant)

partie autonome du robot

 void tourneD()
 {
 //permet de tourner à gauche
 digitalWrite(MotorG1,HIGH);// gauche
 digitalWrite(MotorG2,LOW);//gauche
 analogWrite(SpeedG,100); // vitesse gauche
 digitalWrite(MotorD1,LOW);// droit
 digitalWrite(MotorD2,HIGH);// droit
 analogWrite(SpeedD,100);// vitesse droite
 }

 void tourneG()
 {
 //permet de tourner à droite 
 digitalWrite(MotorG1,HIGH);// gauche
 digitalWrite(MotorG2,LOW);//gauche
 analogWrite(SpeedG,100); // vitesse gauche
 digitalWrite(MotorD1,LOW);// droit
 digitalWrite(MotorD2,HIGH);// droit
 analogWrite(SpeedD,100);// vitesse droite
 }

 void ToutDroit() {
 //permet au robot de se déplacer en ligne droite
 digitalWrite(MotorD1,HIGH);
 digitalWrite(MotorD2,LOW);
 analogWrite(SpeedD,150);
 digitalWrite(MotorG1,HIGH);
 digitalWrite(MotorG2,LOW);
 analogWrite(SpeedG,150);
 }

 int detectProie(){
 //fonction qui détecte une proie et nous oriente par rapport à elle
 if (irrecv.decode(&results)){ // Condition sur un signal que nous recevons
   translateIR();
   tsop1 = IR;
   irrecv.resume(); // prend la prochaine valeur
 }
 if (tsop1 == IR && tsop2 != IR){
 //tourne legerement a gauche
   digitalWrite(Stop,HIGH);
   tourneG();
   delay(300);
   digitalWrite(Stop,LOW);
   tsop1 = 0;
   tsop2 = 0;
   return 0;
  
 }
 else if (tsop1 != IR){
 //tourne legerement a droite
   digitalWrite(Stop,HIGH);
   tourneD();
   delay(300);
   digitalWrite(Stop,LOW);
   tsop1 = 0;
   tsop2 = 0;
   return 0;
 }
 else {
   return 1;
 }
 }

 float obstacle(){
 //fonction qui detecte un obstacle
   digitalWrite(trigger, HIGH); //émission signal
   delay(10);
   digitalWrite(trigger, LOW);  //fin émission
   long measure = pulseIn(echo, HIGH, MEASURE_TIMEOUT); //temps entre le signal emis et recu
   float distance_mm = measure / 2.0 * SOUND_SPEED;// calcul de la distance en mm
   Serial.print(F("Distance: "));
   Serial.print(distance_mm);
   Serial.print(F("mm ("));
   Serial.print(distance_mm / 10.0, 2);
   Serial.print(F("cm, "));
   Serial.print(distance_mm / 1000.0, 2);
   Serial.println(F("m)"));
   delay(5);
   return distance_mm;}

Void Setup

 void setup() {
 Serial.begin(115200);
 Serial.println("IR Receiver Button Decode");
 irrecv.enableIRIn(); // Start the receiver
 pinMode(13,OUTPUT);
 pinMode(12,OUTPUT);
 digitalWrite(Stop,HIGH);
 pinMode(A0,INPUT); //configure les types de pins (entrées ou sorties)
 pinMode(A1,INPUT);
 pinMode(A3,INPUT);
 pinMode(8,OUTPUT);
 pinMode(7,OUTPUT);
 pinMode(4,OUTPUT);
 pinMode(6,OUTPUT);
 pinMode(10,OUTPUT);
 pinMode(A5,OUTPUT);
 pinMode(A4,OUTPUT);
 pinMode(9,OUTPUT);
 digitalWrite(A4,LOW);//trigger
 digitalWrite(Stop,HIGH);}

Void Loop

 void loop() {
   int i = 0;
   while(detectProie() != 1 && i < 1){
     i++;
   }
   if( obstacle() > 500 ){
     digitalWrite(Stop,HIGH);
     ToutDroit();
     delay(1000);
     digitalWrite(Stop,LOW);
   }
   else {
     digitalWrite(Stop,HIGH);
     tourneD();
     delay(400);
     digitalWrite(Stop,LOW);}}

 void translateIR() // Se délenche suivant le signal IR recu 
 {
   switch(results.value)
   {
   case 0x14EB18E7:digitalWrite(12,LOW); digitalWrite(13,HIGH);  break;
   case 0x14EB30CF:digitalWrite(13,LOW); digitalWrite(12,HIGH); break;
   //   ^here your hex code that you got in irdumpv2 or irdemo
   default:
     Serial.println(" other button   ");
   }// End Case
   delay(100); // Délai d'attente avant de répeter le programme} 

Circuit imprimé

tout d'abord on a essayé de comprendre comment fonctionne la carte electronique modele fournie au debut du BE. Une fois comprise on l'a modifié pour qu'elle convienne a notre robot. on la reduite au maximum en enlevant les partie inutiles. Une fois reçue et verifiée nous avons soudé les composant et testé la carte. la carte est donc composé d'un atmega328p (carte mère), d'un double pont en h pour controler les moteurs, d'un port USB avec son adaptateur. il est capable d'acceuillir 2 moteurs, un buzzer, 2 tsop, 1 servomoteur et 1 sonar.

Circuit Imprimé

Différence robot proie/prédateur

Un robot proie est constitué comme suit :

• un châssis roulant, un contrôleur pour chaque paire de moteurs, un Arduino Uno ou un circuit électronique maison à base de micro-contrôleur ATMega328p ;
• des détecteurs ultrason pour éviter les collisions ;
• un récepteur infra-rouge TSOP pour décoder les signaux infra-rouges modulés ;
• un émetteur infra-rouge pour émettre un signal signalant le robot comme une proie ;
• un dispositif récepteur à courte distance pour simuler la capture par un prédateur, vous pouvez partir sur l'idée d'un capteur à effet Hall.

Dans son mode autonome, le robot se promène dans la pièce en évitant les obstacles de façon tranquille et prévisible. Quand il repère un prédateur à son signal infra-rouge, la proie se déplace plus vivement avec de brusques changements de direction. Quand le détecteur à courte distance indique que le robot proie est à portée du prédateur, il s'arrête. Faire clignoter des LED rouges serait assez à propos.

Un robot prédateur est constitué comme suit :

• un châssis roulant, un contrôleur pour chaque paire de moteurs, un Arduino Uno;
• un détecteur ultrason pour ne pas rentrer dans les obstacles ;
• des récepteurs infra-rouges TSOP pour décoder les signaux infra-rouges modulés ;
• un émetteur infra-rouge pour émettre un signal signalant le robot comme un prédateur ;

Dans son mode autonome, le robot tourne en rond à la recherche d'une proie. Dès qu'il en repère une, il se précipite vers elle en se calant sur son signal infra-rouge. Quand le prédateur pense être à porté de la proie, il lui fonce dessus. Il ne s'arrête pas et s'acharne jusqu'à en venir à bout.