Les fils de données

Introduction



Dans cette partie, nous allons aborder un des éléments les plus important dans la programmation en NXT-G.

Vous allez découvrir ici ce que sont les fils de données, les différents types de données qu'il transportent et comment s'en servir dans vos programmes.

Mais auparavant, nous allons voir très rapidement les blocs de capteurs de manière à pouvoir utiliser ces derniers avec les fils de données.

Une fois que ce concept vous sera acquis, vous serez en mesure de réaliser des programmes d'une certaine complexité.

Alors ne traîner pas et suivez le fil de données d'ariane .... :lol

Les blocs de capteurs



Dans les parties précédentes, lorsque nous avons vu les capteurs, vous les avez toujours gérés avec des blocs de flux. Comme le bloc "Attendre" par exemple.

Mais il existe une autre manière de gérer les capteurs, celle d'utiliser les blocs de capteurs de couleur jaune. Il en existe un pour chaque capteur et même pour des capteurs que vous ne possédez pas dans votre boîte d'origine, soit parce qu'il n'existe que dans la version LEGO MINDSTORMS NXT 1.0 ou éducation, soit simplement parce qu'il sont vendu séparément.


Faites donc bien attention avec votre ensemble NXT 2.0 de ne pas utiliser le bloc du "Capteur photosensible" ci-dessous, car celui-ci ne sert qu'avec le capteur photosensible de l'ensemble NXT 1.0 ou éducation.



C'est donc le bloc du "Capteur photosensible" qu'il vous faudra utilisez chaque fois que possible dans ce tutoriel, à la place du bloc "Capteur de couleurs", si vous disposez du capteur photosensible de l'ensemble NXT 1.0 ou éducation.

Bien évidemment, l'utilisation du mode capteur de couleurs ainsi que le bloc "Lampe de couleur" ne fonctionneront pas avec le capteur photosensible !


Voici à quoi ressemble le bloc "Capteur de couleurs" de votre ensemble NXT 2.0 :




Le capteur fonctionne ici exactement de la même façon que nous l'avons vu dans la partie concernant le capteur de lumière et vous remarquerez dans son panneau de configuration qu'il dispose des même options de paramétrage du capteur que dans les blocs de flux.

La seule différence réside dans le fait que ce type de bloc n'effectue ni pause, ni sortie de boucle et encore moins de commutation de programme comme le font les blocs de flux utilisant les capteurs.

Un bloc de capteur ne fait que scruter la valeur du capteur et de sortir cette donnée sur une prise de son plot de données.

Ainsi cette information est disponible pour être envoyé à d'autres blocs qui la traiteront pour exécuter une tache précise.

Ce type de bloc ne peut donc être utilisé qu'avec des fils de données.

Un bloc de capteur peut posséder plusieurs prise de données de différents type, comme par exemple le résultat de la comparaison de la valeur du capteur avec une valeur de déclenchement, et ainsi fournir plusieurs informations en même temps.

Une fois que le bloc de capteur a placé toutes ses informations sur ses prises de données, le bloc suivant est exécuté.

Les prises de son plot de données, comme n'importe quel autre bloc d'ailleurs, sont disponibles dans un onglet déroulant situé en bas à gauche du bloc.

Le fait de cliquer avec le bouton gauche de votre souris sur cet onglet vous permet de l'ouvrir complètement ou de le refermer.



L'image ci-contre montre le même bloc "Capteur de couleurs" avec son plot de données entièrement ouvert :



Retenez bien que les prises du côté gauche sont des entrées, c'est à dire qu'elles reçoivent une donnée provenant d'un autre bloc.

Alors que les prises du côté droit sont des sorties, c'est elles qui enverront une donnée vers un autre bloc.

Toutes les informations concernant la fonction et les valeurs admissible pour les prises de données, ainsi que toutes les informations de n'importe quel bloc, sont disponibles dans l'aide du logiciel LEGO MINDSTORMS NXT. Il vous suffit pour y accéder de cliquer sur la touche F1 de votre clavier ou de choisir l'option Sommaire et index du menu Aide :



Après ce bref aperçu des blocs de capteurs et des prises de données, intéressons-nous maintenant aux fils de données.

Les fils de données



Vous vous demandez peut-être ce que sont ces fameux fils de données, à quoi ils ressemblent et à quoi ils servent !

B'hein oui, c'est quoi ce truc ?

Alors, les fils de données sont un peu comme des fils électriques.

Mais dans un programme NXT-G, ils servent à transporter des informations entre les blocs de programmation.

Un fil de données relie la sortie d'un bloc à l'entrée d'un autre bloc.


