Binome2018-1 : Différence entre versions

De Wiki de bureau d'études PeiP
 
(30 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]]
[[Fichier:robot-composant-2018.jpg|300px|thumb|right|Moto-réducteurs et roues, micro-contrôleurs ATMega328p et quartz, contrôleur de moteurs TB6612FNG, LED infra-rouge]]
+
[[Fichier:robot-composant-2018.jpg|300px|thumb|right|Apercu de castor robot et de ses composants]]
 
<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).
 
  
= Logiciels à utiliser =
+
=<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 votre robot ne sont pas modélisés dans fritzing. 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]]
  
Pour la conception de circuits imprimés nous vous recommandons le logiciel [http://www.cadsoftusa.com/download-eagle/freeware/ eagle] ou le précédent.
 
  
Pour la découpe laser de nombreux utilisateurs utilisent [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é. Vous pouvez tenter [http://www.freecadweb.org/?lang=fr_FR freeCAD] si vous cherchez un logiciel plus libre. Une solution en ligne existe : [https://www.onshape.com/ onshape].
+
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 le développement avec les plateformes Arduino, utilisez l'environnement du même nom. Si la programmation C++ vous fait peur, n'hésitez pas à ajouter l'outil [http://sourceforge.net/projects/ardublock/ ardublock] à cet environnement.
+
Pour nous aider dans la conception des circuits imprimés, nous avons utilisé fritzing. cela nous a permis de personnaliser notre circuit imprimé
  
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.
 
  
Un premier circuit de type bouclier Arduino permet d'éviter tous les câbles entre l'Arduino et les contrôleurs de moteurs : [[Fichier:robot_bouclier.zip]]. Ce circuit est prévu pour 4 moteurs, les binômes avec des chassis bi-moteurs devront le simplifier. Après téléchargement, prenez soin de modifier le suffixe <code>.zip</code> en <code>.fzz</code>.
+
=Système embarqué=
<gallery style="margin: 0 auto;">
 
Fichier:robot_bouclier_bb.png|Bouclier : plaque d'essai
 
Fichier:robot_bouclier_schem.png|Bouclier : schéma
 
Fichier:robot_bouclier_pcb.png|Bouclier : circuit imprimé
 
</gallery>
 
  
Un second circuit permet de se passer totalement d'un Arduino : [[Fichier:RobotPCB.zip]]. Le coeur de la carte est un micro-contrôleur ATMega328p comme sur l'Arduino. La plupart des capteurs et actionneurs nécessaires à vos robots sont présents sur la carte. Après téléchargement, prenez soin de modifier le suffixe <code>.zip</code> en <code>.fzz</code>.
+
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.
<gallery style="margin: 0 auto;">
 
Fichier:RobotPCB_bb.png|Contrôleur : plaque d'essai
 
Fichier:RobotPCB_schem.png|Contrôleur : schéma
 
Fichier:RobotPCB_pcb.png|Contrôleur : circuit imprimé
 
</gallery>
 
  
= Configuration du système embarqué =
 
  
Pour contrôler les robots télécommandés vous utiliserez un ordinateur miniature Raspberry Pi 3. Cet ordinateur doit être configuré comme un point d'accès WiFi pour permettre une connexion à partir d'un téléphone intelligent.
+
= Répartition des tâches =
  
Il existe au moins deux méthode de se connecter sur la Raspberry PI 3 pour la configurer. La première méthode est la méthode "grand public" en utilisant la carte graphique intégrée sur la Raspberry et en lui connectant écran, clavier et souris. La seconde méthode est plus spartiate et traditionnellement utilisée dans le monde des systèmes embarqués : la connexion par liaison série.
+
Valentin a travaillé sur la strcuture du robot. Pour ma part, je me suis chargé du programme informatique.
  
== Connexion série ==
+
=<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>=
  
Vous êtes de futurs ingénieurs, la méthode "liaison série" est à votre portée et vous pourrez l'employer pour d'autres dispositifs. Vous allez commencer par récupérer la dernière version de la distribution Linux pour Raspberry Pi. Comme nous n'avons pas besoin de l'interface graphique, il est préférable de choisir la distribution "Raspbian Jessie Lite" plus légère en terme d'espace disque. La configuration décrite ci-après a été effectuée sur la version du 2017-01-11.
 
  
Une fois l'archive zippée de la distribution récupérée vous pouvez l'installer sur la carte SD après l'avoir décompressée en utilisant la commande <code>dd</code> :
+
=Ajout des bibliothèques=
dd if=2017-01-11-raspbian-jessie-lite.img of=/dev/sdb
 
Le nom du périphérique <code>/dev/sdb</code> peut varier suivant votre machine, vous pouvez lister les noms des périphériques blocs avec la commande <code>lsblk</code>. Exécutez cette commande avant et après l'insertion de votre carte SD et vous aurez le nom utilisé par votre système.
 
  
Avant de démarrer la Raspberry Pi 3 sur cette carte SD, vous devez modifier quelques paramètres de démarrage. En effet sur les dernières version de la distribution raspbian, la connexion série a été laissée de coté. Plusieurs explications à cela : la Raspberry vise plus le marché du jouet grand public que celui du système embarqué, de plus la Raspberry Pi 3 intégre maintenant une interface bluetooth disponible via le port série principal. Il est cependant possible d'utiliser le second port série désigné sous le nom de périphérique <code>/dev/serial0</code>. Montez la première partition de votre carte SD Raspian Lite avec la commande
 
mount /dev/sdb1 /mnt
 
puis examinez les fichiers <code>cmdline.txt</code> et <code>config.txt</code>. Attention le nom de la partition n'est pas forcément <code>/dev/sdb1</code>, utilisez <code>lsblk</code> pour déterminer le nom de la première partition de votre carte SD sur votre machine. Vérifiez que l'option <code>console=serial0,115200</code> est bien présente dans la ligne du fichier <code>cmdline.txt</code> et ajoutez <code>enable_uart=1</code> à la fin du fichier <code>config.txt</code>. N'oubliez pas de libérer votre carte SD par la commande
 
umount /mnt
 
  
Vous pouvez ensuite insérer la carte SD dans la Raspberry Pi. Utilisez le câble USB/série pour connecter votre Raspberry à votre PC. Il faut enficher les câbles noir, blanc et vert du câble USB/série [https://www.adafruit.com/product/954] sur les entrées/sorties correspondantes de la Raspberry [https://pinout.xyz/]. Le câble noir doit être sur la broche 6, le câble blanc sur la broche 8 et le câble vert sur la broche 10. Alimentez votre Raspberry Pi et lancez la commande suivante sur votre PC
+
  #include <boarddefs.h>
minicom -o -8 -b 115200 -D /dev/ttyUSB0
+
   #include <IRremote.h>
Vous devez obtenir, in fine, l'invite de connexion de la Raspberry
+
  #include <IRremoteInt.h>
Raspbian GNU/Linux 8 raspberrypi ttyS0
+
  #include <ir_Lego_PF_BitStreamEncoder.h>   //Ici nous importons toutes les bibliothèques que notre programme utilisera au fur et à mesure
    
 
raspberrypi login:
 
Vous pouvez vous connecter avec l'identifiant <code>pi</code> et le mot de passe <code>raspberry</code>. Pour passer administrateur utilisez la commande <code>sudo su</code>.
 
  
== Mise à jour de la distribution ==
+
=Connexion des composants aux pins du robot=
  
La distribution Raspbian vient avec le système de démarrage <code>systemd</code>. Ce système n'est pas forcément adapté à l'usage que nous souhaitons faire de la Raspberry : utilisation en tant que système embarqué et manipulation en mode texte. Il est assez simple de supprimer, en tant qu'administrateur, le paquetage <code>systemd</code> ainsi que deux autres paquetages qui tentent de gérer automatiquement la configuration réseau <code>dhcpcd5</code> et <code>openresolv</code> :
 
apt-get purge dhcpcd5 openresolv
 
apt-get purge systemd
 
Attention pour que la seconde commande fonctionne, il faut que la Raspberry Pi puisse récupérer des paquetages, donc soit connectée au réseau. En salle E304, vous pouvez connecter votre Raspberry sur la seconde interface réseau d'une Zabeth. Dans le fichier <code>/etc/network/interfaces</code> vous pouvez écrire la configuration ci-dessous :
 
auto eth0
 
iface eth0 inet dhcp
 
Il faut aussi mettre une adresse de serveur de noms dans le fichier <code>/etc/resolv.conf</code> :
 
nameserver 193.48.57.34
 
Enfin pour que la Raspberry accède aux dépôts de paquetage sur Internet, il faut lui indiquer d'utiliser les serveurs mandataires Web de l'école :
 
export http_proxy=http://proxy.polytech-lille.fr:3128
 
Il est normal que la suppression de <code>systemd</code> retourne une erreur, il faudra relancer la Raspberry pour l'enlever définitivement. Avant cela modifiez le fichier <code>/etc/inittab</code> et remplacez la ligne
 
#T0:23:respawn:/sbin/getty -L ttyS0 9600 vt100
 
par la ligne
 
T0:23:respawn:/sbin/getty -L serial0 115200 vt100
 
Après le redémarrage de la Raspberry enlevez définitivement <code>systemd</code> en tapant à nouveau la commande
 
apt-get purge systemd
 
  
== Connexion sur la Raspberry par <code>ssh</code> ==
+
  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)
  
La connexion sur la Raspberry par série a ses limites : le terminal texte est assez mal géré et à terme la connexion série sera dédié à la communication avec le micro-contrôleur. Maintenant que la Raspberry est configurée sur le réseau, il est souhaitable de s'y connecter en utilisant la commande <code>ssh</code>.
 
  
Pour activer le serveur <code>ssh</code> sur la Raspberry, utilisez les commandes suivantes :
+
=partie autonome du robot=
update-rc.d ssh enable
 
invoke-rc.d ssh start
 
  
Vous pouvez alors vous connecter sur la Raspberry avec la commande :
+
ssh pi@172.26.79.1XX
+
  void tourneD()
Si le message d'erreur à la connexion vous énerve, il vous suffit de rajouter un <code>#</code> devant l'appel de fonction <code>check_hash</code> à l'avant-dernière ligne du fichier <code>/etc/profile.d/sshpasswd.sh</code>.
+
  {
 +
  //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
 +
  }
  
== Configuration en point d'accès ==
+
  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
 +
  }
  
Pour que votre Raspberry Pi 3 devienne un point d'accès, installez le paquetage <code>hostapd</code> :
 
  apt-get install hostapd
 
  
Copiez le fichier de configuration de <code>hostapd</code> qui se trouve dans le répertoire <code>/usr/share/doc/hostapd/examples/</code> dans le répertoire <code>/etc/hostapd</code> :
+
  void ToutDroit() {
   cp /usr/share/doc/hostapd/examples/hostapd.conf.gz /etc/hostapd
+
   //permet au robot de se déplacer en ligne droite
   gunzip /etc/hostapd/hostapd.conf.gz
+
   digitalWrite(MotorD1,HIGH);
Examinez le fichier <code>/etc/hostapd/hostapd.conf</code> à la recherche des mots-clefs suivants :
+
  digitalWrite(MotorD2,LOW);
* <code>ssid</code>, indiquez votre nom de réseau WiFi ;
+
  analogWrite(SpeedD,150);
* <code>country_code</code>, mettez le code de la France <code>FR</code> ;
+
  digitalWrite(MotorG1,HIGH);
* <code>channel</code>, faites en sorte que les Raspberry n'écoutent pas toutes sur le même canal ;
+
  digitalWrite(MotorG2,LOW);
* <code>wpa</code>, activez l'option (mettre à 1) ;
+
  analogWrite(SpeedG,150);
* <code>wpa_passphrase</code>, donnez le mot de passe de votre réseau (au moins 8 caractères) ;
+
  }
* <code>wpa_key_mgmt</code>, à configurer à la valeur <code>WPA-PSK</code>.
 
  
Enfin dans le fichier <code>/etc/default/hostapd</code>, définissez le chemin du fichier de configuration :
 
DAEMON_CONF=/etc/hostapd/hostapd.conf
 
Relancez le service par la commande :
 
service hostapd restart
 
  
Vous pouvez vérifier avec votre téléphone que votre réseau WiFi est bien visible.
+
  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;
 +
  }
 +
  }
  
== Configuration IP des clients WiFi ==
+
  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;}
  
Pour que les clients WiFi puissent obtenir une adresse IP et autres coordonnées réseau, installez le paquetage <code>isc-dhcp-server</code> :
+
=Void Setup=
  apt-get install isc-dhcp-server
 
  
Tout d'abord choisir un réseau IPv4, par exemple <code>192.168.100.0/24</code> et affecter à la Raspberry une adresse de ce réseau, par exemple <code>192.168.100.1</code>. Pour cela ajoutez le bloc ci-dessous à la fin du fichier <code>/etc/network/interfaces</code> :
 
auto wlan0
 
iface wlan0 inet static
 
  address 192.168.100.1
 
  netmask 255.255.255.0
 
  
Il est alors possible de configurer le serveur DHCP au travers de son fichier de configuration <code>/etc/dhcp/dhcpd.conf</code>. Les directives à modifier sont les suivantes :
+
  void setup() {
* <code>option domain-name</code>, spécifiez un nom de domaine de votre choix (<code>monrobot.org</code> par exemple) ;
+
  Serial.begin(115200);
* <code>option domain-name-servers</code>, spécifiez l'adresse <code>192.168.100.1</code> comme serveur DNS ;
+
  Serial.println("IR Receiver Button Decode");
* <code>authoritative</code>, déclarez votre serveur DHCP comme légitime.
+
  irrecv.enableIRIn(); // Start the receiver
Il faut aussi ajouter un bloc réseau comme celui-ci :
+
  pinMode(13,OUTPUT);
subnet 192.168.100.0 netmask 255.255.255.0 {
+
  pinMode(12,OUTPUT);
  range 192.168.100.100 192.168.100.200;
+
  digitalWrite(Stop,HIGH);
  option routers 192.168.100.1;
+
  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);}
  
Relancez le service par la commande :
 
service isc-dhcp-server restart
 
Vous devez maintenant pouvoir connecter votre téléphone sur votre réseau WiFi. La bonne connexion au réseau WiFi doit se voir dans le fichier de contrôle <code>/var/log/daemon.log</code> et l'obtention d'une adresse IP doit se lire dans le fichier <code>/var/log/syslog</code>.
 
  
== Ajout d'un nom réseau pour la Raspberry Pi ==
 
  
A ce point votre téléphone peut contacter la Raspberry par son adresse IP. Pour pouvoir faire de même avec un nom significatif installez le paquetage <code>bind9</code> :
+
=Void Loop=
  apt-get install bind9
 
  
Ajoutez un bloc dans le fichier de configuration <code>/etc/bind/named.conf</code> :
 
zone "monrobot.org"  {
 
  type master;
 
  file "/etc/bind/db.monrobot";
 
};
 
  
Créez le fichier <code>/etc/bind/db.monrobot</code> avec un contenu de ce type :
 
$TTL    604800
 
@      IN      SOA    localhost. root.localhost. (
 
                              2        ; Serial
 
                        604800        ; Refresh
 
                          86400        ; Retry
 
                        2419200        ; Expire
 
                        604800 )      ; Negative Cache TTL
 
