Les blocs mathématiques

Introduction



Dans cette partie nous allons découvrir les blocs mathématiques fournit avec votre logiciel LEGO MINDSTORMS NXT.

Ces blocs sont très utiles pour effectuer toutes sortes de calculs et de comparaisons dans vos programmes.

Nous verrons donc chacun de ces blocs indépendamment, puis une application pratique un peu loufoque mettra en œuvre tout ces blocs.

Cela donnera, à n'en pas douter, un peu plus de capacité à vos machines et robots sortie de votre imagination fertile.

Alors, comme se plaisait à dire mon professeur de mathématique, "aujourd'hui, excitation psychomathématique !". :heink

Le bloc Math



Ce bloc exécute des opérations arithmétiques simples telles que addition, soustraction, multiplication et division. Le bloc peut également calculer des valeurs absolues et des racines carrées.




Le bloc "math" possède un plot de données avec deux prises d'entrée à gauche et trois prises de sortie à droite. Les nombres en entrée pour l'équation arithmétique peuvent être tapés ou fournis dynamiquement par des fils de données.

La sortie fournissant le résultat de l'équation sera transmise par la prise de sortie inférieure #, à laquelle vous devez connecter un fil de données relié au plot de données d'un autre bloc. Les deux prises de sortie en face des prises d'entrée permettent, si nécessaire, de transmettre les nombres en entrée à d'autres blocs.

Le menu déroulant permet de choisir l'une des six opérations arithmétiques que vous pouvez effectuer :



Addition

Dans ce cas, les deux nombres en entrées sont additionnés et la somme est envoyée à la sortie.

Entrée A + Entrée B = Sortie

Exemple : 50 + 2 = 52

Soustraction

Dans ce cas, le second nombre entré est soustrait du premier, la différence étant envoyée à la sortie.

Entrée A - Entrée B = Sortie

Exemple : 50 - 2 = 48

Multiplication

Dans ce cas, les deux nombres en entrées sont multipliés et le résultat est envoyé à la sortie.

Entrée A x Entrée B = Sortie

Exemple : 50 x 2 = 100

Division

Dans ce cas, le premier nombre entré est divisé par le second, le quotient étant envoyé à la sortie.

Entrée A / Entrée B = Sortie

Exemple : 50 / 2 = 25

Valeur absolue

En mathématiques, la valeur absolue d'un nombre est sa valeur numérique sans tenir compte de son signe.

Dans ce cas, la valeur absolue du premier nombre en entrée sera envoyée à la sortie.

delim{|}{Entree A}{|} = Sortie

Exemple : delim{|}{50}{|} = 50
Exemple : delim{|}{-50}{|} = 50

Racine carrée

En mathématiques, la racine carrée d’un nombre réel positif x est le nombre positif dont le carré vaut x.

Dans ce cas, la racine carrée du premier nombre en entrée sera envoyée à la sortie.

sqrt{Entree A} = Sortie

Exemple : sqrt{50} = 7,071


Programme d'exemple




Voici un petit programme très simple vous permettant de visualiser le résultat des différentes opérations possibles avec ce bloc :







Son fonctionnement est des plus simple.

Le bloc "math" effectue une addition des deux nombres, 50 et 2, entrés dans son panneau de configuration.

Le résultat du calcul, ici la valeur 52, est fournit par un fil de données à un bloc "Nombre en texte" qui se charge de la convertir en chaîne de caractère pouvant être afficher sur l'écran du NXT.

Cette chaîne de caractère est transmise, une fois encore par un fil de données, à un bloc "Afficher" configuré comme il se doit pour afficher un texte. Ce dernier fera s'afficher le résultat de l'opération sur l'écran du NXT.

Enfin, une petite temporisation de 5 secondes est effectuée à l'aide d'un bloc "Attendre" pour permettre de voir le résultat avant que le programme ne se termine.

Vous pouvez tester les différents type d'opération que le bloc "math" peut effectuer en gardant les même valeurs d'entrée, afin d'en voir les différents résultat.

Vous pouvez aussi changer les valeurs d'entrée et vérifier que même des valeurs décimales, donc des nombres avec des virgules, donne un bon résultat.

Voila concernant le bloc "math", voyons maintenant un autre bloc mathématique.

Le bloc Aléatoire