Connexion entre blocs à l'aide d'un fil de données




Pour créer un fil de données, vous devez le « tirer » d'une prise de données d'un bloc.

Le pointeur de votre souris change de forme lorsqu'il se trouve au-dessus ou à proximité d'une prise de données.

Si vous cliquez avec le bouton gauche puis déplacez votre souris, vous « déroulez » un fil de données qui peut être connecté à une prise de données d'un autre bloc en cliquant à nouveau sur le bouton gauche.



Pour illustrer la connexion entre deux blocs par un fil de données, l'image suivante vous montre le même bloc "Capteur de couleurs" mais cette fois-ci configurer en capteur photosensible. Vous remarquerez que la sortie du capteur de lumière est reliée à l'entrée contrôle de puissance du bloc "Moteur".




Cacher les prises de données non utilisées




Noter que si vous refermez les onglets de ces blocs, ceux-ci se refermeront en ne laissant apparaître que les prises connectées à des fils de données.
Votre espace de travail sera ainsi moins encombré.




Comprendre les fils de données




La compréhension de ce programme est extrêmement simple.



Le capteur de lumière en mode photosensible mesure un certain niveau d'intensité de lumière représenté par une valeur entre 0 et 100, par exemple 63, qu'il place sur sa prise de sortie. Le fil de données transporte cette information vers l'entrée Puissance du bloc "Moteur". Celui-ci fera tourner le moteur en question à une vitesse déterminée par la valeur reçu sur son entrée Puissance donc, dans cet exemple, une vitesse de 63.

La vitesse du moteur dépendra donc de l'intensité de luminosité mesuré par le capteur de lumière.

Les paramètres d'un bloc dont leurs entrées ne reçoivent pas de fils de données prendront les valeurs indiquées dans le panneau de configuration de ce même bloc.

De même, les paramètres d'un bloc dont leurs entrées reçoivent un fil de données ne prennent plus en compte la valeur indiquée dans le panneau de configuration du bloc en question mais uniquement la valeur envoyée par le fil de données.



Ainsi, dans l'exemple ci-dessus, seul le paramètre Alimentation du bloc "Moteur" recevra sa valeur du fil de données et ignorera la valeur indiquée dans son panneau de configuration. Par contre, tout les autres paramètres du bloc "Moteur" se verront affecter les valeurs réglées dans le panneau de configuration.


Les types de données




Si vous êtes un peu observateur, vous aurez sans doute remarqué que le fil de données vu ci-dessus est de couleur jaune.

Ce n'est pas un hasard et cela a une signification bien précise.

En effet, la couleur d'un fil de données désigne le type de données qu'il transporte.

Il faut savoir qu'il existe trois types de données différentes dans un programme NXT-G.



Nous aurons l'occasion dans les pages suivantes de voir un à un tous ces types de données différentes.


Les fils de données coupés




Chaque fil de données transporte un type de données précis entre les blocs de programmation.

Par exemple, si un fil de données est tiré depuis une prise de sortie numérique d'un bloc, il transportera des données numériques.
Ce fil de données ne peut être connecté qu'à une prise d'entrée numérique du plot de données d'un autre bloc.

Si vous connectez un fil de données entre des prises traitant des types de données différents, par exemple une prise de sortie numérique à une prise d'entrée de texte, cela produira une erreur.

De telles erreurs de connexion créent des fils de données coupés, qui sont indiqués par une couleur grise.



Les programmes contenant des fils de données coupés ne peuvent pas être téléchargés sur le NXT.


Partager un fil de données entre plusieurs blocs




Un fil de données de sortie peut être utilisé par plusieurs blocs :



De plus, il peut y avoir transmission de données de la prise d'entrée à la prise de sortie si cette prise d'entrée comporte une prise de sortie correspondante. Ainsi les données sont transférées de la prise d'entrée à la prise de sortie sans être modifiées.

Donc, le programme ci-dessous est strictement identique à celui ci-dessus :



Toutefois, s'il n'y a pas de fil de données sur la prise d'entrée à gauche, il ne peut pas y avoir transmission de données et le fil sera également coupé.



Par contre, vous ne pouvez pas avoir plusieurs fils de données sur une prise d'entrée :



Ceci ne fonctionnera pas, et le fil sera donc là aussi coupé, car une prise d'entrée ne peut avoir qu'un seul fil de données.


Utiliser plusieurs fils de données




Noter également qu'un bloc peut fournir ou recevoir plusieurs fils de données simultanément :




Placement d'un fil de données sous d'autres blocs




Vous avez également la possibilité de connecter deux blocs séparés l'un de l'autre par plusieurs autres blocs.

