Instrument2012-1

Robot navigant aux instruments - 2012/2013

Version 4.29.2, mise à jour le 29/04/2013 à 11:18

Vidéo HD

LE ROBOT EN AUTONOMIE

Enjeux et objectifs

Nous devons doter notre robot d'une boussole ou d'un gyroscope pour lui permettre de connaitre précisément sa direction de déplacement. Distinguons le gyroscope, qui renvoie la valeur de vitesse angulaire, et la boussole qui renvoie un cap.

• Nous commencerons par faire en sorte que notre robot sache avancer en ligne droite, pour cela nous utiliserons le contrôle PID. Nous allons pour cela effectuer des corrections sur la trajectoire en utilisant des rotations. L'angle de ces rotations va être calculé en fonction de l'erreur de trajectoire indiqué par l'instrument. Plus exactement par la somme d'une constante multipliée par l'erreur instantanée, d'une autre constante multipliée par l'intégrale de l'erreur et enfin d'une dernière constante multipliée par la dérivée de l'erreur. Il nous faut pour cela trouver les valeurs adaptées des trois constantes.

• Nous ferons ensuite en sorte que notre robot sache contourner les obstacles au plus juste. Au plus juste signifiant qu'il tournera vers la droite ou vers la gauche en jugeant où se trouve le chemin le plus libre. L'algorithme à appliquer consiste à tourner le robot d'un angle faible dans un sens puis dans l'autre et de lire les résultats du sonar. Si les deux mesures indiquent un obstacle trop proche, l'angle est augmenté et le procédé répété. Dès qu'une trajectoire indique un chemin libre ou du moins un obstacle à distance suffisante, le robot avance en ligne droite suivant cette trajectoire. L'instrument doit être utilisé ici pour vérifier que le robot effectue précisément des rotations des angles souhaités et qu'il sache revenir en position initiale pour éventuellement recommencer avec un angle plus grand.

• Pour permettre de suivre le comportement du robot, nous afficherons sur la brique de contrôle MindStorm l'angle de rotation pour le dernier contournement et la distance parcourue le long de la dernière ligne droite.

Nous intégrerons ces comportements pour obtenir un robot capable de contourner les obstacles avec un minimum d'intelligence.

Voici un exemple de contournement d'obstacle avec l'algorithme décrit.

• 

  Contournement d'obstacle

Problèmes rencontrés et solutions apportées

Nous avons rencontré plusieurs problèmes tout au long de notre projet. Nous nous sommes efforcés soit de les résoudre, soit de les contourner en utilisant d'autres moyens pour arriver à nos fins, notamment sur l'aspect le plus ardu : la programmation.

• Problème #1 : Absence d'espace libre sur le robot dans le montage initial pour insérer la foxboard.
  • Solution apportée : Création d'un espace de stockage à l'arrière du robot.

• Problème #2 : Le logiciel de programmation par blocs, bien qu'intuitif, ne nous permet pas d'arriver au degré de complexité auquel nous voudrions mener le robot.
  • Solution apportée : Passage à la programmation par lignes de code en langage NXC.

• Problème #3 : La difficulté d'intégration du gyroscope et ses valeurs variant trop rapidement le rendent trop compliqué à utiliser.
  • Solution apportée : Malgré le passage en "lowspeed" du capteur, il demeure compliqué, pour le moment. Nous préférerons d'abord travailler avec le compas, pour travailler avec les angles, plutôt que les vitesses de rotations.

• Problème #4 : Le robot semble avoir du mal à gérer le calcul des angles ET la rotation de ses moteurs.
  • Solution apportée : Allègement du programme. Le robot semble désormais mieux se comporter et fait ce qu'on lui demande sans négliger de commandes.

• Problème #5 : Le robot part toujours à droite quelle que soit la déviation.
  • Solution apportée : Réécriture du programme afin de distinguer plusieurs cas. Le robot corrige désormais efficacement dans la majorité des cas.

• Problème #6 : Le robot corrige dans le sens contraire lorsqu'il est autour du cap nord à cause de notre méthode de détection. (NB: Nous détaillerons ultérieurement la méthode plus bas).
  • Solution apportée : L'algorithme actuel est à travailler avec des modulos.