@      IN      NS      localhost.
 
robot  IN      A      192.168.100.1
 
  
Enfin ajoutez en tête du fichier <code>/etc/resolv.conf</code> la ligne
+
  void loop() {
domain monrobot.org
+
    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);}}
  
Vous pouvez vérifier le bon fonctionnement du résolveur de nom en tapant
 
  host -t any robot 192.168.100.1
 
  
== Installation d'un serveur Web ==
+
  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}
  
La commande du robot doit se faire via une interface Web. Il faut donc installer un serveur Web sur la Raspberry Pi avec un système de page dynamiques pour exécuter du code sur la Raspberry. Il suffit pour cela d'installer les paquetages <code>apache2</code> et <code>php7</code> :
 
apt-get install apache2 php7
 
  
Un premier test consiste à donner <code>robot</code> dans la barre d'adresses du navigateur Web de votre téléphone. La page de test du serveur Web <code>apache2</code> doit s'afficher.
 
  
Vous pouvez aussi écrire une petite page permettant d'effectuer une action comme l'arrêt de la Raspberry Pi. Cette page est à mettre dans le répertoire <code>/var/www/html</code>. Voila un exemple de page PHP, nommez la <code>index.php</code> et supprimez le fichier <code>index.html</code> :
 
<?php
 
if(array_key_exists('stop',$_POST)){
 
  system('super halt');
 
  die('halting ...');
 
  }
 
