Suivi de ligne

[Alban42800]

Je reprend l'énoncé évoqué dans les mini-challenges :
Niveau de difficulté : Moyen

- Objectif : Faire un robot capable de suivre la ligne noire de la piste en ovale fournie avec le NXT. Le robot fait 10 tours et s'arrête.

- Contrainte : Pas de limite sur le nombre de modèles présentés, pas de limite dans le temps, aucune limite dans la quantité de pièces.
Pièces commercialisées par LEGO uniquement.
Le robot doit s'arrêter de lui-même sans utiliser d'éléments externes.

- Programmation : Pas de contraintes sur le langage utilisé.

Quelques remarques et conseils :
Vous pouvez optimiser le programme pour un seul sens de rotation et gagner en vitesse.
Vous pouvez optimiser le programme pour les 2 sens de rotation et gagner en polyvalence.
S'assurer que la distance entre le capteur de lumière et la piste reste constante (papier bien tendu et capteur bien fixé). Attention au Soleil qui modifie les valeurs lues par le capteur.


Edit le 08/02/2014 : ce topic avait été lancé dans le cadre d'un Exercice NXT. Suite à la suppression de cette rubrique, le sujet a été déplacé dans "De la théorie à la pratique".

[semtou]

heuuu ! alban 10 tours c'est un peu beaucoup pour moi. On peu pas faire juste un tour pour voir tu payes plus les piles ?

[Alban42800]

1 tour c'est niveau facile.
10 tours c'est pour montrer que c'est fiable. Le dernier que j'avais fait mettait 9 secondes pour faire un tour donc c'est pas long 10 tours.
Bien sur tu peux commencer par un tour.

[semtou]

Merci je me contenterai d'un tour alors et quand je t'arriverai à la cheville je passerai à la suite. Il me tarde de voir la vidéo des 9 secondes grand manitou

[Alban42800]

Pour commencer ton programme peut être très simple :
Si le capteur voit de la lumière tu actionne un moteur et s'il n'en voit pas tu actionne l'autre moteur.
Sinon, dans les samples LEJOS il y a déjà un programme tout fait, il ne te reste plus qu'à cliquer sur "Upload and RUN".

[semtou]

Oui j'ai déjà fais du suivi de ligne en RCX mais pas avec un grand succès au niveau de la fiabilité. J'irais voir les exemples mais j'ai déjà écrit des organigrammes que je voudrais tester.
A +

[Alban42800]

Pour terminer mon après midi robotique j'ai fais ce robot, et surtout mis au point un programme.

Edit : Vidéo dispo dans le 2éme message.

Le programme est on ne peut plus simple (une fois enlevé les "fioritures" permettant de déclarer les moteurs et les capteurs) :
En gros c'est une boucle avec un seul test dedans :
Si capteur de lumière détecte la ligne noire --> Moteur B à 10% et Moteur C à 40%
Sinon --> Moteur B à 40% et Moteur C à 15%

Cela m'a demandé tout de même de nombreux essais pour trouver les bonnes puissances de moteurs.
Le problème c'est de gérer "l'inertie" due au poid du robot et aux temps de réponses du Java.
Le robot avance constamment dans un état instable, soit en tournant à droite soit à gauche. Si tu tourne trop fort tu t'éloigne trop de la ligne et si tu tourne pas assez fort tu ne redresse pas assez la trajectoire...

Voici le programme complet :

Code: Tout sélectionner

import lejos.nxt.*;

/*** suivi de ligne oval **/
public class ColorDetector
{
public static void main(String [] args)
throws Exception
{
int deg;
LightSensor light = new LightSensor(SensorPort.S2);
// seuil lumineux = 40
// 10 tours = 28300 degrés
Motor.B.regulateSpeed(false); //init des moteurs
Motor.C.regulateSpeed(false);
Motor.B.resetTachoCount(); //reset compteurs de tours
Motor.C.resetTachoCount();
deg = 0;
Motor.B.backward(); // on démarre...
Motor.C.backward();
 
while ( deg < 28300 && (Button.readButtons() == 0) ) // tant que pas 10 tours
    {
    if ( light.readValue() > 40 ) // pas de ligne
        {// tourne à droite
        Motor.B.setPower(10);
        Motor.C.setPower(40);
        }
    else // sur la ligne
        { // tourne à gauche
        Motor.B.setPower(40);
        Motor.C.setPower(15);
        }
    deg = 0 - Motor.B.getTachoCount() - Motor.C.getTachoCount();
    }
LCD.drawInt(Motor.B.getTachoCount(), 4, 0, 0);
LCD.drawInt(Motor.C.getTachoCount(), 4, 0, 1);
Motor.B.stop();
Motor.C.stop();
Thread.sleep(5000);
}
}