Algorithmes de programmation utilisés

Variables utilisées

On définit dans le programmes plusieurs variables à valeurs entières. Les voici :

• int chdg; >>> chdg pour "Current Heading", c'est le cap instantané du robot (en degrés).
• int shdg; >>> shdg pour "Start Heading", c'est le cap de référence au début de la trajectoire.
• int var; >>> C'est la variable "départ moins actuel" (shdg-chdg) utilisé pour l'algorithme décrit plus bas.
• int gauche; >>> C'est la distance vers l'obstacle le plus proche enregistré lorsque le robot tourne la tête à droite.
• int droite; >>> C'est la distance vers l'obstacle le plus proche enregistré lorsque le robot tourne la tête à gauche.

On définit, de même, des constantes :

• #define NEAR 30 >>> C'est la distance (en cm) à laquelle le radar de proximité ordonne au robot d'arrêter d'avancer.
• #define ERREUR 15 >>> C'est la marge d'erreur (en degrés) dans laquelle le robot considère que les variations de cap sont négligeables.
• #define P 40
• #define I 40 >>> Ce sont les variables utilisées lors du contrôle PID.
• #define D 90

Les algorithmes

• SetSensorLowspeed(IN_3); >>> Initialisation du radar : le capteur est lancé.
• SetSensorLowspeed(IN_4); >>> Initialisation de la boussole : le capteur est lancé.
• chdg = SensorHTCompass(IN_4); >>> shdg prend la valeur du cap et est fixée pour le moment.
• shdg = SensorHTCompass(IN_4); >>> chdg prend la valeur du cap courant.
• var =(shdg - chdg); >>> Cela est relativement transparent.

Si le robot est à une distance supérieure à NEAR alors

• Tant que le robot est à une distance supérieure à NEAR
  • Le robot avance
  • On actualise chdg
  • Si le robot dévie passé une certaine marge d'erreur alors
    • Tant que shdg est différent de chdg
      • On stoppe le robot
        • Si var est inférieur à 0 alors
        • On a dévié à gauche, on corrige à droite
        • On réactualise chdg
        • On réactualise var
      • Sinon
        • On a dévié à droite, on corrige à gauche
        • On réactualise chdg
        • On réactualise var
      • On réactualise chdg
    • Fin tant que
  • Fin si
• Fin tant que

Sinon

• Tant que le robot est à moins de NEAR d'un obstacle
  • On arrête le robot
  • Rotation du capteur de distance de 60° sur la gauche
  • Enregistrement de la distance avant un obstacle dans gauche
  • Rotation du capteur de distance de 120° à droite
  • Enregistrement de la distance avant un obstacle dans droite
  • Rotation du capteur de 60° à gauche pour retour au centre
  • Si gauche est inférieur ou égal à droite alors
    • Le robot fait une rotation pendant 2 secondes sur la droite
  • Sinon
    • Le robot fait une rotation pendant 2 secondes sur la gauche
  • Fin si
• On reset shdg au cap courant
• Fin tant que

Fin si
On arrête le robot

Le contrôle PID

Nous avons utilisé le contrôle PID dans la rotation du capteur à ultrasons, vulgairement appelé "tête" de notre robot. Celui-ci s'est avéré beaucoup plus simple dans l'action que nous souhaitions réaliser sur la rotation de la tête. Voici comment il a été implémenté. Nous avons introduit la syntaxe RotateMotorPID(OUT_B, 30, 60, P, I, D); où

• OUT_B représente la sortie B
• 30 est la puissance de la rotation
• 60 est l'angle de la rotation
• P, I et D sont des constantes définies au début du programme. Il n'est pas utile ici de détailler les fonctions de t permettant le calcul de P, I et D, mais il est en revanche utile de détailler l'utilité de ces trois variables :
  • P(t) rend le contrôleur plus rapide dans le temps mais il n'assure pas qu'il n'y ai aucune erreur d'équilibrage.
  • I(t) donne de la "mémoire" au contrôleur, dans un sens il accumules les traces d'erreurs et les compense, avec un zéro erreur de moyenne garantie.
  • D(t) donnes les "prédiction futures" au contrôleur ( comme la dérivée en maths ), ce qui accélère la réponse.

