Binome2018-1 : Différence entre versions

De Wiki de bureau d'études PeiP
 
(17 révisions intermédiaires par 2 utilisateurs non affichées)
Ligne 1 : Ligne 1 :
 +
<include nopre noesc src="/home/pedago/ppeip/include/video-Robot_Binome01_2018-iframe.html" />
 +
__TOC__
 +
<br style="clear: both;">
 
=<div class="mcwiki-header" style="border-radius: 15px; padding: 15px; font-weight: bold; text-align: center; font-size: 80%; background: #0080FF; vertical-align: top; width: 98%;"> Introduction </div>=
 
=<div class="mcwiki-header" style="border-radius: 15px; padding: 15px; font-weight: bold; text-align: center; font-size: 80%; background: #0080FF; vertical-align: top; width: 98%;"> Introduction </div>=
  
  
 
+
Notre projet dans ce bureau d'étude à été de fabriquer des robots dans le domaine des proies ou prédateurs.
Durant notre année nous avons du réaliser 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 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.  
Ligne 30 : Ligne 32 :
 
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.  
 
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é.
Les montages photographiques ci-dessous présentent les éléments permettant de construire un robot sans trop souffrir et les composants de base pour construire un robot plus optimisé et personnalisé.
 
  
 
[[Fichier:IMG 9286.jpg|300px|thumb|left|Chassis, Arduino Mega, récepteur infra-rouge, sonar, contrôleur moteurs]]
 
[[Fichier:IMG 9286.jpg|300px|thumb|left|Chassis, Arduino Mega, récepteur infra-rouge, sonar, contrôleur moteurs]]
Ligne 37 : Ligne 38 :
 
<br style="clear: both;"/>
 
<br style="clear: both;"/>
  