Cela ne gène nullement, les blocs reliés par fils de données ne sont pas obligés de se trouver l'un à côté de l'autre :




Supprimer un fil de données




Enfin, pour supprimer un fil de données qui s'étire de gauche à droite entre deux prises de données, cliquez sur la prise de droite.



A présent, nous allons passer en revue tous ces types de fils de données et leur utilisation avec différents blocs de programmation.

Les données de type texte



Pour mettre en application l'utilisation de fils de données de type texte, je vous propose de créer un programme vous permettant d'afficher sur l'écran du NXT la valeur de luminosité mesuré par le capteur de lumière.

Toutefois, nous allons également voir l'utilisation de deux nouveaux blocs qui servent dans la gestion des fils de données de type texte et qui nous seront utiles dans le programme que nous voulons concevoir.

Tous d’abord, nous placerons un bloc "Boucle" de type infinie, dans lequel tous les autres blocs seront placés, de manière à ce que le programme s'exécute en permanence tant que vous n'y mettrez pas fin vous même.



Ensuite que faire ?

Et bien, nous placerons en premier lieu un bloc "Capteur de couleurs", configurer en capteur photosensible, qui renverra sous forme numérique la valeur de la luminosité mesuré par le capteur.



Hors, pour pouvoir afficher cette valeur sur l'écran du NXT, il faut utiliser un bloc "Afficher" qui n'accepte que des données de type texte sur son plot de données "Texte" !

D'ailleurs, si vous faite l'expérience suivante qui consiste à vouloir relier une sortie de type numérique, comme celle du bloc "Capteur de couleur", à une entrée de type texte, comme celle du bloc "Afficher", vous obtiendrez un fil de donnée coupé comme ci-dessous :



Le programme ne sera pas valide et ne pourra pas être téléchargé dans votre NXT.

C'est pour cette raison qu'existe le bloc "Nombre en texte" qui, comme son nom l'indique, transforme un nombre de type numérique en une chaîne de caractères de type texte.
Un texte étant une chaîne de caractères de n'importe quelle longueur.

Il est des plus simple à utiliser, puisqu'il suffit de lui fournir en entrée une donnée numérique pour que celle-ci soit transformée en texte et rendue disponible sur son plot de sortie.

Un exemple valant tous les discours, le programme suivant fonctionnerait très bien :



Toutefois, un nombre seul sur un écran ne dit pas grand chose en lui même s'il n'est pas accompagné de quelques mots indiquant à quoi correspond cette valeur et quelle est son unité de mesure !

C'est pour cela que nous utilisons un autre nouveau bloc, nommé tout simplement "Texte", qui permet de rajouter des mots dans notre chaîne de caractères de manière à créer une courte phrase.

Vous remarquerez que ce bloc est divisé en trois parties nommées A, B et C. Le bloc "Texte" peut regrouper ces trois parties de texte afin d'en faire un élément plus grand, comme une phrase.

Les trois parties de texte en entrée peuvent être tapés directement dans le bloc ou être fournis de manière dynamique par des fils de données. Le texte en sortie est transmis par un fil de données de type texte.

Ici, nous taperons directement le texte dans le bloc pour les parties A et C. La partie B sera fournie par la valeur du capteur préalablement transformée en chaîne de caractères.

Les mots suivants seront utilisés :



N'oubliez pas que les espaces sont importants et qu'ils ne seront ajoutés au texte en sortie que si vous les ajoutez au texte en entrée.
Ici, il y a un espace après le = de la partie A de manière à ne pas avoir la valeur du capteur qui soit collée au texte et un espace avant le % de la partie C pour la même raison.

Les accent n'étant pas supportés par l'écran du NXT, il ne faut donc pas en mettre sur le "é" de luminosité.

Le résultat de tout cela en sortie du bloc "Texte" sera donc, par exemple, la phrase suivante : Luminosite = 45 %.
La valeur réel dépendant, bien évidemment, de la mesure effectué par le capteur de lumière !

Voici donc ci-dessous le programme final à réaliser :








Et, comme vous l'avez vu précédemment dans ce tutoriel, vous pouvez rendre votre programme plus compact visuellement en cliquant sur les onglets des plots de données des deux derniers blocs de programmation telle que vous le montre l'image suivante :



Le programme ne change pas. Il reste exactement le même, prenant moins de place sur l'écran tout simplement.

Il reste tout compte fait très facile à comprendre.

