REBEQA

Présentation du sujet

Mission générale

Le but de notre projet est de retrouver et récupérer un objet déposé dans un labyrinthe. Pour se faire, nous aurons besoin

1. D'un labyrinthe : il sera construit par des lignes de scotch noires collées sur un fond blanc . Les robots devront suivre ces lignes.
2. Robot bandit : Son rôle est de déposer un objet aléatoirement dans un labyrinthe (on choisit aléatoirement un temps qui fixera le moment auquel il doit déposer l'objet. Une fois l'objet déposé, le robot (retourne à sa position de départ en réalisant le chemin inverse).
3. Robot Policier : Recherche l'objet métallique en parcourant le labyrinthe. Une fois l'objet trouvé, il revient à sa position de départ, communique le chemin à suivre pour récupérer l'objet au troisième robot.
4. Robot Démineur : Récupère l'objet en suivant le chemin indiqué par le robot policier et revient à la base.

Détail du labyrinthe et des robots

- Labyrinthe : Il sera conçu à l'aide de scotchs noirs qui définiront le chemin. Il ne comporte pas de murs ni d'obstacles. Un code couleur permet de détecter une fin de route (scotch rouge) et le robot devra revenir sur ses pas ou un type d'intersection (3 branches : vert / 4 branches : jaune). Par défaut, le robot tournera tout le temps à droite (environ 90 degré). Le point de départ n'est pas considéré comme une fin de route (détection de blanc).

Dimension du labyrinthe à ajouter et de la largeur du chemin

- Les robots possèdent deux capteurs de suivi de lignes, 3 roues suédoises motorisées et un capteur de couleur. Ils intègrent tous une carte de commande R-Pi Picow.

- Le robot policier et le robot démineur possèdent en plus deux capteurs à ultrasons et un module de communication Bluetooth

- Le robot bandit et le robot démineur possèdent une pince motorisée, celle du robot démineur contiendra un "détecteur de métal" qui permettra de différencier un objet en métal d'un objet classique (en bois).

Matériel utilisé

- 3 cartes R-Pi Picow

- 2 capteurs ultrasons : HC-SR04

- 6 suiveurs de lignes

- 3 capteurs couleurs RGB

- 3 batteries

- 2 pinces dont une avec un détecteur d'objets métallique

- 2 Module Bluetooth

- 9 roues

- 1 objet métallique et 2 objets en bois de couleur

Pince

Les robots 1 et 3 seront munis de pinces. Ces dernières ont été modélisées à l'aide du logiciel SolidWorks et imprimées avec une imprimante 3D. Il y a une base qui fait la jonction entre les deux pinces, le servomoteur et le robot. Nous nous sommes inspirés des travaux des années précédentes en faisant bouger seulement une pince grâce au servomoteur qui va entrainer avec un système d'engrenage la seconde pince.

Servo Moteur

Afin de contrôler les pinces, nous allons utiliser 2 servo moteurs que nous avons récupéré d'anciens robots.

Datasheet : https://www.kjell.com/globalassets/mediaassets/701916_87897_datasheet_en.pdf?ref=4287817A7A

Nous avons donc testé leur bon fonctionnement avec une carte Arduino et le code suivant:

Code : Fichier:Moteur pince.zip

Identification de l'objet

On retrouve dans le labyrinthe un leurre et un objet déposé par le robot 1. Pour différencier le bon objet du leurre, nous avions d'abord pensé à utiliser un capteur de conductivité: le bon objet aurait été métallique et permettrait de laisser passer le courant, le différenciant du leurre non conducteur. Cependant, étant impossible à mettre en pratique avec le matériel à notre disposition et ayant un nombre de pin limité sur la carte de commande utilisée, nous avons opté pour une autre méthode d'identification d'objet basée sur la couleur. A l'aide d'un capteur de couleur TCS3200, nous allons pouvoir différencier l'objet d'une couleur spécifique du leurre de couleur blanche.

Code Arduino pour la détection d'un objet de couleur spécifique:

Capteurs

Capteur couleur TCS3200

- lien documentation : https://dronebotworkshop.com/arduino-color-sense/#TCS230_Arduino_Hookup Modification effectuée sur le code : allumage de la LED avec la commande

<<digitalWrite(PinDeLaLED, HIGH);>> Attention a bien laisser le mode LOW pour S1.

- Utilisation d'une carte Arduino UNO pour les tests.

- Meilleure détection pour une distance plus proche de 1cm (valeur exacte 1.5cm). Il sera donc placé sous les robots (au centre).

- Intervalles de détection : int redMin = 27; (Red minimum value) // int redMax = 155; (Red maximum value) // int greenMin = 33; (Green minimum value) // int greenMax = 210; (Green maximum value) // int blueMin = 30; (Blue minimum value) // int blueMax = 250; (Blue maximum value).

- La sortie renvoyée est sous format RGB avec le code choisi

- Les entrées S0 et S1 permettent la gestion du scaling (20% permettent de fixer une durée de pulsation acceptable et de limiter le bruit).

- Les entrées S2 et S3 permettent de définir un filtre couleur qui permettra de récupérer l'intensité de chaque composante RGB.

Code C++ : Fichier:Capteur couleur C.zip

Capteur ultrasons HC-SR04

- On branche l'alimentation sur 5V, Gnd à la masse, le pin 12 sur la sortie et le pin 11 sur l'entrée

- On le positionnera à l'avant pour détecter l'objet à récupérer (il n'y a pas d'obstacles extérieurs comme des murs).

Code Arduino : Fichier:Capteur US.zip Code C++ : Fichier:Capteur US C.zip

Capteurs suivi de ligne

Afin que les robots se déplacent dans le labyrinthe, nous allons utiliser des capteurs de lignes. Nous allons donc réutiliser le capteur de suivi de lignes des années précédentes qui est le capteur SparkFun Line sensor Breakout QRE1113.

Datasheet : https://www.sparkfun.com/datasheets/Robotics/QR_QRE1113.GR.pdf https://download.kamami.pl/p587610-KY-033-Joy-IT.pdf

Nous avons utiliser une carte arduino afin de tester le bon fonctionnement des capteurs de suivi de lignes et nous en avons 2 par robots soit 6 en tout.

Code C++ : Fichier:Suivi lignes.zip

Détecteur d'objet métallique

- Permet de détecter si un courant passe dans l'objet situé à l'intérieur de la pince : si l'objet est métallique, il conduit l'électricité ce qui forme un circuit fermé et donc on obtient une tension proche de zéro. Sinon, il ne conduit pas pas l'électricité et on obtient un circuit ouvert et on obtiendra une valeur proche de la tension d'alimentation (environ 5V).

Capteur Optique

Nous avons décider de reprendre l'idée du capteur optique écoconçu du robot RAMBOT présent sur les pinces du robot. Ce capteur permet de détecter si il y a bien un objet entre les pinces. Pour cela, nous avons repris les schémas électriques et modifié les composants.

Nous avons ensuite testé ce capteur avec le code suivant:

Code : Fichier:Capteuropt.zip

Ensemble des capteurs

Nous avons fait un test avec tous les capteurs mis en même temps sur une carte.

Code : Fichier:Robot3.zip

Communication

-Communication Bluetooth

Simulation

Tutoriels

Liens utiles

• Documentation officielle Webots (en anglais)
• Le fichier Webots du robot omni_wheels se trouve
• Un tutoriel pour faire suivre une ligne au robot
• Le tutoriel vidéo en python
• en C++
• Des tutoriels allant de la prise en mains à l’utilisation de certains capteur dans Webots sont disponibles

Installation de Webots

Environnement VM (Ubuntu, il suffit alors d'installer Webots à partir à partir de l'app center) ou WSL (Linux pour windows avec Ubuntu)

Pour WSL

modification à faire dans Windows :

INSTALLER RAPIDEMENT UBUNTU SUR WINDOWS 10 - WSL [TUTO]

commande à taper :

Installer WSL 2 | Microsoft Learn

Installer Webots :

Webots documentation: Installation Procedure

Webots

Une simulation Webots contient au moins ces deux composants :

• Un fichier world file (.wbt) qui définit un ou plusieurs robots et leurs environnements. Le langage utilisé est VRML97.
• Un ou plusieurs fichiers de contrôle (controller programs) pour ces robots. Ces fichiers sont en C/C++/Java/Python/MATLAB. Nous utiliserons C++.

Eventuellement il peut y avoir des PROTO : un fichier qui permet de définir un nouveau type de robot, capteur, objet ou structure, en combinant des nœuds existants (comme Solid, Transform, Shape, etc.). C’est un modèle réutilisable avec une interface personnalisable (paramètres comme la taille, la couleur, la masse...)

Pour exécuter le controller (procédure à refaire à chaque changement de code) :

• Dans le dossier du controller on tape les lignes de commandes
  • Export WEBOTS_HOME=CHEMIN_INSTALLATION_WEBOTS (souvent : /usr/local/webots)
  • make
• Dans webots recharger le monde (CTRL+SHIFT+R)
• Lancer la simulation

Modification d'un proto : Pour apporter une modification à un PROTO on préférera modifier le Node Tree plutôt que le code, modifier le Node Tree ne modifie pas le fichier code (et inversement). Si on modifie le fichier code, il faut sauvegarder le fichier puis recharger le monde pour appliquer le changement.

Créer un prototype dans Webots (en VRML97) est long et fastidieux. On préférera donc créer un modèle sous SolidWorks via 2 méthodes : - l’exporter en fichier .wrl - export un .stl ou un .obj

Créer un solide avec des formes originales

On a utilisé SolidWorks (partie à détailler avec image) pour modéliser notre solide puis on l'a exporté en .wrl (à préciser avec images) et on a extrait les coordonnées de notre solide. Sur Webots, on obtient le code suivant :

Solid {
  rotation 1 0 0 0
  children [
    Shape {
      appearance PBRAppearance {
        baseColor 0 0.8 0
        baseColorMap ImageTexture {
        }
        roughness 0.5
        metalness 0
      }
      geometry IndexedFaceSet {
        coord Coordinate {
          point [
             -0.089884 -0.040276 -0.000000, -0.089884 -0.040276 0.020000, -0.074666 -0.066129 0.000000, -0.074666 -0.066129 0.020000, -0.001198 0.116360 0.000000, -0.001198 0.116360 0.020000, 0.028801 0.116612 -0.000000, 0.028801 0.116612 0.020000, 0.105327 -0.064616 -0.000000, 0.105327 -0.064616 0.020000, 0.120108 -0.038510 -0.000000, 0.120108 -0.038510 0.020000
          ]
        }
        coordIndex [
           7, 11, 6, -1, 6, 11, 10, -1, 5, 7, 4, -1,
           4, 7, 6, -1, 1, 5, 0, -1, 0, 5, 4, -1,
           3, 1, 2, -1, 2, 1, 0, -1, 9, 3, 8, -1,
           8, 3, 2, -1, 11, 9, 10, -1, 10, 9, 8, -1,
           11, 7, 9, -1, 9, 7, 5, -1, 9, 5, 3, -1,
           3, 5, 1, -1, 2, 0, 8, -1, 8, 0, 4, -1,
           8, 4, 10, -1, 10, 4, 6, -1
        ]
     
  }
 }
]
}

Code pour contrôler notre robot Fichier:Omnic cmd.zip Vidéo simulation du suivie de ligne par le robot:

Tâches effectuées

1. Réalisation d'un robot complet
   • Fabrication des cartes de commande
   • Fabrication de la base
2. Contrôle du fonctionnement des pièces existantes
   • Capteurs
   • 2 robots déjà existants
3. Simulation sur Webots
4. Réalisation de la pince avec imprimante avec détecteur de métal

Pi-Pico

Fichier:Tuto Installation VSCODIUM.odt

Mécanique

Objet

Nous avons choisit un objet de 5cm de diamètre afin de pouvoir le détecter plus facilement avec le capteur de couleur. L'objet fait 14cm de haut, et a des côtés plus larges que son centre afin de l'attraper plus facilement. Il y a des transitions entre les différentes sections avec des pentes de 30° par rapport à l'horizontale afin de ne pas avoir besoin de support lors de l'impression de l'objet en 3D.

Pince

Les branches de la pince ont une courbure adaptée au diamètre de l'objet, avec l'introduction d'un jeu. La pince a un slot pour attacher le capteur de couleur.

Il n'y a pas d'emplacement pour le détecteur de présence pour la LED infrarouge de réception et son récepteur associé. Nous avons fait ce choix car il serait trop long de modéliser un emplacement pour la LED sans fragiliser la pince, donc elle sera collée sur la tranche de la branche de la pince.

Roue

Pour la roue, on prend le modèle .stl suivant, ouvrable avec Solidworks : https://www.thingiverse.com/thing:5031000 . On modifie le fichier de sorte d'avoir un diamètre d'axe de roue et une taille de roue similaire à ceux utilisés les années précédentes : - Hauteur de roue : 40 mm - Axe de roue : 4 mm

On fait une mise à l'échelle qui ramène la hauteur de roue à 40 mm. Puis on essaye d'adapter ensuite l'axe de roue à 4 mm.

Algorithmes

Parcours du labyrinthe

Direction en fonction des couleurs

Les intersections du labyrinthe seront délimitées par des couleurs selon les directions possibles que le robot pourra emprunter: violet: présence d'une intersection rouge: aller à droite bleu: aller à gauche vert: aller à droite ou à gauche jaune: aller à droite, à gauche ou en avant orange: impasse

Ces couleurs sont placées sur le labyrinthe comme sur la modélisation suivante: SIMU

Parcours d'un arbre

Afin d'explorer l’ensemble des chemins du labyrinthe, on applique un algorithme basé sur une structure en arbre, où chaque nœud représente une intersection ou une impasse.

L’algorithme parcourt chaque nœud à partir d’un point de départ, en explorant toutes les branches possibles. À chaque intersection, il choisit un chemin, le suit jusqu’à une impasse, puis revient en arrière pour explorer les autres options. Cela permet de visiter tous les chemins du labyrinthe.

code: