Programmer son NXT!

Tout ce tutoriel est codé avec le logiciel RobotC pour Lego Mindstorms. Pour plus d'info aller voir: notre tutoriel sur le logiciel RobotC

Les Capteurs

Tout au long de ce tutoriel nous allons utiliser l'écran du NXT pour afficher les valeurs retournés par les différents type de capteur. Pour ne pas vous perdre voici une brève explication de comment afficher du texte ou des variables sur l'écran.

Pour afficher quelque chose sur l'écran du NXT il faut utiliser la fonction nxtDisplayTextLine(); avec quelques paramètres que je vais vous décrir. Mais avant il faut que je vous explique que l'écran du NXT est séparé en /// 7 lignes chacune pouvant recevoir des informations de la longueur de l'écran. La fonction nxtDisplayTextLine(); va prendre en compte 2 paramètres : Le numéro de la ligne sur laquelle vous voulez écrire et le texte à afficher. Un exemple :


nxtDisplayTextLine(2, "Bonjour !");
                                        

Vous pouvez de plus afficher la valeur de variable comme ceci :


nxtDisplayTextLine(2, "%d", maVariable); // Pour une variable de type int
nxtDisplayTextLine(2, "%s", maVariableString); // Pour une variable de type String
nxtDisplayTextLine(2, "%f", maVariableFloat); // Pour une variable de type float
                                        

Capteur de contact

Un capteur de contact est un capteur logique qui va retourner 1 ou 0 selon son etat. Pour faire plus clair la valeur retourner par la capteur si il est préssé sera 1 /// et si il est relaché sera 0. Il sert notamment à detecter des obstacles ou des fins de courses. Nous l'utiliserons pour savoir si le robot rencontre un mur lorsqu'il avance.

Pour commencer il faut indiquer à notre programme qu'un capteur est présent. Pour cela tout en haut du programme il faut rajouter cette ligne :


#pragma config(Sensor, S1,     capteurContact, sensorTouch)
                                        

Essayons de décrypter un peu cette ligne :

  • Sensor : Décrit le type de composant électrique branché, ici un capteur.
  • S1 : Le Sensor Port ou est branché votre capteur. Il y en à 4 sur le NXT, ici sur le port 1 (les numéro sont indiqués sur le NXT)
  • capteurContact : Le nom donnée au capteur pour pouvoir y faire référence dans le code.
  • sensorTouch : Le type de sensor branché il y comme possibilité : ///
Une fois Notre capteur déclaré nous allons maintenant voir comment afficher la valeur retourné par celui ci. Pour commencer nous allons déclarer une variable de type int pour récupérer la valeur renvoyé par le capteur:


int valeurCapteurContact;
                                            

Puis nous allons utiliser la fonction SensorValue(nomCapteur); pour récupérer la valeur. Il nous suffira de la stocker dans la variable valeurCapteurContact puis de l'afficher. Cela nous donne :


#pragma config(Sensor, S1,     capteurContact,         sensorTouch)

task main()
{
    int valeurCapteurContact;
    while(1)
    {
        valeurCapteurContact = SensorValue(capteurContact);
        nxtDisplayTextLine(2, "%d", valeurCapteurContact);
    }
}
                                            

Vous savez maintenant comment récupérer la valeur d'un capteur de contact et la valeur de ses deux états. Pour moi c'est 1023 pour le bouton relacher et 183 pour le bouton appuyer.
Nous allons Maintenant reprendre la fonction avancer que l'on a vu précédemment. Vous vous souvenez que l'on arrêtait les moteurs lorsque la cible était atteinte? Et bah nous allons juste rajouter une condition dans la boucle disant que si la valeur du capteur n'est plus égale à 0 (bouton relaché) on arrête aussi les moteurs. Pour faire cela nous allons utiliser l'opérateur "ET" s'écrivant && en programmation. Ce qui nous donnera une condition de boucle comme ceci : while(nMotorRunState[motorA] != runStateIdle && valeurCapteurContact == 0){}
Ce qui nous donne au final :