?>
 
<!DOCTYPE html>
 
<html>
 
  <head>
 
  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
 
  <title>Contrôle Web</title>
 
  </head>
 
  <body>
 
  <form method="POST" action="<?php echo $_SERVER['PHP_SELF']; ?>">
 
    <input type="submit" name="stop" value="Arrêter"/>
 
  </form>
 
  </body>
 
</html>
 
  
Notez l'appel de fonction <code>system('super halt')</code>. Pour que cet appel ait l'effet désiré, c'est à dire l'arrêt propre de la Raspberry Pi, il faut que le serveur Web puisse déclencher cet arrêt. De base, ce n'est pas possible pour une raison de droits : l'utilisateur <code>www-data</code> sous lequel tourne le serveur <code>apache2</code> n'a pas le privilège de lancer la commande <code>halt</code>. Nous allons donc utiliser l'utilitaire <code>super</code> pour autoriser le serveur Web à lancer la commande :
+
=<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>=
  apt-get install super
 
Ajoutez ensuite la ligne ci-dessous à la fin fichier de configuration de <code>super</code> qui se nomme <code>/etc/super.tab</code> :
 
halt    /sbin/halt      uid=root        www-data
 
  
Voila, vous devriez pouvoir arrêter votre Raspberry Pi en cliquant sur le bouton "Arrêter" de votre page Web.
+
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.
  
== Communication série ==
+
[[Fichier:IMG 20190509 164927.jpg|300px|thumb|left|Circuit Imprimé]]
 +
<br style="clear: both;"/>
  
Votre Raspberry Pi va probablement devoir communiquer avec un micro-contrôleur. Le plus simple est d'établir une communication série. Par contre les pages Web dynamiques peuvent difficilement utiliser le port série étant donné leur durée de vie, c'est à dire d'exécution, limitée. La solution propre pour permettre à des pages Web d'utiliser un port série est de passer par un serveur websocket. Ce type de processus est lancé au démarrage de la machine et accapare le port série. L'intérêt est que le serveur websocket est facilement contactable par un programma javascript tournant sur le navigateur.
+
=<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>=
 
 
Sur votre Raspberry, vous devez installer le paquetage <code>libwebsockets-dev</code> :
 
apt-get install libwebsockets-dev
 
Récupérez ensuite le programme C stocké sur ce Wiki ([[Fichier:Webserial.zip‎]] ou [[Fichier:Webserialv2.zip]] suivant la version de votre bibliothèque <code>libwebsockets</code>). Décompressez-le et compilez-le avec la commande :
 
  gcc -Wall webserial.c -o webserial -lwebsockets
 
Vous pouvez faire en sorte que ce programme soit lancé dès le démarrage de la Raspberry Pi en modifiant le fichier <code>/etc/rc.local</code>. Pensez à préciser le chemin complet du programme et à suffixer par un & pour que le programme soit lancé en tâche de fond.
 
 
 
 
 