Pour l'instant je met 10,8 secondes à faire un tour mais je vais améliorer ça si j'ai le temps (les moteurs sont à 40% actuellement)

[Alban42800]

Voici la vidéo :

[semtou]

Génial c'est rapide et fluide. J'aime aussi le robot sobre, avec se NXT on à l'impression qu'on a plus besoin des pièces de notre stock.
ça c'est du suivi de ligne.
a +

[roboleo]

Très rapide; intéressante l'idée de contrôler en jouant sur des puissances différentes de chacune des roues motrices. Quelle que soit la méthode, le bot serpente.
As-tu essayé avec un bot disposant d'une roue folle à l'arrière? Je ne suis pas certain de la même fluidité…

[Polo]

Je ne pense pas que la roue jockey telle qu'elle est sur ce MOC pose un problème niveau performance, car je trouve que c'est la méthode la plus simple et la moins adhérente que l'on puisse trouver. En tout cas, elle m'a bien fait rire, ta roue jockey ( enfin, si on peut vraiment l'appeler comme ça ). Cette simplicicité mise en oeuvre, c'est déroutant

[Alban42800]

Arf, c'est une roue folle, un peu folle
Bon, après j'ai essayé pendant 2 heures d'améliorer les perfs : Rien à faire, plus vite il finit dans le décors !
J'ai essayé de déplacer le capteur, largement devant la roue folle et aussi plus près de l'essieu moteur (actuellement le capteur est derrière la roue folle entre les deux grosses parties des moteurs). --> Sans succès, et placé trop près de l'essieux le programme ne peut plus du tout fonctionner.
Le robot met trop de temps à redresser sa trajectoire, temps de réponses trop long.

Problème : Quand le robot s'éloigne trop de la ligne il tourne beaucoup et arrive sur la ligne avec un angle tel qu'il ne peut plus reprendre la trajectoire.

Par exemple, supposons le capteur à gauche de la ligne sur la feuille : Il tourne à droite et arrive sur la ligne.
Ensuite il tourne à gauche et j'ai deux cas : Soit il ne réagit pas assez vite et sort à droite de la ligne (dans l'ovale) et retourne à droite --> le robot est perdu dans l'oval.
Soit je met trop la patatte dans le moteur et il part trop à gauche, du coup il s'éloigne trop de la ligne --> Problème

Le problème est de gérer les bonnes puissances et je pense que le Java met trop de temps à réagir et aussi que le moteur met trop de temps à atteindre la puissance demandée (je n'ai pas essayé avec la régulation à on).
Afin de limiter les différences de puissances (et donc améliorer les temps de réponse des moteurs) je pense qu'il faut diminuer la voie (distance entre les 2 roues motrices). A suivre...

[semtou]

Salut à tous voici ma contribution à ce petit jeu. Je suis repassé en NXT-G pour une après-midi de programmation.
J'ai gardé le robot contact comme base et voici les différentes méthodes que j'ai essayées :

* le classique une roue après l'autre en fonction de la luminosité reçu : noir moteur droit, blanc moteur gauche.
* la traversé de ligne noire d'un bord à l'autre en alternant les moteurs.
* l'éloignement et retour à la ligne avec une temporisation.
* la traversé de ligne noire avec une tempo de chaque coté pour fluidifié.
* la traversé de ligne avec tempo seulement d'un coté et vitesse différente pour chaque roue.
* un je m'éloigne en 2 temps : éloignement progressif et retour, plus je contrôle au retour, mon préféré.

bref je passe donc de 29 secondes au tour à seulement 7"80 au tour en une après midi ça occupe quand y une météo comme se weekend vaut mieux avoir des légos sous la main.

Un jeu de pile plus tard, voilà la vidéo :



Si vous connaissez d'autre méthode je suis comme d'habitude preneur. Merci a +

[Alban42800]

Très intéressant, et bravo pour la performance.
Par contre quelle est la fiabilité ? moi j'ai refusé tous mes programmes qui ne faisaient pas 10 tours car ils partaient en dehors de l'ovale au bout de 2 ou 3 tours.
Tu ne me laisse pas le choix : je dois faire mieux...
à bientôt...

[Thibaud]

WOw bravo semtou, il va falloir que je m'y mette aussi alors 7'80'' balaise quant même!!