#pragma config(Sensor, S1,     capteurContact, sensorTouch)

void avancerContact(int tour);

task main()
{
    avancer(600);//On avance avec une cible egale a 600
    wait1Msec(1000); //On fait une pause de 1 seconde
    avancer(1200); On avance avec une cible de 1200
}

void avancerContact(int tour)//fonction avancer
{
    int valeurCapteurContact;

    nSyncedMotors = synchAB; //on sychronise les deux moteurs, le moteur A dirige
    nSyncedTurnRatio = 100; //On met les deux moteur a la meme vitesse
    nMotorEncoder[motorA] = 0; //On reinitialise l'encodage du moteur
    nMotorEncoderTarget[motorA] = tour; //on definit la valeur envoye en parametre comme la cible  atteindre
    motor[motorA] = 60; //On met la puissance du moteur a 60%

    valeurCapteurContact = SensorValue(capteurContact);
  
    while(nMotorRunState[motorA] != runStateIdle && valeurCapteurContact == 0)//Tant qu'on  pas atteint la cible ou que le bouton n'a pas été enfoncé
    {
        valeurCapteurContact = SensorValue(capteurContact);// On est obligé de relire la valeur du capteur en continue pour que la condition de la boucle s'effectue.
    }
    motor[motorA] = 0;//Une fois la cible atteinte on remet le moteur a 0
}
                                            

A noter que l'on pourrai directement utiliser un appel à la fonction pour faire notre condition : while(nMotorRunState[motorA] != runStateIdle && SensorValue(capteurContact) == 0). Mais il est important que vous compreniez que cette fonction retourne une valeur sur laquelle vous pouvez travaillez comme n'importe quel nombre.

Capteur de distance ultrason

Un capteur à ultrason est un capteur qui va retourner une valeur comprise entre 0 et 1024 associé à une distance. La fonction de RobotC récupérant cette valeur va directement la convertir en centimètre donc vous n'avez pas à vous en soucié pour le moment. Son fonctionnement repose sur l'envoie d'ultrason qui vont, à chaque obstacle, faire des rebonds et retourné sur le capteur. La capteur va alors mesurer le temps entre l'envoie et la reception de ces ultrasons pour en déduire la distance.

Comme pour le capteur de contact il va falloir le définir, déclaré une variable pour recevoir la distance retourné par le capteur et utiliser la fonction qui retourne cette distance. Voilà un exemple de fonctionnement qui va afficher la distance sur l'écran du NXT:


#pragma config(Sensor, S2,     capteurUltrason,    sensorSONAR) // Configuration pour un capteur à ultrason, faîtes attention au numéro du port de sortie.

task main()
{
    int valeurCapteurUltrason;
    while(1)
    {
        valeurCapteurContact = SensorValue(capteurUltrason);
        nxtDisplayTextLine(2, "%d", valeurCapteurUltrason);
    }
}
                                        

Et voici une fonction faisant avancer le robot jusqu'à ce que la distance soit inférieur à celle indiquée en paramètre ou que la cible soit atteinte.


#pragma config(Sensor, S2,     capteurUltrason,    sensorSONAR) 

void avancerObstacle(int tour, int distance);

task main()
{
    avancerObstacle(3600,20);//On avance avec une cible egale a 600
}