Des robots miniatures peuvent être réalisés en utilisant des servo-moteurs continus et des pièces en plexiglas ou en contreplaqué découpées à l'aide de la découpeuse laser du [http://www.fabricarium.fr/mediawiki-1.23.5/index.php?title=Accueil Fabricarium]. Certaines formes plus complexes peuvent éventuellement être réalisées à l'aide des imprimantes 3D du [http://www.fabricarium.fr/mediawiki-1.23.5/index.php?title=Accueil Fabricarium]. Il est possible d'imprimer des pneus avec du PLA flexible.
 
Pour les fixations vous avez de la visserie (vis, écrous, entretoises).
 
  
 
=<div class="mcwiki-header" style="border-radius: 15px; padding: 15px; font-weight: bold; text-align: center; font-size: 80%; background: #0080FF; vertical-align: top; width: 98%;"> Logiciels </div>=
 
=<div class="mcwiki-header" style="border-radius: 15px; padding: 15px; font-weight: bold; text-align: center; font-size: 80%; background: #0080FF; vertical-align: top; width: 98%;"> Logiciels </div>=
  
Pour concevoir un schéma propre du câblage de votre robot vous pouvez utiliser [http://fritzing.org/home/ fritzing]. Tous les composants de notre robot ne sont pas modélisés dans fritzing. Donc voici une liste de composants supplémentaires mis au points par des élèves IMA de la promotion 2017 (Julie Debock, Hugo Vandenbunder et Sylvain Verdonck) et revus par les encadrants du bureau d'études :
+
Pour concevoir un schéma propre du câblage de notre robot, nous avons utlisé  [http://fritzing.org/home/ 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]]
 
* détecteur ultrason : [[Fichier:UltrasonicSensor_HCSR04.zip]]
 
* contrôleur de moteurs : [[Fichier:MotorDriver_Pololu_md08a.zip]]
 
* contrôleur de moteurs : [[Fichier:MotorDriver_Pololu_md08a.zip]]
Ligne 49 : Ligne 48 :
 
Pour la découpe laser nous avons utilisé ce logiciel [https://inkscape.org/fr/ inkscape].
 
Pour la découpe laser nous avons utilisé ce logiciel [https://inkscape.org/fr/ inkscape].
  
Pour la conception 3D solidwork est très utilisé. Mais nous ne l'avons pas utilisé.
+
3D solidwork est très utilisé pour construire le support de notre robot. Mais nous ne l'avons pas utilisé.
Pour le développement avec les plateformes Arduino, utilisez l'environnement du même nom. La programmation se fait en C++ ce qui est relativement abordable. Il y a de nombreux site internet qui proposent de claires explication. Enfin les programmes que nous devons réaliser restent largement dans nos cordes ce qui ne pose aucun problème.
+
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 vous aider dans la conception des circuits imprimés, nous vous proposons des circuits modélisés avec fritzing que vous pourrez adapter à vos robots. Ces circuits ont été ébauchés par des élèves IMA et retouchés par les encadrants du bureau d'études. Ce qui est pratique pour tester un composant à l'avance et ainsi ne pas prendre du retard.
+
Pour nous aider dans la conception des circuits imprimés, nous avons utilisé fritzing. cela nous a permis de personnaliser notre circuit imprimé
  
  
Ligne 62 : Ligne 61 :
 
= Répartition des tâches =
 
= Répartition des tâches =
  
Nous n'imposons pas de répartition rigide des tâches. Pour qu'une démonstration puisse se faire en fin de bureau d'étude il faut au moins un robot proie et un robot prédateur.
+
Valentin a travaillé sur la strcuture du robot. Pour ma part, je me suis chargé du programme informatique.
  
 
=<div class="mcwiki-header" style="border-radius: 15px; padding: 15px; font-weight: bold; text-align: center; font-size: 80%; background: #0080FF; vertical-align: top; width: 98%;"> Programme informatique </div>=
 
=<div class="mcwiki-header" style="border-radius: 15px; padding: 15px; font-weight: bold; text-align: center; font-size: 80%; background: #0080FF; vertical-align: top; width: 98%;"> Programme informatique </div>=
  
 +
 +
=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=
 
=Connexion des composants aux pins du robot=
  
  
int MotorG1=8;
+
  int MotorG1=8;
int MotorG2=7;
+
  int MotorG2=7;
int MotorD1=4;
+
  int MotorD1=4;
int MotorD2=A5;
+
  int MotorD2=A5;
int SpeedG=6;
+
  int SpeedG=6;
int SpeedD=10;
+
  int SpeedD=10;
int echo=A3;
+
  int echo=A3;
int trigger=A4;
+
  int trigger=A4;     //On relie les pins aux microprocesseurs
int Tsop1=A0;
+
  int Tsop1=A0;
int Tsop2=A1;
+
  int Tsop2=A1;
int Stop = 9;
+
  int Stop = 9;
int tsop1=digitalRead(Tsop1);
+
  int tsop1=digitalRead(Tsop1);
int tsop2=digitalRead(Tsop2);
+
  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 autonomie du robot=
+
=partie autonome du robot=
  
 
+
void tourneD() {
+
  void tourneD()
 +
  {
 +
  //permet de tourner à gauche
 
   digitalWrite(MotorG1,HIGH);// gauche
 
   digitalWrite(MotorG1,HIGH);// gauche
 
   digitalWrite(MotorG2,LOW);//gauche
 
   digitalWrite(MotorG2,LOW);//gauche
Ligne 95 : Ligne 109 :
 
   digitalWrite(MotorD2,HIGH);// droit
 
   digitalWrite(MotorD2,HIGH);// droit
 
   analogWrite(SpeedD,100);// vitesse droite
 
   analogWrite(SpeedD,100);// vitesse droite
}
+
  }
  
void tourneG() {
+
  void tourneG()
 +
  {
 +
  //permet de tourner à droite
 
   digitalWrite(MotorG1,HIGH);// gauche
 
   digitalWrite(MotorG1,HIGH);// gauche
 
   digitalWrite(MotorG2,LOW);//gauche
 
   digitalWrite(MotorG2,LOW);//gauche
Ligne 104 : Ligne 120 :
 
   digitalWrite(MotorD2,HIGH);// droit
 
   digitalWrite(MotorD2,HIGH);// droit
 
   analogWrite(SpeedD,100);// vitesse droite
 
   analogWrite(SpeedD,100);// vitesse droite
}
+
  }
  
  
void ToutDroit() {
+
  void ToutDroit() {
 +
  //permet au robot de se déplacer en ligne droite
 
   digitalWrite(MotorD1,HIGH);
 
   digitalWrite(MotorD1,HIGH);
 
   digitalWrite(MotorD2,LOW);
 
   digitalWrite(MotorD2,LOW);
Ligne 114 : Ligne 131 :
 
   digitalWrite(MotorG2,LOW);
 
   digitalWrite(MotorG2,LOW);
 
   analogWrite(SpeedG,150);
 
   analogWrite(SpeedG,150);
}
+
  }
  
  
int detectProie(){//fonction qui nous place en face d'une proie
+
  int detectProie(){
   tsop1 = digitalRead(Tsop1);
+
  //fonction qui détecte une proie et nous oriente par rapport à elle
  tsop2 = digitalRead(Tsop2);
+
   if (irrecv.decode(&results)){ // Condition sur un signal que nous recevons
 
+
    translateIR();
   if (tsop1 == IR && tsop2 != IR){//tourne legerement a gauche
+
    tsop1 = IR;
 +
    irrecv.resume(); // prend la prochaine valeur
 +
  }
 +
   if (tsop1 == IR && tsop2 != IR){
 +
  //tourne legerement a gauche
 
     digitalWrite(Stop,HIGH);
 
     digitalWrite(Stop,HIGH);
 
     tourneG();
 
     tourneG();
     delay(200);
+
     delay(300);
 
     digitalWrite(Stop,LOW);
 
     digitalWrite(Stop,LOW);
 +
    tsop1 = 0;
 +
    tsop2 = 0;
 
     return 0;
 
     return 0;
   
+
 
 
   }
 
   }
   else if (tsop1 != IR){//tourne legerement a droite
+
   else if (tsop1 != IR){
 +
  //tourne legerement a droite
 
     digitalWrite(Stop,HIGH);
 
     digitalWrite(Stop,HIGH);
 
     tourneD();
 
     tourneD();
     delay(200);
+
     delay(300);
 
     digitalWrite(Stop,LOW);
 
     digitalWrite(Stop,LOW);
 +
    tsop1 = 0;
 +
    tsop2 = 0;
 
     return 0;
 
     return 0;
 
   }
 
   }
Ligne 139 : Ligne 165 :
 
     return 1;
 
     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=
  
  
void setup() {
+
  void setup() {
 
   Serial.begin(115200);
 
   Serial.begin(115200);
 +
  Serial.println("IR Receiver Button Decode");
 +
  irrecv.enableIRIn(); // Start the receiver
 +
  pinMode(13,OUTPUT);
 +
  pinMode(12,OUTPUT);
 
   digitalWrite(Stop,HIGH);
 
   digitalWrite(Stop,HIGH);
   pinMode(A0,INPUT);
+
   pinMode(A0,INPUT); //configure les types de pins (entrées ou sorties)
 
   pinMode(A1,INPUT);
 
   pinMode(A1,INPUT);
 
   pinMode(A3,INPUT);
 
   pinMode(A3,INPUT);
Ligne 160 : Ligne 206 :
 
   pinMode(9,OUTPUT);
 
   pinMode(9,OUTPUT);
 
   digitalWrite(A4,LOW);//trigger
 
   digitalWrite(A4,LOW);//trigger
   digitalWrite(Stop,HIGH);
+
   digitalWrite(Stop,HIGH);}
  
}
 
  
  
Ligne 168 : Ligne 213 :
  
  
void loop() {
 
  int i = 0;
 
  while(detectProie() != 1 && i < 1){
 
    i++;
 
  }
 
  
   if( obstacle() > 500 ){
+
   void loop() {
    digitalWrite(Stop,HIGH);
+
    int i = 0;
    ToutDroit();
+
    while(detectProie() != 1 && i < 1){
    delay(1000);
+
      i++;
    digitalWrite(Stop,LOW);
+
    }
  }
+
    if( obstacle() > 500 ){
  else {
+
      digitalWrite(Stop,HIGH);
    digitalWrite(Stop,HIGH);
+
      ToutDroit();
    tourneD();
+
      delay(1000);
    delay(400);
+
      digitalWrite(Stop,LOW);
     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}  
  
  
 
 
}
 
  
Notre robot vous réserve une petite surprise. Pour cela, encerclez-le d'un contour qui lui barrera la route et vous verez qu'il s'en sortira. Spoiler alert : il sait éviter des obstacles!!
 
  
 
=<div class="mcwiki-header" style="border-radius: 15px; padding: 15px; font-weight: bold; text-align: center; font-size: 80%; background: #0080FF; vertical-align: top; width: 98%;"> Circuit imprimé </div>=
 
=<div class="mcwiki-header" style="border-radius: 15px; padding: 15px; font-weight: bold; text-align: center; font-size: 80%; background: #0080FF; vertical-align: top; width: 98%;"> Circuit imprimé </div>=
  
Fichier:IMG 20190509 164927.jpg
+
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.
 +
 
 +
[[Fichier:IMG 20190509 164927.jpg|300px|thumb|left|Circuit Imprimé]]
 +
<br style="clear: both;"/>
  
 
=<div class="mcwiki-header" style="border-radius: 15px; padding: 15px; font-weight: bold; text-align: center; font-size: 80%; background: #0080FF; vertical-align: top; width: 98%;"> Différence robot proie/prédateur </div>=
 
=<div class="mcwiki-header" style="border-radius: 15px; padding: 15px; font-weight: bold; text-align: center; font-size: 80%; background: #0080FF; vertical-align: top; width: 98%;"> Différence robot proie/prédateur </div>=
Ligne 217 : Ligne 277 :
  
 
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.
 
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.
 
== Réalisations des binômes ==
 
 
{| class="wikitable"
 
! Numéro !! Elèves !! Type de robot !! Page
 
|-
 
| Binôme 1
 
| Ziyad Houssaini* / Lucas Houziaux*
 
| Proie
 
| [[Binome2017-1|Binôme 1 2017/2018]]
 
|-
 
| Binôme 2
 
| Théo Evrard! / Valériane Salingue*
 
| Prédateur
 
| [[Binome2017-2|Binôme 2 2017/2018]]
 
|-
 
| Binôme 3
 
| Valentin Kerskens° / Kadir Tekin*
 
| Proie
 
| [[Binome2017-3|Binôme 3 2017/2018]]
 
|-
 
| Binôme 4
 
| Alex Lagneau* / Adrien Piednoel!
 
| Proie
 
| [[Binome2017-4|Binôme 4 2017/2018]]
 
|-
 
| Binôme 5
 
| Clémence Béchet! / Pierre Gautreau*
 
| Prédateur
 
| [[Binome2017-5|Binôme 5 2017/2018]]
 
|-
 
| Binôme 6
 
| Claire Devisme° / Noémie Lounici!
 
| Prédateur
 
| [[Binome2017-6|Binôme 6 2017/2018]]
 
|-
 
| Binôme 7
 
| Nour Ekhlas*
 
| Prédateur
 
| [[Binome2017-7|Binôme 7 2017/2018]]
 
|-
 
| Binôme 8
 
| Vincent Dubois*
 
| Proie
 
| [[Binome2017-8|Binôme 8 2017/2018]]
 
|-
 
| Binôme 9
 
| Raphaël Bonvalet* / Damien Tillaux*
 
| Proie
 
| [[Binome2017-9|Binôme 9 2017/2018]]
 
|-
 
|}
 

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


Vidéo HD


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.


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.