Ce bloc génère un nombre aléatoire, c'est à dire un nombre au hasard. Vous pouvez utiliser des nombres aléatoires pour générer un comportement imprévisible sur votre robot.




Le nombre aléatoire généré est compris entre des limites minimale et maximale que vous devez définir. Si vous voulez générer des nombres aléatoires entre 5 et 10, fixez la valeur minimale à 5 et la valeur maximale à 10. Si vous ne voulez pas que 5 et 10 figurent parmi les nombres aléatoires possibles, fixez la valeur minimale à 6 et la valeur maximale à 9.

Fixez les limites minimale et maximale à l'aide de la glissière ou en entrant des valeurs dans la zone de saisie. Pour obtenir un nombre dynamique, branchez des fils de données en entrée au plot de données du bloc.

La sortie du bloc ne peut être envoyée que via un fil de données à partir de la prise de valeur en sortie #.

Définissez les limites minimale et maximale en tirant les deux glissières ou en entrant des nombres. La limite supérieure de la glissière est fixée à 100 ; toutefois, si vous entrez une valeur dans la zone de saisie, vous pouvez fixer la limite supérieure au-delà de 100. Vous pouvez également entrer un nombre négatif dans la zone de la limite minimale ; ce nombre supplantera la valeur de la glissière. Pour fixer les limites minimale et maximale de manière dynamique, branchez des fils de données en entrée au plot de données du bloc.


Programme d'exemple




Voici un petit programme très simple vous permettant de visualiser le fonctionnement de ce bloc :







Son fonctionnement est très simple également.

Une boucle permettra au programme de fonctionner de manière répétée.

A l'intérieur de celle-ci, un bloc "Aléatoire" générant un nombre au hasard.

Ce nombre aléatoire est transmit par fil de données à un bloc "Nombre en texte" pour le convertir en chaîne de caractère.

Cette chaîne de caractère étant envoyée ensuite, toujours par un fil de données, à un bloc "Afficher" qui se charge de l'affichage sur l'écran du NXT.

Enfin, un bloc "Attendre" configurer pour attendre un appui sur le bouton Orange du NXT, permet de visualiser le nombre aléatoire sur l'écran du NXT en stoppant temporairement l’exécution du programme jusqu'à une action sur ce même bouton Orange qui fera boucler le programme pour lui faire afficher un autre nombre aléatoire.

Bref, rien de difficile pour le moment.

Voyons donc encore un autre bloc mathématique.

Le bloc Comparer



Ce bloc peut déterminer si un nombre est supérieur, inférieur ou égal à un autre nombre.
Les nombres en entrée peuvent être tapés ou fournis de manière dynamique par des fils de données.




Un bloc "Comparer" possède un plot de données avec deux prises d'entrée à gauche et trois prises de sortie à droite. Les deux prises d'entrée doivent être connectés à d'autres blocs à l'aide de fils de données, sauf si l'une des prises d'entrée reçoit une valeur constante que vous entrez.

La sortie résultant de la comparaison sera transmise à partir de la prise de sortie inférieure, à laquelle vous devez connecter un fil de données relié au plot de données d'un autre bloc. Les deux prises de sortie en face des prises d'entrée permettent, si nécessaire, de transmettre les valeurs en entrée à d'autres blocs.

Le menu déroulant permet de choisir l'une des cinq comparaisons disponibles :



Supérieur à (A>B)

Dans ce cas, si le premier nombre entré est supérieur au second nombre entré, le bloc "Comparer" renvoie la valeur « Vrai ». Dans le cas contraire, il renvoie la valeur « Faux ».

Si Entrée A > Entrée B, Sortie = « Vrai »

Inférieur à (A<B)

Dans ce cas, si le premier nombre entré est inférieur au second nombre entré, le bloc "Comparer" renvoie la valeur « Vrai ». Dans le cas contraire, il renvoie la valeur « Faux ».

Si Entrée A < Entrée B, Sortie = « Vrai »

Égal à (A=B)

Dans ce cas, si le premier nombre entré est égal au second nombre entré, le bloc "Comparer" renvoie la valeur « Vrai ». Dans le cas contraire, il renvoie la valeur « Faux ».

Si Entrée A = Entrée B, Sortie = « Vrai »


Programme d'exemple




Voici un petit programme vous permettant de vérifier le fonctionnement de ce bloc :