Une boucle infinie, dans laquelle la valeur du capteur de luminosité est lue par un bloc "Capteur" puis transformée en chaîne de caractères à l'aide d'un bloc "Nombre en texte" pour obtenir une donnée de type texte à laquelle on rajoute quelques mots avec un bloc "Texte" et le tout est affiché sur l'écran du NXT grâce à un bloc "Afficher".

Simple non ? :p

Les données de type logique



Pour mettre en application l'utilisation de fils de données de type logique, je vous propose de créer un premier programme simple vous permettant d'allumer ou d'éteindre la lampe de votre capteur de lumière grâce au bouton orange situé sur votre NXT.

Voici donc le programme à réaliser :






Pas de panique, ce programme est très simple à comprendre.

Comme d'habitude, une boucle sans fin pour faire s'exécuter le programme en permanence.

A l'intérieure de celle-ci, juste deux petits blocs.

Le premier, un bloc "Capteur Boutons NXT" que l'on va laisser dans sa configuration par défaut puisqu'elle nous convient parfaitement.
Il fera changer l'état de sa sortie logique "Oui/Non", qui passera donc de l'état Faux à l'état Vrai, lorsque le bouton d'entrée orange sera enfoncé.
Comme l'indique le tableau ci-dessous tiré de la documentation du bloc "Capteur Boutons NXT".



Et le deuxième, un bloc "Lampe de couleur" lui aussi laissé dans sa configuration d'origine. C'est à dire en lampe de couleur rouge.
Ce dernier recevra cette donnée logique sur son plot d'entrée "Action", qui éteindra la lampe si la donnée vaut la valeur Faux et l'allumera si la donnée vaut la valeur Vrai.
Comme l'indique le tableau ci-dessous tiré de la documentation du bloc "Lampe de couleur".



Le résultat simple de cela est que, lorsque vous appuyez sur le bouton orange de votre NXT, la lampe s'allume.
Et que celle-ci s'éteint lorsque vous n'appuyez plus sur le bouton orange de votre NXT.

Toujours simple, non ... :lol


Utilisation du bloc "Commutation" avec les fils de données logique




Au même titre que n'importe quel autre bloc, le bloc "Commutation" est capable de recevoir et de gérer une donnée de type logique envoyé par un fil de donnée.

Pour illustrer ce propos, nous allons réaliser un programme presque aussi simple que celui ci-dessus.

Ce programme aura comme tâche de faire changer la couleur de la lampe du capteur de lumière en fonction de l'état, appuyé ou non, du bouton orange de votre NXT.

Mais attend là ...

Pourquoi passer par des fils de données pour faire ça, alors qu'il serait plus simple d'utiliser un bloc "Commutation" configuré en mode capteur de bouton NXT orange ?

C'est une très bonne question et je suis d'accord avec vous.

Mais je vous répondrez que ce programme n'est là que pour vous montrer la possibilité d'utiliser les fils de données avec un bloc "Commutation" et que, plus tard dans vos programmes, le fil de données ne viendra pas toujours d'un capteur mais probablement du résultat d'une comparaison précédente.

Et là, vous ne pourrait pas faire autrement que d'utiliser un fil de données avec votre bloc "Commutation".

Voici donc le programme à réaliser :








Là encore, pas de panique, c'est on ne peut plus simple.

Toujours cette boucle sans fin pour faire s'exécuter le programme en permanence.

A l'intérieur de celle-ci, un bloc "Capteur Boutons NXT" que l'on laisse dans sa configuration par défaut puisqu'elle nous convient parfaitement comme précédemment.
Il fera changer l'état de sa sortie logique "Oui/Non", qui passera donc de l'état Faux à l'état Vrai, lorsque le bouton d'entrée orange sera enfoncé.

Jusque là, rien de nouveau. C'est la même chose que le précédent programme.

La nouveauté se trouve au niveau du bloc "Commutation" qui cette fois ne sera plus contrôlé par un capteur, comme nous l'utilisions jusqu'ici, mais au contraire par une valeur.
C'est pourquoi il vous faut ici changer le paramètre Contrôle du bloc "Commutation" dans son panneau de configuration, pour le passer de l'option Capteur à celle de Valeur.

Vous remarquerez de ce fait, dans le panneau de configuration du bloc "Commutation", que les paramètres Capteur, Port et Action sont remplacées par de nouveaux paramètres nommées Type et Conditions.

Ces dernières, comme leurs noms l'indique, vous permettent d'indiquer le type de donnée que va recevoir le bloc "Commutation" ainsi que les conditions de commutation qui feront choisir au bloc le rayon de séquence qui sera exécuté par le programme.