void avancerObstacle(int tour,int distance)//fonction avancer
{
    int valeurCapteurUltrason;

    nSyncedMotors = synchAB; //on sychronise les deux moteurs, le moteur A dirige
    nSyncedTurnRatio = 100; //On met les deux moteur a la meme vitesse
    nMotorEncoder[motorA] = 0; //On reinitialise l'encodage du moteur
    nMotorEncoderTarget[motorA] = tour; //on definit la valeur envoye en parametre comme la cible  atteindre
    motor[motorA] = 60; //On met la puissance du moteur a 60%

    valeurCapteurUltrason = SensorValue(capteurUltrason);
  
    while(nMotorRunState[motorA] != runStateIdle && valeurCapteurUltrason > distance)//Tant qu'on  pas atteint la cible ou que la distance est supérieur à celle indiqué
    {
        valeurCapteurUltrason = SensorValue(capteurUltrason);// On est obligé de relire la valeur du capteur en continue pour que la condition de la boucle s'effectue.
    }
    motor[motorA] = 0;//Une fois la cible atteinte on remet le moteur a 0
}
                                        

Capteur de couleurs

Avant toute chose pour bien comprendre comment récupérer une couleur il faut comprendre comment fonctionne un capteur de couleur. Celui ci va allumer une de ces trois led, ou les trois en même temps, pour iluminer une surface celle ci, selon sa couleur va en absorber certaine et en revoyer d'autre. Le capteur va alors récupérer ces couleurs renvoyé et regarder celles qui ont été absorbés. Il va alors renvoyer une valeur correspondante à la couleur capté. Il va ensuite regarder de quelle couleur générale cette valeur est la plus proche pour indiquer à l'utilisateur ce qu'il attend.

Selon les couleurs à capter la précision est meilleure avec certaines led en effet si la couleur à capter absorbe surtout du rouge il vaut mieu l'illuminer avec du rouge /// pour avoir plus de précision.
En général vous utiliserez les trois led en même temps cela permettant la meilleure précision sur toute la plage de valeur. Pour déclarer le capteur en mode full color utilisez cette ligne:


#pragma config(Sensor, S3,     capteurCouleur,        sensorColorNxtFULL)
                                        

Voici maintenant les valeurs retourné par le capteur correspondant aux couleurs:

  • noir = 1
  • bleu = 2
  • vert =3
  • jaune = 4
  • rouge =5
  • blanc = 6
Faisons maintenant avancer notre robot jusqu'à ce que celui-ci detecte un changment de couleur.
Pour faire cela je vais vous donner la ligne pour récupérer la valeur du capteur puis après ce sera comme d'habitude: int valeurCapteurLumiere = SensorValue(couleur)


#pragma config(Sensor, S3,     capteurCouleur,        sensorColorNxtFULL) 

void avancerCouleur();

task main()
{
    avancerCouleur();//On avance avec une cible egale a 600
}

void avancerCouleur(int tour,int distance)//fonction avancer
{
    int valeurCapteurCouleur;
    int valeurCouleurOriginal; 

    nSyncedMotors = synchAB; //on sychronise les deux moteurs, le moteur A dirige
    nSyncedTurnRatio = 100; //On met les deux moteur a la meme vitesse
    nMotorEncoder[motorA] = 0; //On reinitialise l'encodage du moteur
    nMotorEncoderTarget[motorA] = tour; //on definit la valeur envoye en parametre comme la cible  atteindre
    motor[motorA] = 60; //On met la puissance du moteur a 60%

    valeurCapteurCouleur = SensorValue(capteurCouleur);
    valeurCouleurOriginal = SensorValue(capteurCouleur);
  
    while(valeurCapteurCouleur == valeurCouleurOriginal)//Tant qu'on  a pas changé de couleur
    {
        valeurCapteurCouleur = SensorValue(capteurCouleur);// On est obligé de relire la valeur du capteur en continue pour que la condition de la boucle s'effectue.
    }
    motor[motorA] = 0;//Une fois la cible atteinte on remet le moteur a 0
}
                                            

Retrouver ici un programme avec toutes les fonctions déjà implémenté pour n'avoir qu'à les appeler pour contrôler votre robot.

Plus de tutoriel sur la programmation du NXT arriverons bientôt notamment sur comment faire le meilleur suivie de ligne possible ou sur la programmation par taches permettant de rendre votre robot plus réactifs ! Suivez-nous sur les réseaux sociaux pour rester au courant !