Voici le fonctionnement de ce programme.

Le début du programme est exactement le même que le programme d'exemple du bloc "Aléatoire", à savoir une boucle dans laquelle un bloc "Aléatoire" génère un nombre au hasard qui sera transformé en chaîne de caractère par un bloc "Nombre en texte" pour être afficher sur la ligne 4 de l'écran du NXT à l'aide d'un bloc "Afficher".

Ensuite, ce même nombre aléatoire est envoyé par un fil de données sur la prise d'entrée A d'un bloc "Comparer" configuré pour comparer si le nombre aléatoire fournit via cette entrée A est supérieur ou non au nombre 50 entré dans son panneau de configuration.

Si le nombre aléatoire est supérieur à 50, la sortie du bloc "Comparer" sera « Vrai ».

Si le nombre aléatoire est inférieur à 50, la sortie du bloc "Comparer" sera « Faux ».

Juste après ce bloc "Comparer" vient un bloc "Commutation" configurer, lui, en commutateur sur valeur logique qui reçoit le signal logique « Vrai » ou « Faux » envoyée par la sortie du bloc "Comparer".

Selon que le signal logique soit « Vrai » ou « Faux », c'est à dire que le nombre aléatoire soit supérieur ou inférieur à 50, le bloc "Commutation" va exécuter le rayon de séquence supérieur ou inférieur.

Ces rayons de séquence contiennent tout les deux un bloc "Afficher" permettant d'inscrire un texte, est plus grand ou est plus petit,sur la ligne 5 de l'écran du NXT.

Un dernier bloc "Afficher" fait suite au bloc "Commutation" pour afficher une dernière phrase, que 50 ,sur la ligne 6 de l'écran du NXT.

Enfin, un bloc "Attendre" configurer pour attendre un appui sur le bouton Orange du NXT, permet de visualiser le tout sur l'écran du NXT en stoppant temporairement l’exécution du programme jusqu'à une action sur ce même bouton Orange qui fera boucler le programme pour générer un autre nombre aléatoire et effectuer une autre comparaison.

Voila qui clôture cette partie sur le bloc "Comparer".

Voyons donc encore une fois un autre bloc mathématique.

Le bloc Plage



Ce bloc peut déterminer si un nombre se trouve dans une plage de nombres ou en dehors. Les nombres en entrée peuvent être tapés, définis à l'aide des glissières ou fournis de manière dynamique par des fils de données. Le signal logique en sortie, « Vrai » ou « Faux », est transmis par un fil de données.




Un bloc "Plage" possède un plot de données avec trois prises d'entrée à gauche et quatre prises de sortie à droite. Les prises d'entrée peuvent être connectés à d'autres blocs à l'aide de fils de données, sauf si un ou plusieurs des prises d'entrée reçoit un nombre que vous entrez.

La sortie logique du bloc "Plage" sera transmise à partir de la prise de sortie inférieure, à laquelle vous devez connecter un fil de données relié au plot de données d'un autre bloc. Les trois prises de sortie en face des prises d'entrée permettent, si nécessaire, de transmettre les nombres en entrée à d'autres blocs.

Le nombre de test peut être tapé ou fourni de manière dynamique par un fil de données. La zone de test est grisée si un fil de données est connecté.

Les limites inférieure et supérieure peuvent être définies à l'aide de la glissière, être entrées ou être fournies de manière dynamique par des fils de données. Les zones de saisie sont affichées en grisé lorsque des fils de données sont connectés.

Le menu déroulant permet de choisir l'une des deux opérations disponibles :



Dans la plage

Dans ce cas, si le nombre de test se trouve entre les limites inférieure et supérieure ou est égal à l'un des nombres limites, le bloc "Plage" renvoie une valeur « vrai ». Dans le cas contraire, il renvoie la valeur « Faux ».

Hors de la plage

Dans ce cas, si le nombre de test se trouve en dehors des limites inférieure et supérieure et n'est pas égal à l'un des nombres limites, le bloc "Plage" renvoie une valeur « vrai ». Dans le cas contraire, il renvoie la valeur « Faux ».


Programme d'exemple




Voici un petit programme vous permettant de vérifier le fonctionnement de ce bloc :












Voici le fonctionnement de ce programme.