Ici l'option Type utilisée sera celle par défaut puisqu'il s'agit du type logique et que c'est justement le type de donnée que devra traiter le bloc "Commutation". Notez qu'il existe autant de possibilités que de type de donnée, à savoir logique, numérique et texte.
Remarquez également à droite dans le panneau de configuration les conditions Vrai et Faux dans l'option Conditions.

Cela étant dit, le fonctionnement du bloc "Commutation" reste le même qu'auparavant.
Si la valeur de la donnée logique est vrai, c'est le rayon de séquence supérieur qui sera exécuté par le programme.
Si la valeur de la donnée logique est faux, c'est le rayon de séquence inférieur qui sera exécuté par le programme.

Du coup, tout s'explique simplement.

Si vous appuyez sur le bouton orange de votre NXT, la valeur renvoyée par le fil de donnée logique du bloc "Capteur Boutons NXT" est vrai et c'est donc le rayon de séquence supérieur du bloc "Commutation" qui sera exécuté par le programme. Donc le bloc "Lampe de couleur" configuré en couleur verte.

Si vous n'appuyez pas sur le bouton orange de votre NXT, alors la valeur renvoyée par le fil de donnée logique du bloc "Capteur Boutons NXT" est faux et c'est donc le rayon de séquence inférieur du bloc "Commutation" qui sera exécuté par le programme. Donc le bloc "Lampe de couleur" configuré en couleur bleu.

Ce n'est pas plus compliqué que ça ! :p

Notez également que vous avez la possibilité de faire rentrer un fil de données à l'intérieur d'un bloc "Commutation", mais uniquement si celui-ci est configuré dans son panneau de configuration pour ne pas être vue à plat.




Dans l'exemple ci-dessus, le résultat de la comparaison de la valeur de distance mesuré par le capteur d'ultrasons avec la valeur de déclenchement définit dans son panneau de configuration est envoyée par un fil de données logique au bloc "Commutation" alors que cette même valeur de distance est envoyée par un fil de données numérique à un bloc "Moteur".


Utilisation du bloc "Boucle" avec les fils de données logique




De même, le bloc "Boucle" est capable de recevoir et de gérer une donnée de type logique envoyé par un fil de donnée.

Pour illustrer ce propos, nous allons réaliser un programme très simple.

Ce programme aura comme tâche de jouer un son de sonar en boucle jusqu'à ce que le bouton orange de votre NXT soit pressé.
Une fois le bouton orange enfoncé, le programme sortira de la boucle et jouera un son d'applaudissement.

Ma question est la même que celle posée avec le bloc "Commutation" ...

Pourquoi passer par des fils de données pour faire ça, alors qu'il serait plus simple d'utiliser un bloc "Boucle" configuré en mode capteur de bouton NXT orange ?

C'est toujours une très bonne question et je suis toujours d'accord avec vous.
Mais ma réponse sera la même ... Ce programme n'est là que pour vous montrer la possibilité d'utiliser les fils de données avec un bloc "Boucle" et que, plus tard dans vos programmes, le fil de données ne viendra pas toujours d'un capteur mais probablement du résultat d'une comparaison précédente.

Et là, vous ne pourrait toujours pas faire autrement que d'utiliser un fil de données avec votre bloc "Boucle".

Voici donc le programme à réaliser :







Ici, la nouveauté se trouve au niveau du bloc "Boucle" qui cette fois sera contrôlé par un fil de données logique.

C'est pourquoi il vous faut ici changer le paramètre Contrôle du bloc "Boucle" dans son panneau de configuration, pour le passer à l'option Logique.

Vous remarquerez de ce fait, dans le panneau de configuration du bloc "Boucle", que le paramètre Jusque refait son apparition.
Le paramètre Jusque dispose de deux conditions de sortie de boucle, Vrai ou Faux.

Nous laisserons ici la condition par défaut, à savoir Vrai, puisqu'elle nous conviendra très bien pour ce programme.
Mais celle-ci peut très bien être configuré à Faux si le besoin s'en fait sentir dans un de vos programme.

Cela étant, le fonctionnement du bloc "Boucle" reste le même qu'auparavant.
Tant que la condition n'est pas remplie, la boucle continue d'exécuter les blocs se trouvant à l'intérieur d'elle-même.
Si la condition est remplie, alors le programme sort de la boucle et exécute les blocs suivants.

Du coup, dans le cas comme ici où la condition de sortie de boucle est configurer sur Vrai, l'explication est simple.

Si vous n'appuyez pas sur le bouton orange de votre NXT, alors la valeur renvoyée par le fil de donnée logique du bloc "Capteur Boutons NXT" est faux. Dans ce cas, la boucle continue l'exécution du bloc "Son" configuré pour jouer un son de sonar jusqu'à ce que sa condition de sortie de boucle soit remplie.