Avec notre serveur websocket nous pouvons implanter des protocoles simples. L'exemple qui suit permet d'allumer et d'éteindre des LEDs connectées à un Arduino et à savoir quels boutons sont pressés. Pour les LEDs, le numéro de la LED à gérer est donné par les 7 bits de poids faible et le bit de poids fort permet de savoir s'il faut l'allumer ou l'éteindre. Pour les boutons, un octet est envoyé par l'Arduino dont chaque bit indique si le bouton est appuyé ou non.
 
 
 
Le programme de l'Arduino est très court :
 
#define LED1      8
 
#define Bouton1    2
 
#define Bouton2    3
 
 
void setup(void){
 
Serial.begin(9600);
 
for(int i=0;i<6;i++) pinMode(LED1+i,OUTPUT);
 
pinMode(Bouton1,INPUT);
 
pinMode(Bouton2,INPUT);
 
digitalWrite(Bouton1,HIGH);
 
digitalWrite(Bouton2,HIGH);
 
for(int i=0;i<6;i++){
 
    digitalWrite(LED1+i,HIGH);
 
    delay(200);
 
    digitalWrite(LED1+i,LOW);
 
    }
 
}
 
 
void loop(void){
 
if(Serial.available()>0){
 
  unsigned char actions=Serial.read();
 
  int led=LED1+actions&0x7f;
 
  if((actions&0x80)==0) digitalWrite(led,HIGH); else digitalWrite(led,LOW);
 
}
 
unsigned char capteurs=0;
 
if(digitalRead(Bouton1)==LOW) capteurs |= 0x01;
 
if(digitalRead(Bouton2)==LOW) capteurs |= 0x02;
 
Serial.write(capteurs);
 
delay(100);
 
}
 
 
 
La page Web qui dialogue avec le serveur websocket encore plus courte est disponible sur ce Wiki [[Fichier:Jsserial.zip]].
 
Penser à placer le fichier jquery.js stocké sur [[Fichier:jquery.zip]] dans votre dossier <code>/var/www/html</code> pour assurer le bon fonctionnement de la page web.
 
 
 
= 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.
 
 
 
== Robot proie ==
 
  
 
Un robot proie est constitué comme suit :
 
Un robot proie est constitué comme suit :
Ligne 301 : Ligne 268 :
 
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.  
 
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.  
  
Vous pouvez ajouter un mode télécommande au robot. La modification la plus simple consiste à recevoir des ordres d'une télécommande infra-rouge. Le robot pourrait ainsi recevoir des ordres pour accélèrer ou décélérer, pour tourner tranquillement ou brusquement.
 
 
Pour aller plus loin vous pouvez équiper votre robot d'une Raspberry PI 3 communiquant avec la carte de contrôle en série. Le robot peut alors être téléguidé par un téléphone.
 
  
== Robot prédateur ==
 
  
 
Un robot prédateur est constitué comme suit :
 
Un robot prédateur 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 ;
+
* 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 ;
 
* 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 ;
 
* 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 ;
 
* un émetteur infra-rouge pour émettre un signal signalant le robot comme un prédateur ;
* un dispositif émetteur à courte distance pour simuler la capture d'une proie, par exemple un électro-aimant.
 
 
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 active la communication à faible portée. Cette activation est temporaire pour donner une chance à la proie de s'échapper.
 
 
Vous pouvez ajouter un mode télécommande au robot. La modification la plus simple consiste à recevoir des ordres d'une télécommande infra-rouge. Le robot pourrait ainsi recevoir des ordres de direction, de vitesse et d'activation de la communication "capture".
 
 
Pour aller plus loin vous pouvez équiper votre robot d'une Raspberry PI 3 communiquant avec la carte de contrôle en série. Le robot peut alors être téléguidé par un téléphone.
 
 
== Réalisations des binômes ==
 
  
{| class="wikitable"
+
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.
! 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.