En fait, le fonctionnement de ce programme est similaire au programme d'exemple du bloc "Comparer".

Seuls les textes des blocs "Afficher" sont à changer.

Nous trouvons donc une boucle dans laquelle un bloc "Aléatoire" génère un nombre au hasard qui sera transformé en chaîne de caractère par un bloc "Nombre en texte" pour être afficher sur la ligne 4 de l'écran du NXT à l'aide d'un bloc "Afficher".

Ensuite, ce même nombre aléatoire est envoyé par un fil de données sur la prise d'entrée valeur de test d'un bloc "Plage" configuré pour vérifier si le nombre aléatoire fournit via cette entrée se trouve ou non dans la plage de nombres allant de 25 à 75 comme indiqué dans son panneau de configuration.

Si le nombre aléatoire est dans la plage entre 25 et 75, la sortie du bloc "Plage" sera « Vrai ».

Si le nombre aléatoire est hors de la plage allant de 25 à 75, la sortie du bloc "Plage" sera « Faux ».

Juste après ce bloc "Plage" vient un bloc "Commutation" configurer, lui, en commutateur sur valeur logique qui reçoit le signal logique « Vrai » ou « Faux » envoyée par la sortie du bloc "Plage".

Selon que le signal logique soit « Vrai » ou « Faux », c'est à dire que le nombre aléatoire soit dans la plage ou hors de la plage allant de 25 à 75, le bloc "Commutation" va exécuter le rayon de séquence supérieur ou inférieur.

Ces rayons de séquence contiennent tout les deux un bloc "Afficher" permettant d'inscrire un texte, dans la plage ou hors de plage,sur la ligne 5 de l'écran du NXT.

Un dernier bloc "Afficher" fait suite au bloc "Commutation" pour afficher une dernière phrase, de 25 a 75 ,sur la ligne 6 de l'écran du NXT.

Enfin, un bloc "Attendre" configurer pour attendre un appui sur le bouton Orange du NXT, permet de visualiser le tout sur l'écran du NXT en stoppant temporairement l’exécution du programme jusqu'à une action sur ce même bouton Orange qui fera boucler le programme pour générer un autre nombre aléatoire et effectuer une autre vérification.

Voila qui clôture la partie sur le bloc "Plage".

Voyons donc pour finir un dernier bloc mathématique.

Le bloc Logique



Ce bloc applique une opération logique à ses entrées et envoie la réponse vrai/faux via un fil de données. Les entrées, qui doivent également être de type « vrai » ou « faux », peuvent être définies à l'aide des cases d'option ou être fournies de manière dynamique par des fils de données.




Un bloc "Logique" ouvre possède un plot de données avec deux prises d'entrée à gauche et trois prises de sortie à droite. Les prises d'entrée doivent être connectés à d'autres blocs à l'aide de fils de données, sauf si l'un d'eux reçoit une valeur constante que vous définissez à l'aide de cases d'option.

La sortie résultant de l'opération logique sera transmise à partir de la prise de sortie inférieure, à laquelle vous devez connecter un fil de données relié au plot de données d'un autre bloc. Les deux prises de sortie en face des prises d'entrée permettent, si nécessaire, de transmettre les valeurs en entrée à d'autres blocs.

Les quatre opérations logiques que ce bloc peut exécuter permettent d'effectuer une série de comparaisons :



Opération « Et »

Dans le cas d'une opération « Et », si vos deux valeurs en entrée sont toutes deux vraies, la sortie vaut elle aussi « vrai ». Dans tous les autres cas, la sortie vaut « faux ».

Ce principe s'explique aisément à l'aide d'un « tableau de logique » :

Entrée A Entrée B Sortie
Faux Faux Faux
Faux Vrai Faux
Vrai Faux Faux
Vrai Vrai Vrai


Comme vous pouvez le constater, la réponse n'est « vrai » que quand les deux valeurs en entrée sont vraies ; dans tous les autres cas, la réponse est « faux ».

Opération « Ou »

Dans le cas d'une opération « Ou », si l'une de vos valeurs en entrée, ou les deux, sont vraies, la sortie vaut « vrai ».

Entrée A Entrée B Sortie
Faux Faux Faux
Faux Vrai Vrai
Vrai Faux Vrai
Vrai Vrai Vrai


Opération « XOu »