Si vous appuyez sur le bouton orange de votre NXT, la valeur renvoyée par le fil de donnée logique du bloc "Capteur Boutons NXT" est vrai, la condition de sortie de boucle est remplie et donc le programme sortira de la boucle et exécutera le bloc "Son" configuré pour jouer un applaudissement.

Ce n'est pas très compliqué, avouer ! :p

Les données de type numérique



Attend, STOP ....

On a déjà vu les données de type numérique au début de cette partie, tu rabâche ou quoi !!!

Mais non, mais non ...

J'ai introduit, il est vrai, au début de cette partie les données de type numérique et leurs utilisation avec d'autres blocs comme les blocs "Moteur" par exemple.

J'ai fait un survol rapide car la mise en application pratique de ce type de fils de données se fera dans les parties suivante.

Toutefois pour être complet dans mes propos, je voudrais ici vous parler de l'utilisation des fils de données de type numérique avec les blocs "Boucle" et "Commutation".


Utilisation du bloc "Boucle" avec les fils de données numérique




Pour mettre en application l'utilisation de fils de données de type numérique avec un bloc "Boucle", je vous propose de créer un programme vous permettant de visualiser sur l'écran de votre NXT les valeurs renvoyées par le compteur d'un bloc "Boucle".

Visualiser le compteur d'un bloc "Boucle" .... J'ai jamais vu ça moi, t'es ouf comme mec toi !

En fait, si vous êtes un peu observateur, vous aurez sans doute remarqué le paramètre Montrer dans le panneau de configuration du bloc "Boucle" :



Ce paramètre Montrer vous permet justement, comme on peut le deviner par son nom, de montrer la prise de données correspondant au compteur du bloc "Boucle" lorsque la case de ce paramètre est coché.

Dans ce cas, une prise de données apparait sur le côté gauche du bloc "Boucle" :



Cette prise est disponible sur toutes les boucles quelque soit leur mode de contrôle.

La donnée fournie par cette prise est de type numérique et correspond au nombre de fois que la boucle s'est exécutée.

De fait, la première fois que le programme entre dans une boucle, comme elle ne s'est encore jamais exécutée, la valeur fournie sur sa prise de données nommée Nombre de boucles est 0.

Lorsque la boucle s'exécutera à nouveau, la valeur disponible sur sa prise de données Nombre de boucles sera 1.

Et ainsi de suite, chaque fois que la boucle s'exécute, son compteur est augmenté de 1.

Pour visualiser cela, je vous propose de créer le programme suivant :







Ce programme est d'une simplicité absolue et vous ne devriez pas rencontrer de soucis de compréhension à votre niveau.

La première fois que le programme entre dans la boucle, il prend la valeur disponible sur sa prise de données Nombre de boucles, la transforme en chaîne de caractère à l'aide d'un bloc "Nombre en texte" puis l'envoi sur un bloc "Afficher" pour pouvoir visualiser cette valeur sur l'écran du NXT.

Ensuite, le programme attend 5 secondes grâce à un bloc "Attendre" configuré comme il se doit.

Une fois le temps passé, la boucle s'exécute de nouveau et son compteur est augmenter de 1.

L'affichage de cette nouvelle valeur sur l'écran du NXT permet de voir le nombre de boucles effectué par le programme.

Vous pouvez donc voir tranquillement que toute les 5 secondes le programme exécute les blocs dans la boucle et fournit le nombre de boucles effectuées sur l'écran du NXT.
Et cela de manière infini.

Bref, rien de bien compliqué la dedans. ;)

Réalisons maintenant un autre programme utilisant le compteur de boucle, mais cette fois-ci plus rapide et permettant de visualiser autrement l'information fournie par ce compteur.

Ce programme sera plus rapide car il ne disposera plus d'une temporisation de 5 secondes dû au bloc "Attendre", qui n'était placé dans le programme précédent que par soucis de compréhension et de confort de lecture sur l'écran du NXT, mais d'une temporisation de seulement 0,1 seconde (soit 100 millisecondes).

L'information du compteur sera également visualisé, sur l'écran du NXT, non plus sous forme de chiffres, mais sous formes graphiques.

En effet, le but de ce programme est de dessiner un cercle dont le rayon augmente graduellement lors de l'exécution du programme.

Cela pourrait ressembler à l'écran de base d'un sonar actif d'un bateau, et c'est d'ailleurs pour ça que l'on va y rajouter un son de sonar ... Rien que pour la forme ! :p