Le contrôle PID permet donc une précision sans erreur et donc de tourner la tête exactement où il faut en assurant son retour exact à la position de départ, permettant toujours à la "tête" de regarder pile devant le robot sans décalage au fil de ses rotations.

Avancées du projet

Synthèse des fonctionnalités :

• Le robot avance en ligne droite : OK
• Le robot corrige sa trajectoire si on l'en dévie : OK
• Rotation du capteur ultrason, appelé "tête" et enregistrement des valeurs retournées : OK
• Le robot se dirige vers le chemin le plus dégagé : OK
• Le robot corrige toujours vers le bon endroit, par exemple si il dévie vers la gauche il corrige à droite : PARTIEL, A AMELIORER
• Le robot avance en suivant une ligne de couleur : OK

Avancées

Le montage du robot est presque terminé

• Création de la page wiki du projet.

• Montage du robot.

Le montage du robot est presque terminé

• Fin du montage du robot.

• Câblage.

• Découverte et utilisation du logiciel de programmation par blocs (Lego Mindstorms NXT).

• Découverte du logiciel de programmation par ligne de code en NXC (Bricx).

• Test de plusieurs lignes de codes NXC sur le logiciel (Bricx)
  • Ligne droite
  • Rotation sur lui-même
  • Détection d'obstacle : réponse en tournant vers la gauche pour éviter
  • Rotation de la "tête" (capteur US) sur 120° et adaptation (changement de hauteur du capteur pour éviter la collision avec les puces ultérieurement...

• Implémentation du contrôle PID (Rotation de la tête).

• Réalisation d'un programme permettant au robot de capter les obstacles dans un champ de 120 degré par la rotation de la tête, et contournement de ces derniers.

• Avancées majeures de la page du projet
• Création d'un tâche sensor qui affiche le cap sur l'écran
• La tâche sensor assure aussi une rotation de la tête du robot pour intégrer, au futur, la possibilité de choisir le chemin le plus dégagé.

• Implémentation quasi-complète de la rotation de la tête : le robot enregistre désormais dans une variable gauche et droite la distance mesurée par ultrasons en tournant la tête vers ledit côté.
• Le robot choisit alors la plus grande distance dégagée entre la gauche et la droite, tourne, et emprunte ce chemin.

LE ROBOT MULTIFONCTIONS

Le suiveur de ligne

Nous avons tout d'abord cherché à intégrer le suiveur de ligne à notre robot. Pour cela, nous avons obtenu le code du groupe de Déborah Saunders & Jean Wasilewski. Cela permet au robot, en plus de ses fonctionnalités de base, de se diriger selon une ligne de couleur (normalisée verte pour tout le monde).
L'implémentation a été délicate car il faut placer la sonde à l'avant du robot, vers le bas, près du sol. Hors c'est là qu'était fixée la tête du robot. L'astuce a donc été de placer la tête au dessus du moteur plutôt qu'en dessous, la surelevant et laissant ainsi l'espace libre pour le capteur de couleur, sous le robot.

Le contrôle à distance

Nous avons ensuite intégré le programme de Kévin De Arriba et Alexandre Jouy, qui permet de contrôler le robot à distance. Le robot peut alors être contrôlé et répondre aux commandes via une interface web, en se connectant directement via Wi-Fi. Le principe, pour basculer en mode télécommande est de lui envoyer un octet dans la boite aux lettres n°3 dont les 4 bits de poids forts sont à zéro. Voici la signification de ces octets : valeur 0x00 (0) : arrêt du robot ; valeur 0x01 (1) : le robot avance ; valeur 0x02 (2) : le robot recule ; valeur 0x03 (3) : le robot tourne à gauche ; valeur 0x04 (4) : le robot tourne à droite ; valeur 0x05 (5) : le robot affecte à ses moteurs les valeurs trouvées dans les boites aux lettres n°5 et n°6. (Tiré de la page Wiki du groupe)