Dans le cas d'une opération « XOu », si l'une de vos valeurs en entrée est vraie, mais pas les deux, la sortie vaut « vrai ».

Entrée A Entrée B Sortie
Faux Faux Faux
Faux Vrai Vrai
Vrai Faux Vrai
Vrai Vrai Faux


Opération « Pas »

L'opération « Pas » est parfois baptisée « inversion ». Cette opération n'emploie qu'une valeur en entrée. Si la valeur en entrée est vraie, la sortie vaut « faux » ; si la valeur en entrée est fausse, la sortie vaut « vrai ». Cette opération se contente donc d'inverser la valeur en entrée.

Entrée A Sortie
Vrai Faux
Faux Vrai



Programme d'exemple




Voici un petit programme vous permettant de vérifier le fonctionnement de ce bloc :










Voici le fonctionnement de ce programme.

Une boucle dans laquelle se trouve deux blocs "Capteur Boutons NXT", l'un configuré "Bouton gauche" l'autre "Bouton droite", dont leurs valeurs logique de sortie sont envoyées par fils de données aux entrée A et B d'un bloc "Logique" configurer en opération « Ou ».

La sortie de ce même bloc "Logique" étant envoyée par un fil de données à un bloc "Commutation" contrôlé par une valeur logique.

Ce dernier exécutant, selon que la valeur de sortie du bloc "Logique" soit « Vrai » ou « Faux », le rayon de séquence supérieur ou inférieur sur lesquelles se trouve sur chacun d'eux un bloc "Afficher" permettant d'afficher sur l'écran du NXT une illustration représentant une coche pour indiquer « Vrai » ou une croix pour indiquer « Faux ».

Comme il s'agit ici d'une opération « Ou », l'illustration de la croix sera visible si aucun bouton n'est enfoncé et l'illustration de la coche sera visible si l'un ou l'autre des boutons est enfoncé ou les deux en même temps.

Vous pouvez ainsi faire des essais avec les autres opérations logique « Et » ou « XOu » et visualiser le résultat de la sortie du bloc "Logique".

Voila qui clôture la partie sur le bloc "Logique".

Voyons donc enfin un exemple pratique un peu fou de l'utilisation de tous ces blocs mathématiques.

Le robot fou



Comme application pratique des blocs mathématiques, je vous propose de réaliser un programme permettant à votre robot de simuler la folie.

En effet, ce programme fait en sorte que le robot se déplace de manière totalement aléatoire que ce soit en avant, en arrière, à droite ou à gauche et cela à des vitesses elles aussi complétement aléatoires.

Mais ce n'est pas tout car ce robot générera quelques sons dans certaines circonstances !

Il criera « Hooray » s'il va tout droit, « System Overload » s'il s'arrête et rigolera lorsqu'il tournera rapidement à droite ou à gauche.

Bref, un robot fou fou fou ... :lol

Ce programme ne sert pas à grand chose, mais permet de mettre en application les blocs mathématiques dans leur ensemble.

Nous utiliserons la plate-forme de base pour ce programme.

Voyons donc maintenant ce programme de folie.


Le programme du robot fou




Voici le programme vous permettant de réaliser un robot totalement fou :