Voici donc le programme que je vous propose de réaliser :








Le programme commence simplement par un bloc "Son" qui joue un son de sonar actif, histoire de faire ambiance.
Noter que la case du paramètre Attendre de son panneau de configuration est décoché de manière à ne pas attendre la fin du son avant d'exécuter les blocs suivants.

Il est suivi d'un bloc "Boucle" configuré en mode Compteur pour que la boucle ne s'exécute que 60 fois, et la prise de données du compteur sera rendu visible en cochant la case du paramètre Montrer.

A l'intérieur de la boucle, un premier bloc "Afficher" configurer de tel sorte qu'il dessine un cercle à partir du centre de l'écran dont le rayon sera déterminé par la valeur envoyée par le compteur de la boucle.
De sorte que plus le nombre de boucles exécutées par le programme est grand, plus le rayon du cercle dessiné est grand.

Une petite temporisation de 0,1 seconde est placée dans la boucle de manière à avoir le temps de visualiser l'agrandissement graduel du cercle sur l'écran du NXT.

Une fois les 60 boucles effectuées, un dernier bloc "Son" jouera un son OK nous informant qu'aucun contact sonar n'a été détecté ! :lol

Bref, voila une belle illustration de l'utilisation d'un fil de données numérique avec un bloc "Boucle".


Utilisation du bloc "Commutation" avec les fils de données numérique




Pour mettre en application l'utilisation de fils de données de type numérique avec un bloc "Commutation", je vous propose de créer un programme vous permettant de visualiser sur l'écran de votre NXT la couleur détecté par le capteur de lumière configuré en mode capteur de couleur.
Le tout accompagné par le son correspondant, en anglais, nous indiquant cette couleur.

Le principe de ce programme reste simple à comprendre.

Le capteur de couleur est capable de discerner 6 couleurs différentes, chacune représentée par un chiffre de 1 à 6 :

  1. Black : Noir
  2. Blue : Bleu
  3. Green : Vert
  4. Yellow : Jaune
  5. Red : Rouge
  6. White : Blanc



C'est une de ces valeurs qui est disponible sur la prise de données nommée "Couleur détectée" du bloc "Capteur de couleurs" lorsque celui-ci détecte une couleur.

Cela représente donc 6 possibilités de choix pour le programme, qui seront gérés par un bloc "Commutation".

Chacune de ces possibilités fera donc en sorte que le programme joue le son correspondant à la couleur détecté et affichera le nom de cette couleur sur l'écran du NXT.

Pour commencer, plaçons une habituel boucle infinie :




Mettons un bloc "Capteur de couleurs" dans cette boucle :




Disposons ensuite un bloc "Commutation" configuré en contrôle par valeur de type numérique :



Vous remarquerez, sur la droite du panneau de configuration du bloc "Commutation", qu'il existe uniquement 2 conditions de commutation pour le moment.
Cela vient du fait que le bloc "Commutation" est vue à plat et que, dans ce type d'affichage, il ne peut y avoir que 2 rayons de séquence visible.



Hors, nous venons de voir dans l'énoncé de principe du programme que nous aurons besoin de 6 conditions correspondant chacune aux 6 couleurs détectable.

Pour remédier à cela, il existe un bouton + sur la droite du panneau de configuration du bloc "Commutation" qui vous permet de rajouter des conditions au bloc "Commutation".
De plus, notez pour information que le bouton - juste en dessous de ce dernier vous permet de supprimer des conditions.

Toutefois, vous pouvez également voir que ce bouton + n'est pas disponible pour l'instant car le mode d'affichage du bloc "Commutation" est toujours configuré sur une vue à plat !

Commencez donc par supprimer la vue à plat du bloc "Commutation" en décochant la case du paramètre Afficher :



Ce faisant, vous libérez le bouton + qui permet de lui rajouter des conditions.

Et vous changer également l'affichage du bloc "Commutation" :



Les 2 onglets présent actuellement sur le bloc "Commutation" représente les 2 conditions avec leur rayon de séquence respectif.

Nous allons maintenant rajouter les 4 conditions qui nous manquent pour notre programme, de manière à en obtenir 6 au total.

Pour faire cela, il vous suffit de cliquer 4 fois sur le bouton + à droite du panneau de configuration :



Maintenant nous avons bien nos 6 conditions, mais un souci persiste.

En effet, si vous regardez bien la colonne de droite du paramètre Conditions, vous vous apercevez que les valeurs de ces conditions s'échelonnent de 0 à 5 alors que notre capteur de lumière nous fournira des valeurs allant de 1 à 6 !!!