(Cliquez sur la miniature du programme pour l'agrandir.) :

Robot fou


















Et voici comment fonctionne ce programme.

D'abord et avant tout, une boucle sans fin permettant au programme de s’exécuter indéfiniment.

Vient alors trois blocs "Aléatoire" envoyant un nombre au hasard par leurs fils de données :

  1. Le premier génère un nombre entre 0 et 100 servant à fournir une vitesse aux moteurs.
  2. Le second génère un nombre entre -100 et 100 permettant de virer plus ou moins vers la gauche ou vers la droite.
  3. Le troisième génère un nombre entre 0 et 100 qui, après comparaison, servira à déterminer la direction du déplacement du robot.


Comme indiqué ci-dessus, le bloc suivant est un bloc "Comparer" configuré pour vérifier si le nombre envoyé par le troisième bloc "Aléatoire" est inférieur à 50 ou non.

La sortie logique « Vrai » ou « Faux » de ce bloc servira à déterminer la direction, en marche avant ou en marche arrière, du déplacement du robot.

Vient ensuite le bloc "Déplacer", qui reçoit par des fils de données, les informations des blocs précédent et qui permet d'actionner de manière illimité les moteurs du robot conformément au tableau ci-dessous fournit dans la documentation du logiciel.



Ces blocs se suffisent à eux mêmes pour faire adopter au robot un déplacement aléatoire.

Mais nous allons rajouter d'autres blocs permettant de lui faire émettre quelques sons qui amplifieront son apparente folie.

Ainsi, après le bloc "Déplacer", se trouve un bloc "Son" jouant le son Hooray uniquement lorsque le robot va exactement en ligne droite.

En effet, le prise de données contrôle de ce bloc "Son" est reliée par un fil de données au second bloc "Aléatoire" via le bloc "Déplacer".

Comme ce bloc "Aléatoire" génère un nombre entre -100 et 100 et que celui-ci détermine le sens du virage du robot, lorsque le nombre généré sera exactement égale à zéro, ce qui correspond à ne tourner ni à droite ni à gauche, cela autorisera le bloc "Son" à lire son fichier sonore en vertu du tableau ci-dessous tiré également de la documentation concernant le bloc "Son".



Pour toutes les autres valeurs, le fichier son ne sera pas joué par le bloc "Son".

Et comme ce second bloc "Aléatoire" peut générer des nombres négatif, le bloc "Math" suivant est configuré pour obtenir en sortie de celui-ci la valeur absolue de ces nombres. C'est à dire le même nombre qu'en entrée mais sans le signe + ou -.

Cette valeur absolue servira pour un des blocs "Plage".

Les deux blocs "Plage" qui suivent permettent de vérifier si les nombres générés sont dans une certaine plage de valeurs :

  1. Le premier vérifie si la valeur de direction se trouve dans la plage allant de 75 à 100.
  2. Le second vérifie si la valeur de puissance, donc de vitesse du robot, se trouve dans la plage allant de 80 à 100


Notez au passage que cette même valeur de puissance est transmise également à la prise de données contrôle d'un second bloc "Son" jouant le son System Overload uniquement lorsque le robot à une vitesse nul égale à 0.

Les sorties logiques des deux blocs "Plage" sont envoyées au bloc "Logique", configuré en opération « Et », dont la sortie ne sera « vrai » que lorsque le robot tournera très fortement (75 à 100) à droite ou à gauche et cela à grande vitesse (80 à 100).

Dans ce cas, et uniquement dans ce cas, le bloc "Commutation" suivant exécutera le rayon de séquence supérieur jouant un son de rire à l'aide du troisième bloc "Son".

Enfin, un bloc "Attendre" fera exécuter une pause d'une demi seconde au programme avant que celui-ci ne boucle sur lui même générant trois nouveaux nombres aléatoire pour un autre comportement du robot.

Voila donc le programme d'un robot complément zinzin.

Pour finir ce tutoriel en beauté et être complet dans mes propos, je vous décrit rapidement dans le paragraphe suivant les blocs mathématiques fournit par la société HiTechnic qui se révèlent être très pratique dans nos programmes.

Les blocs mathématiques de HiTechnic



La société HiTechnic, bien connu pour ses capteurs certifiés LEGO, a publiée sur son blog des articles indiquant la mise à disposition de blocs de programmation NXT-G.

Pour importer ces nouveaux blocs mathématiques dans votre logiciel NXT-G, rendez-vous sur cette page qui vous explique comment le faire.

Concernant les fichiers des programmes d'exemple, ils devront être décompressé et placés dans le répertoire approprié (Documents/LEGO Creations/MINDSTORMS Projects/Profiles/Default).


Les blocs HiTechnic Sin/Cos et ATan2




Ces deux blocs permettent le calcul de fonctions trigonométriques telles que sinus, cosinus et Arc tangente.

Ces blocs vous serviront lorsque vous désirerez effectuer des calculs plus complexe comme passer de coordonnées cartésiennes à des coordonnées polaires ou utiliser un capteur d'accélération comme inclinomètre.

Ils sont disponible en deux versions.
Une version ne gérant que les nombres entiers est destinée aux utilisateurs de la version 1.0 du logiciel NXT-G.
Une autre version gérant les nombres décimaux (à virgule flottante) est destinée aux utilisateurs de la version 2.0 du logiciel NXT-G.

Ils sont réputés rapides (calcul de l'ordre de 0,5 à 0,8 ms) et d'une précision d'au moins 6 chiffres pour les versions 2.0 (+ / - 0,000001) !!!



Le bloc HiTechnic Sin/Cos



Ce bloc calcul les valeurs du sinus et du cosine d'un angle Theta.

Une manière simple de visualiser ces valeurs est d'imaginer un cercle unitaire, c'est à dire ayant un rayon de 1, comme sur l'image de droite.

Le sinus vous donne la valeur sur l'axe vertical Y et le cosinus vous donne la valeur sur l'axe horizontal X.

Notez que ces valeurs sont signés, ce qui veut dire qu'elles ont un signe positif ou négatif (+ ou -).

Le sinus sera négatif si l'angle Theta est compris entre 180° et 360°.

De même, le cosinus sera négatif si l'angle Theta est compris entre 90° et 270°.

Notez également que le sinus et le cosinus se répète à l'infini dans chaque direction, de sorte que le sinus d'un angle Theta de 3610° vous donne le même résultat qu'un angle Theta de 10°puisque 3610° représente 10 fois un cercle de 360° + un angle Theta de 10°.

Vous pouvez télécharger ce bloc sur les pages suivantes :



Voici à quoi ressemble ce bloc pour la version 2.0 :




La valeur de l'angle Theta est entrée directement dans le panneau de configuration à l'aide du paramètre Angle ou fournit par un fil de données sur la prise de données de gauche.

Pour ce bloc, l'angle Theta peut être indiqué dans les unités degrés ° ou radians à l'aide du paramètre Units.

Les valeurs du sinus et du cosinus de cet angle Theta se trouvent sur les prises de sorties à droite du plot de données et dans une plage allant de -1 à 1 avec une précision d'au moins 6 chiffres (+ / - 0,000001).


Vous trouverez un programme d'exemple pour la version 2.0 de ce bloc sur cette page.

Le bloc pour la version 1.0 ressemble beaucoup à celui de la version 2.0, sauf que celui-ci n'accepte que l'unité degrés ° pour l'angle Theta et que les valeurs de sorties, d'une plage allant de -100 à 100, sont multipliées par 100.

De sorte que si une sortie vous fournie le nombre 87 par exemple, cela correspondra à une valeur de 0,87.

Vous trouverez un programme d'exemple pour la version 1.0 de ce bloc sur cette page.

Vous pouvez essayer réellement ce programme d'exemple sur le bloc "Sin/Cos" sur votre NXT et étudier ce programme pour comprendre comment il fonctionne, c'est un très bon exercice.



Le bloc HiTechnic ATan2



Ce bloc prend deux valeurs, X et Y, puis calcule l'angle Theta correspondant par rapport à l'axe X comme montré sur l'image de droite.

En termes simples, l'angle Theta est égal à l’arc tangente de Y/X.

Ce bloc prend également en compte le signe de X et de Y pour qu'il puisse déterminer correctement l'angle Theta n'importe où le long du cercle unitaire.

Par exemple, l'angle Theta sera positif si Y est positif et il sera négatif si Y est négatif.

Vous pouvez télécharger ce bloc sur les pages suivantes :



Voici à quoi ressemble ce bloc pour la version 2.0 :




Les valeurs de X et de Y sont entrés directement dans le panneau de configuration à l'aide des paramètres X et Y ou fournit par des fils de données sur les prises de données de gauche.

La valeur de l'angle Theta se trouve sur la prise de sortie à droite du plot de données, dans une plage allant de -180° à 180° en degrés et de -pi à pi en radians.

Là encore, pour ce bloc l'angle Theta de sortie peut être exprimé dans les unités degrés ° ou radians à l'aide du paramètre Units du panneau de configuration.


Vous trouverez un programme d'exemple pour la version 2.0 de ce bloc sur cette page.

Quant au bloc pour la version 1.0, il fournit la valeur de l'angle Theta dans une plage allant de -179° à 180°.

Vous trouverez un programme d'exemple pour la version 1.0 de ce bloc sur cette page.

Vous ne pourrez peut-être pas essayer réellement ce programme d'exemple sur le bloc "ATan2" si vous ne possédez pas de capteur accéléromètre, mais il vous est toujours possible d'étudier ce programme pour comprendre comment il fonctionne.



Le bloc HiTechnic Limit Number



Ce bloc est conçu pour limiter la portée d'un nombre.

Vous pouvez télécharger ce bloc sur cette page.

Il prend en entrée une certaine valeur ainsi qu'une valeur minimal et maximal.

Si la valeur d'entrée est dans l'intervalle entre les valeurs minimal à maximal, alors la valeur de sortie est simplement le même nombre que la valeur d'entrée.

Si la valeur d'entrée est en dehors de l'intervalle, l'une des deux opérations de limitation sera appliquée à cette valeur d'entrée :



Voici le fonctionnement de ces deux opérations :


L'opération Clamp




Cette opération ne fait que limiter une valeur dans une certaine plage.

Si la valeur d'entrée est inférieure à la valeur minimal, la valeur de sortie est égale à cette valeur minimal.

Si la valeur d'entrée est supérieure à la valeur maximal, la valeur de sortie est égale à cette valeur maximal.

Sinon la valeur de sortie est la même que la valeur d'entrée.

Par exemple, disons que vous faites un calcul et que vous avez une valeur de puissance que vous voulez envoyer aux moteurs. Le problème est que la plage de valeurs de vos blocs de mathématiques va au-delà ce que vous voulez envoyer aux moteurs. Ce bloc va limiter la valeur de puissance entre 0 et 75 par un simple réglage de la valeur minimal à 0 et de la valeur maximal 75.

Dans cet exemple, le panneau de configuration du bloc devrait ressembler à ceci:




L'opération Wrap Around




Cette opération enroule la valeur d'entrée autour d'une certaine plage.

Tout dépassement d'une valeur limite par la valeur d'entrée se répercute dans la plage de sortie à partir de la limite opposé.

Cela paraît compliqué à expliquer, mais c'est pourtant très simple à comprendre.

Par exemple, si vous utilisez un capteur boussole, vous pouvez avoir un besoin de normaliser un angle en degré dans une plage particulière tel que de 0° à 360° ou -180° à 180°.

Imaginons que vous travaillez sur un programme qui a besoin de trouver la direction opposée par rapport au capteur boussole.

Une manière de trouver l'opposé d'un angle est d'ajouter 180°.

Si l'angle fournit par le capteur boussole est de 30° et que vous ajoutez 180° vous obtenez 210°. Jusque-là pas de problème.

Mais que se passe t-il quand la sortie du capteur boussole est de 270° ?

Si vous ajoutez 180° vous obtenez 450° !!!

Dans ce cas, vous pouvez utiliser ce bloc configuré en opération Wrap Around pour enrouler la valeur d'entrée autour de la plage allant de 0° à 360°.

Votre programme pourrait donc ressembler à ceci :



Lorsqu'il est utilisé de cette manière, la valeur de sortie sera automatiquement normalisée de telle sorte que les 450° de la valeur d'entrée soit enrouler autour de la plage allant de 0° à 360° et que le résultat en sortie fournisse une valeur de 90°.

En effet, 450° - 360° = 90°.

Ces 90° ce répercuteront à partir de la limite opposé, à savoir la valeur minimal égale à 0°, et donnera donc 0° + 90° = 90°.

Notez que le panneau de configuration de ce bloc dispose d'un indicateur de rétroaction sur le côté gauche dans le champ d'orange.

Cela rend facile le test des fonctionnalités de ce bloc.

Vous pouvez entrer des valeurs d'entrée dans le paramètre Number et voir le résultat sur la valeur de sortie dans la zone de rétroaction sur le côté gauche.

Notez également la liste déroulante du paramètre Preset qui vous permet de choisir parmi quatre réglages communs :



L'utilisation d'un de ces préréglages est facultatif et vous pouvez aussi choisir un réglage personnalisé en choisissant l'option Custom dans cette même liste déroulante.

Voila qui clôt cette partie consacrée aux blocs mathématiques de la société HiTechnic.

Conclusion



Voici la fin de cette longue partie consacrée aux blocs mathématiques.

Tous ces blocs vous serviront à donner une certaine capacité de calcul à vos programmes.

Vous êtes enfin prêt pour concevoir des programmes un peu plus complexes.

Mais il nous reste encore à voir comment mémoriser dans nos programmes certaines valeurs afin de les complexifier encore un peu plus.

Ce sera l'objet d'une prochaine partie.