Vous devez donc à présent modifier les valeurs des conditions pour quelles correspondent aux valeurs que le capteur de lumière enverra au bloc "Commutation".

Pour ce faire, il faut d'abord sélectionner la condition à modifier dans le paramètre Conditions du panneau de configuration, puis changer sa valeur dans le champ situé juste en dessous du tableau des conditions.

Commencer par la dernière condition, la numéro 6, puis affecter lui la valeur 6 au lieu de la valeur 5 actuelle :



Ensuite, continuer pour toutes les autres conditions, jusqu'à la première, de manière à leurs affecter comme valeur le chiffre correspondant à leur numéro de conditions (valeur 5 pour la condition 5, valeur 4 pour la condition 4, ...)

Enfin, il reste encore un petit détail de moindre importance à régler. Celui de la condition par défaut.

La condition par défaut est celle qui sera exécutée par le programme lorsque la valeur transmise au bloc "Commutation" ne correspond à aucune des valeurs des conditions définies dans le paramètre Conditions du panneau de configuration.

Actuellement, il s'agit de la condition numéro 2 qui est choisie comme condition par défaut.
Cela est visible dans le tableau du paramètre Conditions grâce à la petite coche situé devant le numéro de la condition.

Cela pourrait très bien convenir, mais ici nous allons décider de sélectionner la condition numéro 1 comme condition par défaut .

Ce réglage se fait simplement en sélectionnant la condition à définir par défaut et en cliquant sur le bouton étoile * situé en bas à droite du panneau de configuration :



La condition numéro 1 est à présent configuré comme étant celle par défaut, la petite coche visible devant elle en témoigne :



Voila, vous disposez à présent d'un bloc "Commutation" à 6 conditions, de valeurs s'échelonnant de 1 à 6, ce qui correspond aux valeurs envoyées par le capteur de lumière, et la condition numéro 1 est définie comme étant la condition par défaut.

Il ne vous reste plus qu'à tirer un fil de données du bloc "Capteur de couleur" jusqu'au bloc "Commutation".

Rajouter ensuite un bloc "Son" et un bloc "Afficher" pour chaque condition du bloc "Commutation" en cliquant auparavant sur son onglet respectif :



Les onglets sont au nombre de 6, le numéro 1 étant le plus à gauche et le numéro 6 étant le plus à droite.

Une infobulle vous indiquant son numéro s'affiche lorsque vous pointez votre souris sur un onglet et la ligne correspondante du tableau des conditions se trouve surligner en orange lorsqu'un onglet est sélectionné.

Vous ne pouvez donc pas vous tromper de conditions.

Chaque bloc "Son" et chaque bloc "Afficher" doit être configuré de manière unique en respectant, pour chaque numéro de condition, la couleur correspondante.

Voici, en rappel, le tableau de correspondance entre valeurs et couleurs :

  1. Black : Noir
  2. Blue : Bleu
  3. Green : Vert
  4. Yellow : Jaune
  5. Red : Rouge
  6. White : Blanc



Ainsi pour la condition numéro 1, à laquelle on a affecté la valeur 1 et qui correspond donc à la couleur noire, le bloc "Son" devra jouer le son "Black" sans attendre la fin avant que le bloc "Afficher" ne place sur l'écran du NXT la phrase "Couleur noire" :




Configurer comme il se doit chaque bloc "Son" et "Afficher" pour chaque condition, en respectant le tableau ci-dessus.

Pour finir, nous placerons un bloc "Attendre" configuré en mode capteur de bouton NXT orange enfoncé après le bloc "Commutation" :




Cela permettra au programme d'attendre que l'on appuie sur le bouton orange du NXT pour effectuer une nouvelle détection de couleur, afin d'éviter que le NXT ne répète en boucle le nom de la couleur.

Ce qui pourrait être agaçant !!! :siffle

Voila, c'est en fait plus long à écrire qu'à faire.

L'utilisation de ce programme est simple.

Lancer le programme, placer le capteur de lumière devant une couleur et appuyer sur le bouton orange de votre NXT pour qu'il vous indique par le son et le texte la couleur détectée.

Tout ça conclu pour de bon cette partie consacrée aux fils de données.

Conclusion



Voici donc la fin d'un relativement long chapitre consacré à la découverte et à l'utilisation des fils de données.

Ces fils de données vous permettrons de faire des programmes bien plus complexe et intelligent à l'avenir.

Nous allons d'ailleurs voir dès la partie suivante l'utilisation de ces fils de données dans un programme destiné à commander un robot bien réel.

Alors, comme d'habitude, je vous donne rendez-vous à la prochaine partie.