TI Codes : TI-Nspire™ et TI-Innovator™ Hub

Dans cette première leçon de l’unité 1, Vous allez utiliser l’éditeur de programme pour écrire un ensemble de commandes qui contrôle une diode sur le Hub TI-Innovator™.

Objectifs :

• Utiliser l’éditeur de programme de TI-Nspire
• Utiliser la commande Send( pour contrôler une diode lumineuse sur le Hub TI-Innovator
• Introduire la commande Wait
• Temporiser le Hub TI-Innovator et la calculatrice

Connecter le Hub TI-Innovator à la TI-Nspire CX. La calculatrice est mise sous tension. Sur le Hub TI-Innovator, une diode verte s’illumine, celle-ci indique que le Hub TI-Innovator est prêt à recevoir des commandes.

Afin d’apprendre à programmer une calculatrice avec le Hub TI-Innovator, vous serez conduits à apprendre la programmation de deux mondes connectés : la calculatrice et le Hub TI-Innovator.

Lorsque vous écrirez un programme dans la calculatrice, vous utiliserez l’éditeur de programmes que l’on trouve dans le menu de l’application Calculs de la calculatrice. L’instruction Send est utilisée pour envoyer des instructions au Hub TI-Innovator™ afin de produire une réaction physique (allumer une lampe, produire un son, faire tourner un moteur, etc).

• Les commandes du Hub TI-Innovator™ se trouvent dans l’éditeur de programmes, au sous menu HUB.

Setting up the LIGHT Program

Votre premier programme commandera le TI-Innovator Hub pour mettre sous tension un DEL rouge pendant 5 secondes.

1. Pour commencer à écrire un nouveau programme, ouvrir un nouveau document ou insérer une page dans le document courant (ctrl+doc), et sélectionner Ajouter l’Editeur de Programme. Choisir Nouveau.
2. Donner un nom au programme (Nous utilisons le nom lum1), et appuyer sur enter.

Le curseur est maintenant situé entre les balises Prgm et EndPrgm.

Les parenthèses après le nom du programme sont utiles pour ajouter des paramètres optionnels.

Votre premier programme est constitué d’une seule ligne de code :

Send(“SET LIGHT ON TIME 5”)

LIGHT est le nom de la DEL rouge.

Pour créer cette commande :

3. Appuyer sur la touche menu, et sélectionner le sous menu Hub.
4. Choisir l’item Send “SET….
5. Puis enfin LIGHT dans le sous menu Send “SET.

Le sous menu Hub contient des instructions pour programmer le TI-Innovator Hub et le TI-Innovator™ Rover. Ces commandes peuvent être entrées manuellement, mais il est plus facile de les choisir à partir des menus.

6. Terminer la commande en complétant l’instruction ON et TIME sont localisé dans le sous menu : menu > Hub > Settings.
   Send “SET LIGHT ON TIME 5”

Le programme complet est montré sur la droite

La commande Send enverra la chaîne de caractères (le texte entre guillemets) au TI-Innovator Hub.

Faire fonctionner le programme

1. Appuyer sur ctrl+R pour faire fonctionner le programme. Cette action « Vérifie la Syntaxe & Enregistre », ajoute une page de calculs à la suite, et recopie le nom du programme.
2. Assurez-vous d’avoir connecté TI-Innovator Hub à la calculatrice
3. Appuyer sur enter pour faire fonctionner le programme.

Si la commande est écrite correctement, la lampe (DEL rouge) s’allumera pendant 5 secondes. S’il y a une erreur dans une instruction du TI-Innovator Hub instruction, la diode clignotera une fois et un bip sonore sera émis

La calculatrice affiche « Terminé » après la fin du programme. Noter que le programme se termine en fait avant l’extinction de la diode. Pour synchroniser la fin du programme avec l’extinction de la diode, nous ajoutons une instruction Wait avec le même délai de mise sous tension de la diode.

Pour ajouter une instruction au programme, nous devons l’éditer :

1. Retourner dans l’éditeur de programme à la page précédente.
2. Ajouter une ligne blanche au programme en mettant le curseur à la fin de la commande Send et appuyer sur enter.
3. Wait se trouve dans le sous menu Hub.
4. Ajouter l’instruction Wait 5 avant EndPrgm.

Faire de nouveau fonctionner le programme (ctrl+R).

L’application Calculs apparait de nouveau et le nom du programme est à nouveau collé. Appuyer sur enter. Le programme cessera avec l’extinction de la diode.

Extensions
Nous pouvons enlever l’instruction TIME de la commande Send et contrôler la durée en ajoutant une instruction Wait. Comme la DEL reste allumée 5 seconde, une fois sous tension, vous devrez également éteindre la lumière dans votre programme.

• Pour mettre la diode hors tension, utiliser l’instruction :
  Send “SET LIGHT OFF”
• Ajouter des commandes afin de faire clignoter la diode plusieurs fois.

Conseil : Utiliser les options de « Copier & Coller » comme sur un ordinateur.

Dans cette seconde leçon de l’unité 1, vous apprendrez à utiliser les instructions pour entrer données dans un programme afin de contrôler la couleur d’une diode (DEL) sur le Hub TI-Innovator™.

Objectifs:

• Utiliser les arguments dans un programme
• Contrôler le couleur d’une diode DEL

La couleur d’une diode DEL (Diode à Emission de Lumière) dispose de trois « canaux » Rouge, Vert et Bleu. Ainsi on l’appelle souvent une diode “RVB DEL”. Les écrans d’ordinateurs, de téléphone et de TV les utilisent très largement pour créer les images

Pour obtenir une couleur particulière, nous devons ajuster le mélange de chacune d’entre elles. De nombreuses combinaisons sont possibles à partir de ces couleurs dites « primaires »

Commençons par contrôler la COULEUR de la DEL à partir de l'application Calculs :

1. A partir du menu > Fonctions & Programmes > E/S, sélectionner la commande Send.

2. Après le mot clé Send, ouvrir les guillemets (ctrl-[x]).
3. Entre ces guillemets, écrire l’instruction
   SET COLOR et trois valeurs numériques séparées par des espaces, représentant le “dosage” de rouge, vert ou bleu pour allumer la diode RVB.
   
   • Ces trois nombres sont compris entre 0 et 255. Plus le nombre est élevé, plus la couleur est brillante. Voir quelques exemples à droite.

Notez que la DEL reste allumée jusqu'à ce que vous changiez son état. Un programme peut vous aider à piloter la DEL plus précisément en l'éteignant avant la fin du programme.

Dans ce programme, vous expérimenterez avec la DEL RVB. Vous fournirez les valeurs rouges, vertes et bleues comme arguments, et la DEL s'allumera dans la couleur que vous aurez choisie pendant quelques secondes, puis le programme éteindra la DEL.

Mise au point du programme couleur01

1. Ajouter une nouvelle page en appuyant sur ctrl+doc, ou commencer un nouveau document. Sélectionner Programme Editeur à partir de menu.
2. Nommer le programme couleur01.

3. Insérer les parenthèses après le nom du programme, taper trois lettres séparées par des virgules afin de représenter les trois couleurs : rouge, vert et bleu.
   • Ces trois lettres sont les ‘arguments’ du programme et seront utilisées par lui afin de piloter le Hub.
   • Nous utilisons les lettres r,v,b sur la droite.

Les arguments sont des « espaces réservés » pour les valeurs que vous fournissez lorsque vous exécutez le programme. Ce sont des variables que les programmes utilisent pour représenter vos valeurs réelles. Ces variables n'existent que pour le programme et ne sont pas disponibles pour d'autres applications et sont donc traitées comme des «variables locales».

4. Sélectionner menu > Hub > Send “SET…> COLOR pour coller la première partie de l’instruction dans l’éditeur de programmes.

Comprendre l’instruction eval( )

Vous ne pouvez pas transmettre les valeurs R V B de la couleur dans l’instruction Send car les lettres R, V, et B seraient envoyées au Hub TI-Innovator à la place des valeurs de ces variables.

Nous avons besoin d’utiliser la fonction spéciale, eval( ) à partir du menu Hub qui est conçue pour convertir la valeur d'une expression de la calculatrice en une chaîne de caractères que le TI-Innovator peut traiter.

Compléter l’instruction Send :

1. Ajouter la fonction eval( ) en sélectionnant menu > Hub > eval(.
2. Taper la lettre r entre parenthèses.
3. Ajouter un espace après les parenthèses.
4. Reproduire la fonction eval( ) deux fois supplémentaires pour les variables v et b. Ne pas oublier de mettre un espace entre chacune d’entre elles. L’instruction Send doit ressembler à ce que vous voyez sur l’écran de droite.

5. Après l’instruction Send ajouter une commande Wait afin d’attendre quelques secondes. N’oubliez pas de fournir un certain nombre de secondes.

6. Finalement ajouter une autre instruction Send “SET COLOR …pour éteindre la diode RVB.
   • Utiliser trois “0” pour éteindre les trois couleurs.

Faire fonctionner le programme

1. Assurez-vous d’avoir connecté le TI-Innovator Hub.
2. Appuyer sur ctrl+R pour vérifier, enregistrer et faire fonctionner le programme.
3. Dans l’application Calculs proposer trois nombres compris entre 0 et 255 et séparés par des virgules, afin de créer le mélange de couleur, puis appuyer sur enter.

• La DEL de couleur s’allume pendant la durée fixée par le nombre de secondes de la commande Wait puis s’éteint.

Note : Pour réexécuter le programme avec des valeurs différentes, appuyez deux fois sur la flèche vers le haut pour mettre en surbrillance le nom du programme, appuyez sur enter, puis modifiez les numéros avant d'appuyer à nouveau sur enter.

Dans cette troisième leçon de l'unité 1, vous apprendrez une autre méthode pour entrer des données dans un programme et comment contrôler le son sur le Hub TI-Innovator ™.

Objectifs:

• Utiliser l’instruction Request
• Contrôler la fréquence et la durée d’un signal sonore

Le Hub TI-Innovator dispose d’un haut-parleur intégré appelé SOUND.

Vous contrôlez le son provenant du haut-parleur SOUND en lui envoyant une valeur de fréquence. Les fréquences sonores sont mesurées en Hertz (Hz), ou «cycles par seconde».

L’instruction Request est trouvée dans le menu E/S. Elle est utilisée pour obtenir de l'utilisateur l’entrée d’une donnée et contient une fonctionnalité qui permet au programmeur de créer un message afin de préciser sa signification.

Syntaxe de l’instruction : Request <Chaîne> , <Variable>

Dans le programme SON, nous utiliserons l’instruction Request .

Mise au point du programme SON

1. Commencer un nouveau programme et le nommer SON1.
2. Ajouter l’instruction Request à partir du menu I/O.
3. Ajouter le message d’invitation “Fréquence ? ” ainsi qu’une virgule après le mot clé Request.
4. Puis la variable qui représentera la fréquence, freq.
5. Ajouter une autre instruction Request afin d’inviter l’utilisateur à préciser la durée « temps » pendant laquelle le son devrait être diffusé.

Comme dans le programme COULEUR que nous avons vu dans la compétence précédente, nous avons besoin d’utiliser la fonction eval( ) afin d’évaluer les variables freq et temps.

Terminer le programme SON

6. Sélectionner Send “SET… et SOUND en appuyant sur la touche menu > Hub > Send “SET… > SOUND.
7. Sélectionner eval( en appuyant sur la touche menu > HUB > eval().
8. Ajouter la variable freq entre parenthèses.
9. Mettre un espace, puis une autre fonction eval() pour la variable temps.
10. Appuyer sur les touches ctrl+R pour vérifier, enregistrer et faire fonctionner le programme.

Faire fonctionner le programme

Lorsque vous exécutez ce programme, une boîte de dialogue s'affiche à la suite de l'instruction Request.

1. Entrer 440 pour la fréquence et 5 pour le temps.
   • Un son de fréquence 440Hz se fait entendre pendant 5 secondes. Cela signifie que la membrane du haut-parleur vibre 440 fois par 5 secondes.
   • Dans un environnement bruyant, vous devrez tenir le Hub proche de votre Oreille pour entendre le son.
2. Appuyer sur enter pour faire fonctionner le programme avec de nouvelles valeurs.
3. Experimenter avec d’autres fréquences.

Ecrire un programme qui contrôle les feux de circulation.

Objectifs :

• Contrôler la diode de couleur RVB pour simuler des feux de circulation en utilisant une seule lampe.
• Créer une séquence d'instructions avec des contrôles de synchronisation appropriés

Votre travail consiste à écrire un programme qui contrôle un feu de signalisation. La lumière sera simulée à l'aide de la diode RVB intégrée au Hub TI-Innovateur.

La DEL COULEUR doit passer du vert au jaune puis au rouge ET du rouge au jaune puis au vert. Vous fixez vous même la temporisation.

Votre programme aura une séquence d'instructions qui simule le changement de ROUGE en VERT puis en JAUNE et enfin en ROUGE. Une structure séquentielle de contrôle dans la programmation est un ensemble d'instructions qui sont traitées les unes après les autres, de haut en bas, sans interruption.

Utiliser Text comme une pause

L’instruction Disp affiche un message sur l’écran d’accueil de la calculatrice. Elle peut être utilisée pour afficher la valeur d’une variable Disp X, mais peut aussi afficher une chaîne de caractères. Mais elle n’empêche pas le programme de continuer.

L’instruction Text du menu E/S affiche une boîte de dialogue et attend que l'utilisateur appuie sur Enter ou clique sur le bouton « OK » avant de traiter le reste du programme.

Configuration de l’écran de titre

1. Commencer un nouveau programme et l’appeler APPLIC1.
2. Obtenir le mot clé Text à partir du menu E/S.
3. Entre guillemets, ajouter le message “Feu de circulation <enter> Appuyer sur enter…” comme montré sur l’écran de droite.

Fixer les couleurs

Tout d'abord, nous définissons la couleur rouge en envoyant les valeurs 255 0 0 à la diode RVB.

Sur l’exemple de droite, nous utilisons l’instruction Wait afin de demander à la calculatrice d’attendre 5 avant d’envoyer la commande suivante au Hub TI-Innovator. La lumière rouge s’illuminera pendant ce temps.

Votre travail consiste à ajouter des instructions pour afficher le vert, puis le jaune, puis le rouge à nouveau.

Un défi : Ajouter des SONs pour guider les personnes aveugles (piétons, pas les conducteurs !) afin qu’elles puissent identifier les couleurs.

Dans cette première leçon de l'unité 2, vous apprendrez à utiliser la boucle For dans la calculatrice à travers un programme qui fera clignoter une diode tout en affichant des informations sur l’écran de la calculatrice.

Objectifs:

• Apprendre à programmer la boucle For
• Faire clignoter une diode
• Utiliser l’instruction DispAt pour afficher du texte et des variables

Écrivons un programme pour faire clignoter une diode DEL un certain nombre de fois. Avec d'autres instructions de saisie (ou arguments), vous pouvez également contrôler le temps pendant lequel le voyant est allumé et éteint.

Ce programme vous demande d’introduire la boucle For…EndFor .

Mise au point du programme :

1. Commencer un nouveau programme et le nommer LUM2.
2. Ajouter Disp en sélectionnant menu > E/S et en choisissant 1:Disp.
3. Entre guillemets, ajouter le texte “Clignotant” comme montré sur l’écran de droite.
4. Ajouter Request en sélectionnant menu > E/S > 1:Request.
5. Entre guillemets, ajouter le texte « Nombre de cycles ? » comme montré sur l’écran de droite.
6. Ajouter une virgule et la variable n.

Ajouter la boucle For:

7. Ajouter la structure For en sélectionnant menu > E/S > 5:For…EndFor.
   • Les deux instructions For et EndFor sont collées ensemble dans le programme avec une ligne entre, afin d’insérer le corps de la boucle.
8. Ajouter le reste de la structure For avec les arguments, i,1,n, séparés par des virgules.
   • Cette instruction signifie “For i allant de 1 à n par pas de 1.”

3. Appuyez sur Enter plusieurs fois dans le corps de la boucle pour créer des lignes vides que nous remplirons ensuite
   • Ne vous inquiétez pas du nombre de lignes vides à entrer. Vous pouvez toujours ajouter plus de lignes si vous en avez besoin, et les lignes vides n'ont aucun effet lorsque vous exécutez le programme.
   • Le bloc d'instructions entre For et EndFor est appelé «corps de boucle». C'est cette section de code qui sera traitée N fois grâce au travail effectué par la boucle For.

Nous souhaitons que la diode clignote n fois. Nous voulons également que la calculatrice affiche le nombre de cycles ALLUME - ETEINT

Commencer le corps de la boucle avec l’instruction DispAt 1, i qui est la variable qui contrôle la boucle.

DispAt affiche l’expression écrite entre les guillemets au numéro de ligne précisé devant l’instruction. La zone d’affichage des informations est située sous le programme. 8 lignes sont disponibles pour l’instruction DispAt .

Nous ajoutons maintenant les instructions ON et OFF comme montré sur l’écran de droite.

10. Ajouter Send “SET LIGHT à partir du menu HUB.
11. Ajouter le mot ON à partir du menu HUB > SETTINGS (ou l’écrire).
12. Ajouter Wait (en secondes) à partir du menu HUB afin que la calculatrice attende avant d’envoyer la commande suivante.
    • Dans notre programme, nous utilisons 1 seconde, mais vous pouvez utiliser les valeurs que vous souhaitez, y compris les décimales
13. Ajouter une autre instruction Send pour éteindre la lampe OFF, ainsi qu’une autre instruction Wait.
14. Faire fonctionner le programme (ctrl+R). Vous devriez voir la diode clignoter et le compteur s’incrémenter sur l’écran de la calculatrice.

Remarquez le retrait ? Cela permet de rendre les programmes plus lisibles et n'a aucun effet sur le fonctionnement du programme

Voici un défi : Ajoutez plusieurs instructions Request pour entrer les données au début du programme (avant l'instruction For) pour définir les temps pour les deux valeurs Wait et utilisez ces variables au lieu de nombres dans ces instructions.

Quittez et exécutez à nouveau le programme. Observez le clignotement et les valeurs affichées sur l'écran de la calculatrice.

Dans cette seconde leçon de l’Unité 2, vous allez apprendre à contrôler l’intensité lumineuse des trois couleurs de la diode RVB qui équipe le Hub TI-Innovator™.

Objectifs:

• Utiliser la boucle For pour contrôler chaque canal de la diode COULEUR RVB

Les valeurs (de 0 à 255) permettant de contrôler les trois canaux Rouge, Vert et Bleu envoyées à la diode RVB déterminent la luminosité de chaque couleur. Ce programme montre comment faire varier graduellement le taux de chaque canal afin d’obtenir par transition les (256³) couleurs possibles. Vous utiliserez de nouveau la boucle For dans votre programme.

Créer un programme de changement des couleurs

1. Créer un nouveau programme et le nommer COULEUR2.
2. Ajouter Text après le titre du programme comme montré sur l’écran de droite.
3. Ajouter Request et entre guillemets ajouter le texte « Temps de transition ? ».
4. Puis ajouter une virgule et la variable w.
   • Cette variable sera utilisée dans l’instruction Wait, donc plus le nombre est petit, plus court sera le temps d’attente avant que ne soit exécutée l’instruction suivante.
5. Comme montré sur l’écran de droite, ajouter également une instruction Request afin de fixer la valeur du pas utilisée dans la boucle For si vous souhaitez accélérer un peu les transitions.

Notes : Local i permet à la variable de ne pas être crée en dehors du programme). Le symbole © est obtenu à partir de menu > Actions > Insert Comment.

Notre programme va graduellement (en fonction des valeurs d'attente et de pas) augmenter l'intensité du ROUGE, puis ajouter du VERT, puis retirer progressivement le ROUGE, puis ajouter le BLEU, retirer le VERT, puis ajouter ROUGE au BLEU, puis retirer le BLEU, Puis enfin enlever le ROUGE. Il s'agit d'un programme assez long, et vous pouvez l'exécuter après avoir terminé chacune des boucles For pour tester son fonctionnement.

C'est une bonne chose que l'éditeur de programmes fournisse automatiquement l'instruction For et EndFor simultanément ainsi vous ne l’oublierai pas ultérieurement.

6. Ajouter une boucle For…EndFor (à partir du menu Contôles) après les deux instructions Request .

Compléter la première Boucle

1. Ajouter les arguments de la boucle For afin que la variable i s’incrémente depuis 0 jusqu’à 255. Utiliser la variable i et la variable s.
2. Ajouter l’instruction Send “SET COLOR à partir du menu HUB.
3. Utiliser la fonction eval( ) depuis le menu HUB pour la variable i pour contrôler le canal ROUGE et mettre les canaux VERT et BLEU à 0.
4. Ne pas oublier de fermer guillemets et parenthèses.
5. Placer ensuite l’instruction Send avec Wait en utilisant la variable w déjà appelée par l’instruction Request .

6. Après la fin de cette première boucle For vous pouvez utiliser l’instruction Text avec un message et admirer la magnifique couleur de la diode.

Ajouter la boucle pour le VERT

Maintenant nous allons construire une autre boucle For pour ajouter du VERT à diode RVB. Mais cette fois, nous voulons seulement contrôler le canal VERT et ne pas toucher au canal ROUGE. Nous pouvons le faire de deux façons :

Send “SET COLOR 255 eval(i) 0”
(Le Rouge étant allumé alors que le Bleu est éteint)

ou

Send “SET COLOR.GREEN eval(i)”
Cette deuxième instruction contrôle uniquement le canal VERT et n'affecte pas les canaux ROUGE et BLEU. Dans les deux cas, notez que nous pouvons réutiliser la variable i de la première boucle For.

Dans l'image à droite, notez que nous avons choisi d'utiliser la méthode précédente.

1. Ajouter l’instruction Wait à l’intérieur du corps de boucle en utilisant la variable w.
2. Ajouter l’instruction Text après leEnd de la boucle et admirez la nouvelle couleur. De quelle couleur s’agit-il ?

Maintenant, nous voulons diminuer progressivement la quantité de ROUGE de façon à ne conserver que le VERT.

Pour diminuer dans une boucle For, nous commençons par la valeur la plus élevée pour aller vers la plus faible en utilisant un pas négatif.

For i, 255, 0, -S

Commence à 255 et soustrait S à chaque pas de la boucle jusqu’à ce que la variable i soit inférieure à 0 lorsque la boucle se termine. Pensez à utiliser le signe négatif [ (-) ] et non la touche correspondant à l’opérateur de soustraction. Ce qui renverrait un message d’erreur.

Nous voulons seulement modifier le canal ROUGE, nous utilisons donc l’instruction Send .

Le reste de cette boucle est similaire aux deux premières boucles que nous avons construites. L'image de droite ne montre que les mots clés saisis.

Pouvez-vous remplir chacune de ces instructions ? Sinon, reportez-vous à l'étape suivante.

Voici la section complétée qui supprime progressivement le ROUGE. À la fin de cette boucle, vous devriez voir une couleur verte lumineuse :

3. Maintenant ajouter une boucle pour avoir du BLEU.
4. Puis ajouter une boucle pour enlever le VERT.
5. Puis créer une boucle afin d’ajouter de nouveau du ROUGE.
   • Quelle couleur voyez-vous à la fin de ces boucles ?
6. Ensuite ajouter une boucle pour enlever le BLEU.
7. Finalement, ajouter une boucle pour enlever le ROUGE.
   • Quelle est la couleur de la LED à la fin du programme ?
   • Que se passe-t-il lorsque les trois canaux de couleur sont 0 ?

Extension : Utiliser DispAt aux emplacements appropriés afin d’afficher les valeurs des couleurs RVB de chaque canal. Vous avez besoin d’une instruction dans chaque boucle, mais elles utilisent la même instruction. Vous pouvez donc les créer par un simple « Copier-Coller »

Dans cette troisième leçon de l'unité 2, vous apprendrez la relation qui existe entre les fréquences et les notes de la gamme musicale. Vous écrirez un programme pour jouer les notes que les musiciens utilisent depuis quelques siècles.

Objectifs:

• Expliquer la relation « racine douzième de deux » de l'échelle musicale
• Ecrire un programme qui joue les notes successives d’une gamme

Un peu de théorie musicale.
Les notes de musique sont déterminées par la fréquence d'un objet vibrant, comme un haut-parleur, membrane de tambour, ou une corde de guitare ou piano. Les notes de l'échelle musicale suivent une relation mathématique particulière. Il y a 12 notes ou « pas » dans une octave. Si la fréquence d’une note est F, alors la fréquence de la note suivante est F×¹²√2 .

On multiplie donc la fréquence d’une note par ¹²√2 ou 2^1/12 (la racine douzième de 2) effectuée 12 fois, cette opération revient à doubler la fréquence d’origine, de sorte que la dernière note dans l'octave ait une fréquence de F× (2^1/12)¹²=2×F. Par exemple si la fréquence d’une note est 440 Hz, La fréquence de la même note à l’octave supérieure est 880 Hz, et celle de l’octave inférieure est 220 Hz.

L'oreille humaine a tendance à entendre les deux notes d'une octave à part comme étant essentiellement «les mêmes», en raison des harmoniques étroitement liées.

Pour cette raison, les notes d'une octave sont données par le même nom dans le système occidental de la musique. Ainsi la note DO (C) est également DO (C) à l’octave supérieure. Les intervalles entre ces notes sont appelés des «demi-tons».

Dans ce projet, vous allez utiliser le rapport 2^1/12 pour générer les douze notes d’une octave.

Le DO médium (C) a une fréquence de 261.64Hz. Une octave au-dessus le DO médium (C), aura une fréquence de 2×261.64Hz or 523.28Hz. Il y a 12 « pas » (demi tons) entre ces notes, et chaque demi ton est le 2^1/12 du son suivant ou précédent quant à sa fréquence.

Sur l’écran de droite, nous avons entré 261.64. Ainsi l’instruction suivante consiste juste à effectuer une multiplication par 2^1/12.

La calculatrice fournit Ans au début, car le symbole de multiplication nécessite un argument en face de celui-ci. Appuyer simplement sur la touche Enter afin de créer les séquences de calcul comme sur l’écran de droite.

Nous prendrons en compte ce principe répétitif dans notre programme. Si vous continuez la progression, la douzième réponse sera 523,28, deux fois la valeur de départ, car : F×(2^1/12)¹²=2×F.

Mise au point du programme :

1. Commencer un nouveau programme et le nommer SON2.
2. Ajouter l’instruction Text suivi de guillemets et entrer le texte « La gamme musicale : Appuyer sur enter ».
3. Affecter le début de la fréquence à 261.64 à la variable f.
   Il ya deux commandes d’affectation. := et → (sto). Vous pouvez utiliser l’un ou l’autre :
   f:=261.64 ou 261.64→ f
4. Cette variable représentera chacune des 12 notes de la gamme.

Configuration de la boucle For :

5. Ajouter une boucle For allant de 1 à 12 (pour les 12 notes).
6. Ajouter l’instruction Send “SET SOUND à partir du menu HUB
7. Ajouter la function eval( ) pour la variable variable f comme montré sur l’écran de droite.

Evaluer la fréquence :

1. Multiplier f par 2^1/12 et stocker le résultat dans la variable f:
   f := f * 2^1/12

   Cette instruction prend la valeur actuelle de f et la change à la fréquence de la note supérieure suivante sur la gamme.

2. Faire fonctionner le programme (ctrl+R). Entendez-vous quelque chose ? Cela correspond-il à ce que vous attendiez ?

Modifier le Programme:

Essayer d’ajouter l’instruction TIME à la commande SEND( “ SET SOUND et assurez-vous d’incorporer une commande Wait de même valeur afin que chaque note s’achève correctement avant de passer à la suivante.

Si une nouvelle commande est reçue par le Hub TI-Innovator avant qu'il ne termine sa dernière tâche, le Hub TI-Innovator traitera la nouvelle commande au lieu de terminer l'actuelle. Lorsque vous faites fonctionner le programme, vous n’entendez pas la gamme « do-re-mi-fa-sol-la-ti-do ». Soit 8 notes. Les autres notes correspondent aux touches noires du piano. Comment faire en sorte que seule les 8 notes soient jouées ?

Ajouter une instruction DispAt afin d’afficher la fréquence des notes.

Nous allons utiliser le générateur de nombres pseudo aléatoires TI-Nspire CX pour créer de la musique

Objectifs :

• Utiliser la boucle For( pour contrôler le nombre de notes
• Utiliser le générateur de nombres aléatoires pour créer des notes de musique

Votre travail consiste à compléter un programme qui demande le nombre de notes à jouer, et utilise ensuite une boucle For (afin de jouer le nombre donné de notes aléatoires. Comme la note est en cours de lecture, la fréquence doit être affichée sur l'écran de la calculatrice en utilisant l’instruction DispAt.

Dans cette application nous utiliserons l’instruction randInt( ) de la calculatrice TI-Nspire pour générer une note aléatoire de la gamme musicale

1. A partir de l’application Calculs, localise randInt( ) dans menu > Probabilités > Nombre aléatoire > Entier.
   • Cette commande exige deux (ou trois) arguments.
2. Entre rune valeur inférieure et supérieure séparées par une virgule et appuyer sur la touche enter.
3. À partir de ce moment, il suffit d'appuyer sur la flèche vers le haut jusqu'à la commande précédente, d'appuyer sur enter pour la réutiliser et d'éditer les deux arguments pour afficher la sortie de la fonction.

Vous combinerez la fonction randInt( ) avec le programme déjà crée et utilisant une progression géométrique de raison 2^1/12 afin de créer les notes de la gamme.

La nouvelle partie importante du code est:

Comme vous pouvez le voir dans le tableau, la fréquence de la note LA (A) de la première octave est de 55Hz. L’intervalle 0 à 59 est utilisé pour les 60 notes du tableau. Noter l’usage de N en 2^(N/12) pour générer la Nième note depuis le LA de la première octave (A1). Lorsque N est à zéro, alors la fréquence est 55Hz, puisque 2^0 is 1.

Utiliser une instruction Wait pour synchroniser le déroulement du programme avec la musique.

Dans cette leçon, nous étudions le capteur de lumière intégré, BRIGHTNESS, et utiliserons l'instruction DispAt pour afficher les lectures du capteur.

Objectifs :

• Lire les mesures Luminosité
• Introduire la boucle While

Dans les leçons précédentes, nous n'avons envoyé que des instructions au Hub TI-Innovator ™ afin d’avoir un impact sur ses périphériques intégrés (LUMIÈRE, COULEUR et SON).

Dans cette unité, nous allons travailler avec le capteur de lumière embarqué, et utiliser la valeur lue dans notre programme pour créer un « compteur de lumière ». Le capteur de lumière produit des valeurs comprises entre 0 et 100 sous forme décimale.

L'obtention de la valeur du niveau de lumière à partir du Hub TI-Innovator nécessite deux instructions:

• Send “READ BRIGHTNESS”
• Get <var>

Mise au point du programme :

1. Commencer un nouveau programme et le nommer LUMIN1.
2. Nous utiliserons la variable b to pour stocker la valeur de la luminosité (BRIGHTNESS), ainsi nous déclarons cette variable comme Local dans le programme. Ceci est optionnel.
3. Sélectionner menu > Hub > Send “READ… > BRIGHTNESS. Appuyer sur la touche enter.

4. Sélectionner menu > Hub > Get.
5. Taper le nom de la variable b (aucune parenthèse n’est utilisée ici).

Fonctionnement du programme :

• READ BRIGHTNESS Demande au Hub TI-Innovator de lire le niveau de luminosité et stocke cette valeur dans une mémoire tampon « buffer » intégrée.
• Get b est une commande pour obtenir la valeur du tampon du Hub TI-Innovator. Cette instruction transfère la valeur de la mémoire tampon sur le Hub TI-Innovator vers la variable b dans la TI-Nspire. Vous pouvez utiliser n’importe quel nom autorisé de variable

La boucle While :

 La boucle While…EndWhile (menu > Control >) Est utilisé pour traiter un bloc de code alors qu'une condition est vraie. Une condition est une instruction logique qui peut être évaluée comme vraie ou fausse. Les opérateurs relationnels et les opérateurs logiques se trouvent sur la touche ctrl + = key.

Les opérateurs relationnels sont =, ≠ , >, ≤, et ≥.

Les opérateurs logiques sont and, or, not, et xor.

Ces opérateurs peuvent être utilisés ensemble afin de composer des instructions composées x>0 and y>0.

Nous allons utiliser une simple boucle While qui s’arrête lorsque la luminosité atteint une valeur inférieure à 1. Pour terminer le programme, couvrir simplement avec votre main le capteur de lumière sur la face latérale du Hub TI-Innovator.

Ajouter une boucle While :

1. Avant l’instruction Send de votre programme, ajouter las commande:
   b:=2
2. Cette instruction est utilisée pour initialiser la boucle. Tant que la condition b>1 est vraie, la boucle continue la lecture du capteur de lumière. Dès qu’elle devient fausse, c’est à dire lorsque la quantité de lumière reçue par le capteur est insuffisante ou que celui-ci est recouvert avec la main, la boucle et le programme se terminent.

Nous voulons inclure les instructions Send et Get à l’intérieur d’une boucle While. Il existe une méthode pratique pour réaliser cela.

2. Sélectionner d’abord les instructions Send et Get en maintenant enfoncée la touche [ ↑ shift ] et en utilisant les touches de directions
3. Maintenant avec les instructions sélectionnées appuyer sur menu > Control > While
4. Cette action place While au début des instructions et EndWhile juste après elles.

5. Ajouter b>1 après le While ainsi votre boucle doit ressembler à celle-ci :
   While b>1
   Send “READ BRIGHTNESS”
   Get b
   EndWhile

Ajouter l’instruction DispAt après l’instruction Get et avant le EndWhile de la boucle comme montré ci-contre en sélectionnant menu > I/O > DispAt.

Afficher un message approprié ainsi que le contenu de la variable b:
DispAt 1, “Luminosité = “, b

• Faire fonctionner le programme (ctrl+R) avec TI-Innovator Hub connecté.
• Vous devriez voir une séquence de valeurs défiler vers le bas de l'application Calculs. Ces valeurs se modifient en fonction de l'intensité lumineuse lue par le capteur.
• Pour terminer la boucle (et le programme), couvrez le capteur de lumière situé à l'extrémité du Hub TI-Innovator afin que la valeur de luminosité affichée soit inférieure à 1

Dans cette seconde leçon de l’unité 3, nous allons construire un interrupteur automatique de lumière dont l’état (ouvert ou fermé) correspond à la valeur de la lumière ambiante.

Objectifs :

• Lire la valeur de la luminosité
• Utiliser une boucle While
• Utiliser If…Then…Else…End pour mettre sous (hors) tension une lampe en fonction de la luminosité

Ecrivons maintenant un programme qui consiste à réaliser un allumage automatique d’une lampe en fonction de la luminosité reçue

Notre programme va interroger le capteur de lumière du Hub TI-Innovator™ et allumer une diode ou une lampe lorsque la valeur lue correspond à une ambiance trop sombre, puis l’éteindra à partir d’un seuil de luminosité donné.

Nous utiliserons notre appareil de luminosité de la leçon précédente pour déterminer une valeur intermédiaire de la luminosité entre une surface surexposée ou sous exposée.

Mise au point du programme :

1. Commencer un nouveau programme et le nommer LUMIN2.
2. Ajouter Disp, entre guillemets et le texte « Interrupteur automatique ».
3. Initialiser la variable b en ajoutant la commande 2→b.
4. Ajouter une boucle While…EndWhile avec la condition b>1. (La valeur de la luminosité est vraiment très faible).

Pour terminer le programme, couvrir le capteur..

5. Dans le corps de la boucle While, ajouter la commande Send “READ BRIGHTNESS” et Get b à partir du menu HUB comme montré sur l’écran de droite.
6. Ajouter DispAt 1, b afin de voir les données lues.

Instruction If

Votre Instruction If contient deux blocs de code. Un lorsque la condition est vraie et un autre lorsqu’elle est fausse.

La structure de l’instruction sur plusieurs lignes est :

If <condition> Then
<action si vraie>
Else
<action si faux>
EndIf

Vous pouvez ajouter plusieurs lignes vierges en appuyant sur la touche [enter].

Ecrivons maintenant la condition…

La valeur de la luminosité stockée dans la variable b prend ses valeurs dans l’intervalle 0 à 100.

Qu’est-ce qu’une bonne valeur pour une ambiance sombre ? Nous choisissons 25, mais nous pouvons la modifier par n’importe laquelle entre 0 et 100.

Nous pourrions améliorer le programme en ajoutant une instruction Request afin de fixer la valeur seuil de déclenchement ‘trigger’ . Assurez-vous de placer l’instruction Request avant le début de la boucle While.

Pour obtenir l’opérateur ‘<’ (inférieur à) utiliser les touches ctrl-=

7. Finalement, allumer puis éteindre la lampe LIGHT ON ou OFF dans le bloc Then et Else comme montré sur l’écran de droite.
8. Appuyer sur ctrl - B pour sauvegarder le programme.
9. Faire fonctionner le programme avec le Hub TI-Innovator connecté.
10. Contrôler la lumière qui arrive sur la cellule du capteur, ainsi que la diode rouge qui s’allume ou s’éteint.

Il pourrait être intéressant d’ajouter une instruction DIsp b après le Get b pour afficher la valeur de b dans l’application Calculs de la calculatrice et d’ajouter également des instructions dans le bloc Then et Else pour montrer l’état de la diode « ON » ou « OFF ».

Pour arrêter la boucle (et le programme), couvrez complètement le capteur de lumière de manière à ce que la lecture soit inférieure à 2.

Optionel :

Ajouter DispAt 2, “Lumière est Allumée” lorsque c’est le cas et DispAt 2, “Lumière est éteinte” également aux emplacements appropriés dans le programme.

Pour arréter la boucle (et le programme), couvrir avec la main, la surface du capteur afin que la valeur de la variable b soit inférieure à 1.

Attention : La diode DEL peut être allumée lorsque le programme s’achève. Quelle commande ajouter afin d’être certain qu’elle s’éteigne ?

Dans cette troisième leçon de l’unité 3, nous allons utiliser la luminosité reçue par un capteur afin de contrôler la couleur d’une DEL

Objectifs:

• Lire un capteur de lumière et contrôler soit la COULEUR DEL, soit la fréquence d’un son issue d’un haut-parleur en fonction de la luminosité reçue.
• Utiliser des formules de conversion pour passer de la valeur de la luminosité à la valeur chromatique de couleur.

Nous allons construire un produit qui réagit à la luminosité de la pièce. Plus une partie de la pièce est lumineuse, plus la diode DEL l’est aussi. La partie délicate ici est de convertir la valeur de la LUMINOSITE en une valeur de couleur appropriée

La LUMINOSITE B prend ses valeurs de 0 à 100.

La COULEUR C (sur les trois canaux) peut varier de 0 à 255.

Comment allons-nous convertir B en C?

Mise au point du programme :

1. Commencer un nouveau programme et l’appeler lumin3.
2. Déclarer les variables b et c comme locales.
3. Ajouter l’instruction : DispAt 1, “Luminosité et couleur”.
4. Mettre la variable b à 2 comme montré. b:=2
5. Ajouter une boucle While…EndWhile pour lire la luminosité en utilisant l’instruction Send “READ BRIGHTNESS”, et lire la variable correspondante avec Get b.
6. Ajouter DispAt 2, “Brightness= “,b pour afficher la valeur de b sur l’écran.

7. Utiliser la variable c pour représenter la valeur de la COULEUR qui seront envoyés aux trois canaux de la DEL RVB. Le coefficient de conversion est 2.55. Soit, c:=2.55*b.
   Vérifier cette relation avec deux paires de valeurs proposées.
   Lorsque b=0, alors c=2.55*0 ==> 0 ; lorsque b=100, alors c=2.55*100 ==> 255.

8. Ajouter une instruction Send “SET COLOR avant le End de la boucle. Cette instruction contrôle la luminosité de la DEL RVB.
9. Finalement compléter l’instruction SET COLOR en utilisant eval(c) trois fois (une fois pour chaque canal de couleur).
   • Lorsque les trois canaux de la DEL de couleur ont la même valeur, la DEL est blanche, et la luminosité de la DEL change en fonction de ces valeurs.
10. Connecter le TI-Innovator™ Hub, et faire fonctionner le programme.
11. Changer la valeur de la luminosité en pointant le capteur vers des objets différents. Observer l’intensité lumineuse de la diode sur le TI-Innovator Hub.
12. Pour mettre fin à la boucle While et par voie de conséquence au programme, couvrit complètement le capteur ainsi la variable b sera inférieure à 1.

Vous pouvez ajouter une nouvelle instruction DispAt afin d’afficher à l’écran les valeurs de b et c.

Mais attention ! L’effet produit n’est pas correct ! Quel devrait être la couleur ou la teinte la plus brillante prise par la diode au plus sombre de la pièce ? Comment inverser cet effet ?

Un autre défi : Que diriez-vous de changer le programme de sorte que les différentes valeurs de luminosité produisent des couleurs différentes?

Dans cette application, vous allez écrire un programme pour contrôler le son provenant du haut-parleur en fonction de la modification de la luminosité détectée par le capteur de lumière - par conséquent, « Harpe lumineuse ! »

Objectifs :

• Ecrire un programme qui convertit la luminosité en son
• Revoir les notes de musique, leur fréquence ainsi que la progression de celles-ci selon la racine douzième de 2.

Ecrire un programme qui lit la LUMINOSITE reçue par un capteur de lumière et joue un son différent en fonction de la luminosité. Il y a deux options possibles pour le son :

• Jouer une fréquence contenue dans une portion du spectre audible (peut-être 100Hz – 1000Hz)
• Jouer une note de musique (un des sons harmonieux spécifiques trouvé sur un piano ou un autre instrument de musique)

La première option consisterait à jouer simplement un bruit et la seconde à réellement faire de la musique, mais cela fait appel à des théories mathématiques plus complexes

Ce programme fait que le TI-Innovator ™ Hub se comporte comme un theremin. Vous pouvez faire varier la quantité de lumière visible par le capteur de LUMINOSITÉ en ajoutant de la lumière (en utilisant une lampe de poche) ou en retirant de la lumière (recouvrant partiellement le capteur).

Commençons

1. Commencer un nouveau programme et le nommer applic3
2. Ajouter une instruction DispAt 1, “Harme lumineuse !”.
3. Initialiser la variable b en ajoutant l’instruction b:=2.
4. Ajouter une boucle While pour la lire luminosité du capteur ‘READ et BRIGHTNESS puis sauvegarder cette valeur Get dans la variable b.
5. Ajouter une instruction pour jouer du son.
6. Noter que nous utiliserons la variable b pour lire la LUMINOSITE et la variable f pour jouer le SON.

Votre travail consiste à compléter le code manquant qui convertit la LUMINOSITE en un son audible ou une note de musique.

Pour le son, utiliser une fréquence comprise dans l’intervalle 100 à 1000 (ou deux fréquences au choix).

Pour les notes de musique, essayer avec le LA ( A1) (55Hz) et en remontant la gamme de 50 notes. (Vous devriez vous référer à l’activité de l’Unité 2, Compétence 3 – prgmSON2— qui joue les 12 notes sur une octave.

Pour les notes de musique, vous devrez convertir votre valeur en un nombre entier de sorte qu'une note «nombre» soit correctement représentée.

Vous pouvez utiliser la fonction int( ) ou la fonction round( ,0).

Dans cette première leçon de l’Unité 4, vous allez apprendre à utiliser l’éditeur de programmes pour mettre le TI-Innovator Rover en mouvement.

Objectifs :

• Utiliser l’éditeur de programmes de la TI-83 Premium CE
• Utiliser l’instruction Send(pour CONNECTER le TI-Innovator Rover au TI-Innovator™ Hub
• Faire rouler dans toutes les directions le TI-Innovator Rover FORWARD, BACKWARD, LEFT et RIGHT

Commençons

• Les instructions du Rover se trouvent en appuyant sur menu > Hub > Rover (RV).
• Certaines parties de l'instruction finale, telles que les valeurs numériques et les paramètres facultatifs, sont entrés au clavier ou sélectionnées à partir d'un autre menu Rover.
• La plupart des instructions du Rover laissent le curseur entre guillemets. Ceci indique qu'il y a plus d'options à entrer dans une commande. La TI-Nspire CX requiert les guillemets par paires.

Votre première instruction pour le Rover demande au TI-Innovator Hub de se connecter au Rover : Send “CONNECT RV” RV est le nom de l’unité Rover.

Pour créer cette commande :

1. Appuyer sur la touche menu puis sélectionner le menu HUB.
2. Sélectionner ensuite le sous menu Rover (RV).
3. Sélectionner la commande Send “CONNECT RV” située à côté du bouton du sous menu

L’instruction suivante consiste à entrer un texte. L’instruction Texte se trouve dans le menu menu > I/O. Cette commande met le programme en pause et attend que l'utilisateur appuie sur la touche enter.

4. Appuyer sur la touche menu, et sélectionner le menu I/O.
5. Sélectionner Texte.

6. Ajouter un message approprié après la commande Texte Texte “Appuyer sur enter pour commencer.”

Lorsqu’on exécute le programme, si on entend un bip du TI-Innovator Hub avant (ou pendant), le message "Appuyer sur enter pour commencer" est affiché, cela signifie que la commande CONNECT RV a échoué. S’assurer que le robot soit sous tension.

Piloter le Rover

7. Appuyer sur la touche enter à la fin de l'instruction Text afin d'ajouter la commande suivante qui fera avancer le mobile.
8. Appuyer sur la touche menu > Hub > Rover (RV), et sélectionner le menu Drive RV comme montré sur l’écran de droite.

9. Sélectionner FORWARD depuis le menu Drive RV.

Noter que la commande FORWARD qui est collée dans le programme a le curseur d'insertion à l'intérieur des guillemets précédé d'un caractère espace. Ceci est pour ajouter des paramètres optionnels à la commande.

10. Nous ajoutons le nombre 1 ici :
    Send “RV FORWARD 1”

11. Dans l'éditeur de programme, appuyez sur ctrl + B pour « enregistrer » le programme et passer à un écran de calculs. Cette commande est située (dans le sous-menu « Vérifier la syntaxe et enregistrer »). Ensuite, ctrl + R ouvrira une application « Calculs », et écrira le nom du programme (sans oublier les parenthèses). Appuyer sur la touche enter pour faire fonctionner le programme. S’assurer d’avoir suffisamment d'espace libre devant le Rover.

L’instruction Text affiche le message. Appuyer sur la touche enter une nouvelle fois, le Rover devrait avancer. Mais jusqu’où ? Etudier attentivement le mouvement afin de bien comprendre le sens de l’instruction FORWARD 1.

L'application Calculs affiche «Terminé » à la fin du programme. Noter que le programme se termine réellement avant la fin du déplacement du Rover. La calculatrice et le TI-Innovator Hub fonctionnent à des vitesses différentes.

Conduire en arrière

12. Editer le programme et ajouter l’instruction Send “RV BACKWARD 1” à la suite de l’instruction FORWARD en appuyant sur la touche menu > Hub > Rover > Drive RV > BACKWARD.
13. Ajouter le nombre 1 à la chaîne de caractères.
14. Enregistrer de nouveau le programme et le faire fonctionner (ctrl+R).

Cette fois, le Rover devrait avancer un peu et revenir à sa position d'origine. Si c'est le cas, félicitations ! Vous avez mis le Rover en mouvement.

Tourner

Les deux nouvelles instructions dans le menu Drive RV sont LEFT et RIGHT.

15. Ajouter ces deux nouvelles instructions au programme et le faire fonctionner de nouveau.
    Send “RV LEFT ”
    Send “RV RIGHT ”

Quel est le rôle de ces instructions ?

Faire le voyage

Étudier le programme sur l’écran de droite et prédire ce que le Rover fera et où il s’arrêtera lorsque le programme se terminera.

16. Entrez ces commandes dans votre calculatrice et faire fonctionner le programme.

Le programme a-t-il fait ce qui était attendu ? Peut-on faire un programme avec seulement ces commandes afin que le Rover parcourt un chemin rectangulaire ?

Dans cette leçon, vous allez étudier certaines des fonctionnalités de conduite facultatives. Les quatre commandes de conduite vues dans la compétence 1 ont toutes laissé un caractère espace après l’instruction de conduite à l'intérieur des guillemets. C'est parce qu'il y a d'autres options que vous pouvez fournir aux commandes. Cette leçon explore ces options.

Objectifs :

• Etendre les caractéristiques des instructions pour piloter le Rover
• Options RIGHT et LEFT
• Wait

Paramètres pour FORWARD et BACKWARD

Ces instructions pour piloter le Rover ont trois paramètres optionnels.

• SPEED
• TIME
• DISTANCE

On les trouve dans le menu > Hub > Rover (RV) > RV Settings ce qui est partiellement montré sur l’écran. Par ailleurs les unités de la vitesse, SPEED (UNITS/S and M/S) peuvent aussi être trouvées dans ce menu.

Utiliser DISTANCE, SPEED et TIME

Quelques exemples des différentes implémentations de l’instruction FORWARD :

• FORWARD DISTANCE # prend les mêmes paramètres que FORWARD #
• FORWARD DISTANCE # M fait avancer Rover de # Mètres
• FORWARD # SPEED # où speed est compris entre 1.4 et 2.3.
  • Les valeurs en dehors de cet intervalle renvoient une erreur du TI-Innovator™ Hub.
• FORWARD TIME #

On peut spécifier n’importe lequel de ces trois arguments dans les instructions FORWARD et BACKWARD.

Il est aussi possible d’utiliser eval( ) si la valeur que l’on souhaite utiliser est stockée dans une variable de la calculatrice ou si on souhaite utiliser le résultat d'une expression.

SPEED et TIME Programme

1. Le programme montré sur l’écran de droite a une instruction qui met le Rover en mouvement FORWARD selon une vitesse précisée SPEED ainsi que pendant un temps donné TIME :
   Send “RV FORWARD SPEED 2.3 TIME 2”
2. Compléter le programme en fournissant les arguments corrects TIME ainsi le Rover retourne à sa position initiale.
   Send “RV BACKWARD SPEED 1.4 TIME ?”

Rappel : DISTANCE = SPEED * TIME

RIGHT et LEFT Options

Par défaut, ces instructions font tourner le Rover sur la droite ou la gauche RIGHT ou LEFT de 90 degrés mais il est possible de préciser la valeur de l’angle de rotation entre (-360…360 degrés). Les valeurs négatives sont aussi permises LEFT -90 est la même chose que RIGHT 90.

3. Ajouter une instruction afin de faire tourner le Rover RIGHT 135 degrés. On doit inclure le nombre 135 entre les guillemets. Le mot DEGREES n’est pas nécessaire, mais reste disponible dans le menu RV Settings pour plus de clarté.

On peut également préciser l’unité de mesure de l’angle en RADIANS ou GRADS ces deux unités sont en revanche à préciser à partir du menu RV Settings.

Quelques exemples sont montrés sur la droite. Quel est le cap final du Rover, après le traitement de ces trois instructions ?

Ecrire un programme afin que le Rover suive le tracé d’un triangle équilatéral.

Commencer avec :
    Send “CONNECT RV”
    Send “RV FORWARD ?”
    Send “RV LEFT ?”
Ou bien utiliser une boucle.

Dans cette troisième leçon de l'unité 4, vous apprendrez à faire tourner le robot vers un angle donné, pendant un temps donné et travaillerez avec la LED COLOR du mobile.

Objectifs:

• Utiliser l’instruction TO ANGLE
• Utiliser la DEL RV.COLOR sur le Rover
• Contrôler le paramètre temps sur la calculatrice et le Rover

Cette leçon aborde trois autres caractéristiques du Rover.

• L’instruction TO ANGLE (qui est différente pour les instructions LEFT et RIGHT)
• Allumer la DEL RV.COLOR sur la face du Rover (appelée ‘Color’ dans le coin supérieur-avant-gauche à côté des indicateurs de niveau de batterie)
• Synchroniser votre programme avec les mouvements du Rover en utilisant Wait

TO ANGLE

L’instruction Send “RV TO ANGLE <nombre>” est utilisée pour faire prendre au Rover un « cap » particulier. Lorsqu’on envoie une commande pour connecter le robot, son cap est défini sur 0 degré, ce qui, dans le monde mathématique, est « Est» (face à l'origine vers l'axe X positif). Dans ce monde, le Nord est à 90 degrés, l'Ouest à 180 degrés et le Sud à 270 degrés. Voir le diagramme à droite.

Indépendamment de l'endroit où le Rover est en train de se diriger, la commande Send "RV TO ANGLE 0" fait tourner le Rover dans la direction qu'il prenait lorsque la commande "CONNECT RV" a été émise.

Par défaut, l’unité de mesure angulaire est le degré DEGREES mais on peut aussi spécifier RADIANS ou GRADS (sélectionner l’unité dans le menu the RV Settings).

Essayer ceci :
    Send “RV TO ANGLE 90”
    Wait 2
    Send “RV TO ANGLE 180”
    Wait 2
    Send “RV TO ANGLE 270”
    Wait 2
    Send “RV TO ANGLE 360”

Le Rover effectue-t-il ce qui est attendu ?

Sychroniser votre Program avec le Rover

Les programmes sur la calculatrice sont « Terminés » avant que le robot ne finisse son parcours. En effet, les instructions de conduite sont stockées dans le TI-Innovator ™ Hub plus rapidement que le Rover ne peut les traiter. Les commandes de conduite sont stockées dans une « file d’attente » et sont traitées par le TI-Innovator Hub lorsque le robot est prêt pour le faire.

Dans cette activité, nous allons écrire un programme pour se déplacer selon un motif aléatoire et allumer la DEL RV.COLOR sur le mobile pendant que le mobile se déplace. Nous utiliserons également la commande TO ANGLE et intégrerons eval() pour passer la commande appropriée.

Mise au point du Programme :

1. Commencer le programme avec l’instruction CONNECT RV.
2. Ajouter une boucle For (menu > Control > For…EndFor pour donner au Rover un mouvement aléatoire.  Il est toujours possible d’ajouter des lignes dans la boucle For si on en a besoin.

3. Dans le corps de la boucle, ajouter l’instruction de mouvement FORWARD.
   Send “RV FORWARD 1”
4. Afin que le Rover tourne selon un cap aléatoire, ajouter l’instruction
   h:=randInt(0,360)
5. Ajouter l’instruction TO ANGLE pour tourner de la direction h.
   Send “RV TO ANGLE eval(h)”
6. Exécuter le programme maintenant pour constater que:
   • Le mobile se déplace de manière aléatoire.
   • Le programme est terminé presque immédiatement alors que le mobile doit encore rouler.

RV.COLOR

Comme la DEL de couleur sur le TI-Innovator Hub est cachée à l'intérieur du Rover, nous avons une autre DEL de couleur sur le Rover à contrôler. Le nom de la DEL de couleur du Rover est RV.COLOR et fonctionne en utilisant les mêmes commandes que la DEL embarquée. On peut utiliser l'une des quatre commandes du menu> Hub> Rover (RV)> Menu RV Color situé à droite.

Send “SET RV.COLOR 255 255 255” produit une lumière blanche.

Ajouter RV.COLOR à votre Programme

7. Ajouter une instruction RV.COLOR au corps de la boucle avant l’instruction FORWARD 1. Vous êtes libre du choix de la couleur.
8. Réexécuter le programme pour voir ce qui se passe. Notez que la DEL s'allume presque immédiatement et reste allumée.

Maintenant, essayons d'allumer la DEL seulement pendant que le Rover se déplace vers l'avant. Cela nécessitera que la calculatrice attende jusqu'à ce que chaque partie soit terminée, puis éteignez la DEL pendant qu'elle clignote. Nous devons ajouter une instruction Wait à notre programme pour contrôler quand la DEL est allumée et éteinte.

9. Combien de temps faut-il à Rover pour avancer ? Environ 1 seconde ? Ajouter une instruction Wait 1 après l'instruction FORWARD 1. On peut ajuster la valeur si elle ne convient pas à votre environnement. Se Rappeler que Wait se trouve dans le menu > menu Hub.
10. Faire fonctionner le programme pour le tester.

Noter que la DEL reste allumée. Nous devons éteindre la LED après que le Rover ait fini de bouger.

11. Combien de temps le Rover prend-il ? Environ 1 seconde ? Ajouter une instruction Wait 1.
12. Après l’instruction Wait 1 éteindre la DEL en ajoutant une instruction Send “SET RV.COLOR 0 0 0”.
13. Tester votre programme. Le Rover s’éteint-il après le délai escompté ?

Nous devons également attendre pendant que le Rover se tourne vers un nouveau cap afin de s'assurer que la lumière s'est éteinte.

14. Ajouter une instruction Wait après l'instruction TO ANGLE. Cette attente devrait être assez longue pour gérer n'importe quel tour de 0 à 360 degrés.

Extension

Peut-on produire une couleur différente à chaque coin ? Astuce : Utiliser eval (quelque chose), et incorporer la valeur de h mais faire attention à la plage de valeurs permise.

Défi supplémentaire :
Programmer le temps de rotation en fonction de l'angle à tourner en observant la direction de rotation du robot en utilisant TO ANGLE.

L'application de cette unité consiste à programmer le robot afin de réaliser un polygone. L'utilisateur entre la longueur d'un côté (dans les 'unités du robot') ainsi que le nombre de côtés du polygone. Le Rover fera alors le polygone.

Objectifs :

• Instructions d’entrée
• Utilisation de l’instruction eval( ) pour le Rover
• Comprendre la construction d’un polygone
• Travailler avec les instructions COLOR et temps (Wait)

Souvenez-vous que le rôle de l’instruction eval( ) est de convertir la valeur d’une variable de la calculatrice ou d’une expression en une chaine de caractères pour être ensuite transmise au TI-Innovator™ Hub. Dans le programme SON montré sur l’écran de droite, l’utilisateur entre une valeur pour la fréquence correspondant à la variable F. La fonction eval(F) convertit ce nombre en une chaîne de caractère représentant ce que le TI-Innovator Hub peut traiter.

Ecrire un programme qui demande la longueur d'un côté et le nombre de côtés d'un polygone puis déplace le Rover (voir modèle). On peut ajouter un feutre au Rover et dessiner le polygone sur une grande feuille de papier. Se rappeler que 1 unité fait 10 cm.
Option : Faire allumer la DEL COLOR aux sommets du polygone.

Quelques instructions utiles :
    Request “LONGUEUR DU CÔTE ?”,L
    Request “NOMBRE DE CÔTES ?”,N
    For I,1,N
    Send “RV FORWARD eval(L)”
    Send “RV RIGHT <quelque chose>”
End

Dans cette première leçon de l'unité 5, vous apprendrez à utiliser le capteur à ultrasons de mesure de distance « Ranger » du TI-Innovator Rover et testerez son aptitude à contrôler le mouvement du mobile.

Objectifs :

• Utiliser l’instruction READ RV.RANGER pour mesurer une distance
• Utiliser l’instruction pour modifier le mouvement du Rover

À l'avant du TI-Innovator Rover se trouve un capteur appelé Ultrasonic Ranger. Le Ranger mesure la distance à un objet situé devant le Rover. Cette information peut être utilisée pour contrôler le mouvement du mobile. Si le Rover se rapproche trop d'un obstacle, il peut être programmé pour changer de direction afin d'éviter l'obstacle.

Nous allons d'abord écrire un programme de test pour déterminer comment le Ranger fonctionne et ensuite, dans la Compétence 2, nous utiliserons cette information pour contrôler le mouvement du Rover.

Le programme lira la valeur mesurée par le Ranger du Rover et affichera cette valeur sur l'écran de la calculatrice. Le Rover ne sera pas en mouvement dans ce programme. On bouge la main devant le Rover ou on tient le Rover dans les mains et on pointe le robot vers divers obstacles pour observer les mesures.

Commencer le programme Test

1. Commencer par l’instruction Send “CONNECT RV” à partir du menu :
   menu > Hub > Rover (RV).

La boucle principale

Nous utiliserons une boucle While pour contrôler le programme. Lorsque la distance est inférieure à une valeur donnée, le programme s’arrête. Nous utilisons la variable dist pour enregistrer la distance mesurée.

2. Initialiser dist à 1 (dist:=1).
3. Sélectionner While…EndWhile à partir du menu : menu > Control. Coder la boucle While tant que la variable dist est supérieure 0.1.

Le corps de la boucle

4. L’instruction READ RV.RANGER se trouve dans le menu
   menu > Hub > Rover (RV) > Read RV Sensors.
5. Sélectionner Send “READ RV.RANGER”.

6. Ajouter les commandes
       Get dist
       Wait 0.25
   Au corps de la boucle.

Obtenir une valeur à partir d'un capteur nécessite à la fois la commande Send"READ RV ..." pour obtenir une valeur du capteur dans le Hub TI-Innovator™ et la commande Get pour obtenir la valeur du TI-Innovator Hub sur le terminal mobile. La commande Wait 0.25 est utilisée pour ralentir l'opération afin de faciliter la lecture et la compréhension des nombres.

Afficher la valeur

7. A partir du menu : menu > I/O, select DispAt. Cette instruction est utilisée pour afficher la valeur de la variable dist à une position fixe sur l’écran de la calculatrice.

L’instruction DispAt requiert (au moins) deux arguments : un numéro de ligne de 1 à 8 et une variable ou une valeur à afficher. Pour afficher quelque chose plus près du centre de l'écran, ajouter des espaces de « remplissage » après la variable ou la valeur.

8. Exemple : DispAt 1, dist, “           “

Faire fonctionner le Programme

9. Enregistrer et exécuter le programme en appuyant sur ctrl + R. Pendant l'exécution du programme, l'écran de l'application Calcul affiche un nombre (distance). Déplacer votre main devant le Rover (ou déplacer le Rover) afin que le Ranger puisse mesurer différentes distances. En quelles unités ces distances sont-elles mesurées ? Quand le programme s’achèvera-t-il ?

Réponse : Les unités de mesure de la distance sont en mètres, et le programme se termine lorsque la distance mesurée est inférieure à 0,1 m ou 10 cm.

Dans la première leçon de l'unité 5, vous avez testé le capteur de distance du Rover pour voir comment le capteur lit et affiche une valeur. Cette leçon vous a donné l’occasion de progresser afin de contrôler le mouvement du mobile.

Objectifs :

• Utiliser l’instruction READ RV.RANGER pour déterminer la distance à un obstacle.
• Contrôler le mouvement du Rover lorsque celui-ci se rapproche trop d’un obstacle.
• Gérer le programme du Rover dans la calculatrice.

Ecrivons un programme pour que le Rover puisse aller et venir entre deux murs. Nous commencerons par faire avancer le Rover FORWARD, ensuite nous lirons la valeur lue par le capteur Ranger et lorsque le Rover se rapprochera trop du mur, celui-ci fera demi-tour et avancera de nouveau FORWARD.

La grande idée

    Dans une boucle For (qui finira par se terminer)
        Démarrer le Rover en mouvement
        Alors que la distance est supérieure à environ 3 cm
            continuer à surveiller le capteur Ranger
        Mettre fin à la boucle While
        STOP, tournez à DROITE 180
    Terminer la boucle For

1. Commencer un nouveau programme
2. Ajouter une boucle For contenant 10 itérations.
3. Ajouter l’instruction FORWARD 100 UNITS afin de faire avancer le robot sur 10 mètres (100 * 0.1m par unité)

Comme dans la leçon précédente, nous utiliserons la variable dist pour représenter la distance du Ranger à un obstacle.

4. Initialiser dist à 1, et insérer la boucle While dist > 0.25.

Noter les deux End dans le code : une pour la boucle EndFor un autre pour la boucle EndWhile. Ceci est appelé des boucles imbriquées.

5. Nous insérons ensuite le code dans le corps de la boucle While.
6. Ajouter l’instruction Send “READ RV.RANGER”.
7. Utiliser l’instruction Get pour enregistrer la valeur lue dans la variable dist.

Cela termine la boucle While. Le Rover avance de 10 mètres et la boucle While surveille la distance. Si on le souhaite, ajouter une instruction DispAt à cette boucle While pour afficher la distance actuelle afin de s’assurer que les choses fonctionnent correctement.

Lorsque la boucle While se termine, cela indique que le mobile est trop proche d'un obstacle. Nous allons dire au Rover d'arrêter de se déplacer vers l'avant et de faire demi-tour. Cependant, nous n'avons pas besoin de dire au Rover de se déplacer à nouveau.

8. Après le End de la boucle While mais avant le End de la boucle For, ajouter l’instruction RV STOP ainsi que la commande RV RIGHT 180.
9. Ajouter l’instruction Wait 2 pour donner au Rover le temps de se retourner avant de se déplacer à nouveau. (Ne pas oublier que la commande FORWARD est au début de la boucle For.)
10. Tester le programme. Lorsque le Rover se rapproche d'un obstacle, il doit faire demi-tour et aller dans la direction opposée. Ajuster les valeurs (distance minimum et temps d'attente), selon les besoins, de la surface de déplacement. Si le Rover se rapproche trop du mur, l'arrière du Rover pourrait heurter le mur en se retournant.

Dans cette troisième leçon de l'unité 5, nous introduisons le capteur COLORINPUT et utilisons la valeur lue par celui-ci afin de modifier la direction du robot.

Objectifs:

• READ COLORINPUT
• Utiliser la valeur lue pour modifier le cap pris par le Rover

Le Rover a un capteur COLORINPUT sur le fond. La lumière réfléchit par le sol est utilisée par le capteur pour mieux « voir » la couleur sur le sol. Nous écrirons un programme pour que le Rover perçoive un changement de couleur. La couleur vue par le capteur est convertie par le TI-Innovator ™ Hub en une des neuf valeurs possibles représentant les couleurs :

1 = Rouge
2 = Vert
3 = Bleu
4 = Cyan
5 = Magenta
6 =Jaune
7 = Noir
8 = Blanc
9 = Gris

1. Commencer un nouveau programme.

2. Nous utiliserons une boucle For afin de demander au Rover de tourner 4 fois.

3. Nous utiliserons une boucle While pour repérer un changement de couleur mais d'abord nous devons savoir quelle couleur « voit » le Rover. Nous avons lu RV.COLORINPUT et obtenu sa valeur dans la variable floor_color de la calculatrice.

4. Nous initialisons ensuite une autre variable, color, pour lancer la boucle While. La couleur sera celle que le Rover « voit » lorsqu'il est en mouvement. Au départ, nous définissons la couleur comme étant floor_color. Ensuite, nous commençons l’exécution de la boucle For le Rover se déplaçant vers l'avant.

5. Nous codons à présent la boucle While pour comparer la variable color avec floor_color incluse dans la boucle While nous recherchons un changement de la variable color.
6. Ne pas oublier l’instruction de fin de boucle EndWhile pour la boucle While.

7. Dans la boucle While, nous surveillons le capteur de couleur tant que le robot est en mouvement. Nous stockons la valeur de la couleur dans la variable color. La boucle se termine lorsque la couleur (la couleur 'actuelle') est différente de floor_color (la couleur 'd’origine').

8. À la fin de la boucle While, nous demandons au Rover de s’arrêter et d'aller à DROITE. Notez que ces deux instructions se situent entre les instructions EndWhile et EndFor, de sorte que le programme fasse tourner le robot quatre fois à droite lorsqu'il détecte un changement de couleur de la surface.

Note : “RV STOP” annule toutes les commandes de mouvement du Rover.

9. Ajouter une instruction FORWARD 1 et une instruction Wait 1 afin que le robot s'éloigne de l'emplacement coloré et avant que le programme ne se répète pour détecter à nouveau une nouvelle couleur "d’origine" (floor_color).
10. Tester le programme sur le sol sur une surface de couleur uniforme (blanc). Placer un point de couleur contrasté (noir) d'environ 5 cm sur 5 cm sur le sol dans la trajectoire du robot afin que le capteur COLORINPUT le voit. Quand le Rover passe au-dessus de la tâche, il devrait s'arrêter, puis tourner et repartir. Ramasser le point de couleur, et placer-le à nouveau devant le Rover. Cela devra se produire quatre fois avant que le programme ne se termine.

Dans cette application de l'unité 5, vous allez écrire un programme afin que le Rover suive un chemin sur une feuille de papier.

Objectifs :

• Utiliser COLORINPUT pour détecter et suivre un chemin sur une feuille de papier.
• Vous aurez besoin d'un exemple de chemin sur papier (Voir le fichier PDF des pages de test.)

Écrire un programme afin que le Rover suive une trajectoire courbe sur le papier en utilisant le capteur de couleur. Le chemin sera décrit par deux couleurs différentes comme ceci :

Le Rover va commencer sur le bord gauche de la page et rouler vers la droite en suivant le chemin incurvé sur le papier. Lorsque le Rover « voit » la couleur ROUGE, il se tourne un peu vers la gauche et avance un peu. Lorsque le Rover « voit » le BLANC, il tourne légèrement à droite et avance un peu.

Expérimenter avec l'angle de braquage et la distance de déplacement pour voir comment le Rover réagit aux différentes couleurs.

Si votre page est rouge et blanche comme dans l'image ci-dessus, on peut utiliser READ COLORINPUT.RED pour voir quelles valeurs sont données par chaque côté du papier. Si on utilise une couleur différente comme le noir, on peut utiliser READ COLORINPUT.GRAY (ou.GREEN ou .BLUE).

Voici un programme, colortest (), à réaliser pour tester le capteur de couleur du robot. Quelles valeurs doit-on utiliser dans le programme ?

Define colortest()=
Prgm
Send "CONNECT RV"
While getKey(0)=" "
    DispAt 1,"Appuyer sur une touche pour arrêter."
    Send "READ RV.COLORINPUT.RED"
    Get r
    DispAt 2,"Valeur de la couleur : ", r
EndWhile
EndPrgm

Noter que le robot ne bouge pas dans ce programme. Utiliser le programme ci-dessus pour déterminer ce que le mobile voit de chaque côté de la ligne ondulée en observant les valeurs de r affichées. Utiliser cette information pour concevoir le programme. Tester le programme en plaçant le mobile sur le bord gauche du papier avec le capteur de couleur près de la frontière entre les côtés rouge et blanc du papier. S’assurer que le capteur de couleur du Rover soit sur le papier. Le programme devrait fonctionner, peu importe où le Rover commence.

Dans cette première leçon de l’unité 6, vous allez apprendre à connaitre le système de coordonnées utilisé par le TI-Innovator™ Rover afin de le mettre en mouvement.

Objectifs:

• Comprendre le système de coordonnées du Rover, la position initiale et le cap.
• Mettre le Rover en mouvement vers un point de coordonnées fixées.
• Utiliser les mathématiques pour calculer une distance.

Le Rover dispose d’un système de coordonnées intégré exactement comme un repère. Lorsque vous envoyez l’instruction Send “CONNECT RV”, la position du Rover sur une grille virtuelle est (0,0) et son cap est de 0 degrés (vers l’axe des abscisses positives).

FORWARD met le robot en mouvement vers la droite.
LEFT tourne le Rover de 90 degrés dans le sens anti horaire.

Notre programme demandera au Rover d’atteindre un point de coordonnées données sur sa grille. Nous utiliserons l’instruction Request pour entrer les valeurs de x et y et faire en sorte que le Rover atteigne le point de coordonnées (x, y) et retourne ensuite à son origine.

1. Commencer votre nouveau programme avec les instructions habituelles.
2. Insérer l’instruction Request pour x et y.
   Souvenez-vous que l’instruction Request affichera un message entre guillemets (le « prompt »).
3. L’instruction Text vous laisse le temps de positionner le Rover à l’origine et la face avant orientée dans la bonne direction.

4. Ajouter l’instruction TO XY. Celle-ci se trouve dans le menu menu > Hub > Rover (RV) > Drive RV et apparaitra dans votre programme non complétée.
   
       Send “RV TO XY ”

5. Les coordonnées x et y peuvent être ajoutées et seront sauvegardées respectivement dans les variables x et y. Afin que le TI-Innovator™ Hub utilise ces valeurs, vous devez utiliser la fonction eval( ) deux fois.
6. Ajouter eval(x) eval(yY) à la commande.
   Send “RV TO XY eval(x) eval(y)”
7. Tester maintenant votre programme. Le Rover doit atteindre le point de coordonnées que vous avez fixé.

8. Ajouter une commande Wait afin de laisser au Rover le temps d’atteindre votre point, puis de retourner à son point de départ. Utiliser simplement les nombres 0 et 0 séparés par un espace. Ajouter par ailleurs une instruction afin de faire retourner le Rover à sa position d’origine (TO ANGLE 0).
9. Tester de nouveau votre programme. Cette fois, le Rover devrait atteindre le point fixé, puis retourner à sa position d’origine et se placer selon le cap initial.

Dans cette leçon vous allez utiliser le TI-Innovator™ Rover pour marquer dans le plan deux points de coordonnées fixées et déterminer la distance entre ces deux points.

Objectifs :

• Se déplacer entre deux points de coordonnées différentes
• MARQUER les points en utilisant un SON, une COULEUR et un crayon feutre.
• Calculer et afficher la distance entre deux points.
• Mesurer la distance entre ces deux points afin de confirmer le calcul.
• Estimer l’erreur sur le calcul et la comparer à celle de la mesure.

Cette activité nécessite l’utilisation d’un crayon feutre dans le porte crayon afin de laisser une trace sur le papier.

Vous écrirez un programme qui marque la trace de deux points dans le plan et calculerez la distance entre ces deux points. Ensuite, vous mesurerez la distance entre ces deux points et comparerez la mesure au calcul.

1. Commencer votre programme avec l’instruction CONNECT RV et inclure la commande du Rover fixant l’unité de mesure de distance à un cm (1 cm = 0.01 mètre). L’instruction RV.GRID. M/UNIT se trouve dans le menu Rover (RV)… > RV Setup…
   
       Send(“SET RV.GRID.M/UNIT .01”)

2. Inclure quatre instructions Request pour les coordonnées des deux points points. Garder à l’esprit que pour la TI-Nspire™ CX les variables peuvent utiliser plusieurs caractères pour les coordonnées x1, y1, x2, et y2 par exemple.
   
       Request “abscisse du premier point (x1):”, x1
       Request “ordonnée du premier point (y1):”, y1
       Request “abscisse du second point (x2):”, x2
       Request “ordonnée du second (y2):”, y2
   
   Nous utilisons également la commande personnalisable Text afin de prendre le temps de préparer le Rover au mouvement
   
       Text “Presser enter pour commencer.”

3. Ensuite nous demanderons au Rover de se déplacer au premier point, puis d’attendre Wait pendant que le Rover se déplace, ensuite d’émettre un SON et d’allumer une DEL de couleur afin de signaler que le Rover a atteint ce point. Nous utiliserons également une instruction Pause et la diode s’éteindra après avoir appuyé sur la touche enter. Souvenez-vous : le son ne sera joué que pendant une seconde.

4. Ensuite, nous attendrons que le Rover atteigne le second point. Un son différent et une autre couleur de DEL seront utilisés afin d’indiquer que le Rover a atteint ce point. Une instruction Wait est utilisée afin de conserver la diode allumée pendant quelques secondes.

Conseil : Copier et coller le texte relatif au premier point puis apporter les modifications qui concernent le second.

5. Finalement, le programme calcule et affiche la valeur de la distance entre deux points en utilisant la relation mathématique :
   

   

   Attention aux parenthèses.
6. Mesurer la longueur du second segment dessiné entre les deux points et comparer cette mesure à la valeur calculée. Comment comparer la mesure à la valeur calculée ? Que l est le pourcentage d’erreur sur la mesure ?
   (mesure - distance) /distance*100

Dans cette leçon, vous allez écrire un programme pour créer une forme bidimensionnelle prédéfinie. Vous allez utiliser les listes dans le programme, ainsi qu’une boucle afin de dessiner les points sur le papier.

Objectifs :

• Définir des listes et utiliser des couples de coordonnées stockées dans celles-ci.
• Dessiner sur le papier une forme à deux dimensions et la reproduire sur la calculatrice.
• Laisser le Rover dessiner la forme sur le papier ou simplement suivre le modèle.

Ce projet nécessite l’utilisation de deux listes qui représentent les coordonnées x et y d’une forme de votre conception. Dans cette leçon, nous allons dessiner un bloc représentant la lettre T comme illustré ci-contre. Notre objectif est de faire en sorte que le Rover dessine cette lettre en utilisant un stylo feutre ou suive le chemin si aucun feutre n’est disponible.

1. Tout d’abord, créer deux listes contenant les paires de coordonnées. Ces listes représentent les coordonnées du bloc de la lettre T. Les abscisses sont dans la liste xs et les ordonnées dans la liste ys. Si vous le souhaitez, vous pouvez créer un bloc lettre différent.
   
   Optionnel : Paramétrer une représentation graphique des données afin de vous assurer que celle-ci correspond bien à ce que vous souhaitez.

2. Maintenant nous pouvons écrire un programme qui commandera au Rover le dessin de la forme. Commencer le programme de manière habituelle, éventuellement, fixer l’unité M/UNIT à une valeur plus petite afin que le graphique ne soit pas trop grand. Sélectionner prgm > Hub > Rover (RV)… > RV Setup… > Send(“SET RV.GRID.M/UNIT.

Vous devez vous souvenir que 0.01 fixe l’unité à 1 cm. Si vous voulez que l’unité soit de 1 pouce, utiliser 0.0254. Ajouter les guillemets à la fin de l’instruction ainsi que la parenthèse fermante.

    Send “SET RV.GRID.M/UNIT .0254”

3. Nous utilisons une boucle For pour traiter chaque élément des deux listes. Souvenez-vous que la boucle For exige trois arguments, la variable i qui contrôle la boucle, commence à 1, et termine à, dim(xs). EndFor est nécessaire à la fin du corps de la boucle.
   
       For i, 1, dim(xs)
       EndFor
   
   Note : dim(xs) est le nombre d’éléments de la liste xs.

4. Le corps de la boucle (le code à l’intérieur de la boucle For est constituée d’une seule instruction indiquant au Rover d’atteindre chaque point dans l’ordre.
   
       Send "RV TO XY eval(xs[i]) eval(ys[i])"
5. Après avoir entré le code, quitter et exécuter le programme et observer si votre forme est correctement dessinée.

Vue d’ensemble : Les explorations avec des nombres aléatoires peuvent conduire à des observations fascinantes. Cette application vous donne l’occasion d’explorer les probabilités et de programmer ainsi le déplacement du Rover sur une grille.

Objectifs :

• Utiliser les coordonnées pour simuler une « marche aléatoire »
• Utiliser les compteurs dans un programme
• Utiliser les instructions conditionnelles non et and

Une « marche aléatoire » est une expérience programmée sur un ordinateur. Cette activité relie différentes compétences en programmation.

Le Problème :

Supposons que les rues de votre ville soient disposées sur un quadrillage, et que votre école se trouve au point de coordonnées (0,0) de votre repère. Votre maison est située au point de coordonnées (7,3), ce qui représente 7 blocs à l’Est de l’école et 3 blocs au Nord. On a représenté sur le graphique ci-contre une image de la situation.

En partant de l’école, vous marchez de façon aléatoire dans une direction (Nord, Sud, Est ou Ouest) en parcourant à chaque fois un bloc de bâtiment, A chaque intersection, vous avancez d’un bloc à chaque fois. Pourrez-vous rentrer ainsi chez vous ? Combien de blocs seront nécessaires ?

La planification est une partie importante du codage. Pensez à ce que le Rover peut faire et à ce que votre langage de programmation peut également faire. Conservez à l’esprit que lorsque vous travaillez avec des nombres aléatoires, vous êtes à la merci de la machine. Cela peut prendre beaucoup de temps avant que le Rover ne rentre « à la maison ». Nous préciserons donc dans le programme un nombre limité de blocs.

1. Commencer le programme avec l’instruction CONNECT RV. Fixer la taille de la grille du Rover à 5 cm en utilisant Send(“SET RV.GRID.M/UNIT .05”).
   
   Souvenez-vous que cette instruction se trouve dans le menu prgm > Hub > Rover (RV)… > RV Setup…et change l’unité de mouvement du Rover (en utilisant FORWARD 1) depuis 10 cm jusqu’à 5 cm, en autorisant plus de points sur la grille dans un espace plus petit.

Initialiser les variables

2. Sauvegarder les coordonnées de la maison (7,3) et le nombre de blocs parcourus (0) respectivement dans les variables home_x, home_y et blocs. La variable blocs sera utilisée pour suivre le nombre de blocs parcourus par le Rover et également pour le stopper s’il va trop loin. Le programme s’arrête au bout d’un certain nombre de blocs parcourus.
   
   Nous utilisons 20 blocs comme variable exhaustive afin de signifier au programme de s’arrêter.
3. Le Rover arrive « à la maison » lorsqu’il atteint le point de coordonnées (x, y), fixées à (7, 3). Initialiser ensemble les variables, x et y, à zéro.

La boucle principale

4. La boucle principale consiste à réaliser une boucle While en adressant deux conditions. Les conditions sont fixées en utilisant la variable (when x=home_x et y=home_y) ou en quittant si le nombre de blocs est atteint (quand blocs=quit).
   La boucle While continue tant que ces deux conditions sont fausses, Nous avons donc mis en place les conditions opposées.
   
       While blocs<quit and not(x=home_x and y=home_y)
   
   Souvenez-vous que les valeurs relatives au problème sont sauvegardées dans les variables quit, home_x, et home_y.
   
   not(afin de s’assurer que le programme se poursuit aussi longtemps que le Rover n’est pas rentré « à la maison ». En logique, and not est « l’opposé » de ou.
5. Ne pas oublier d’inclure une instruction EndWhile si vous tapez le code manuellement.

Corps de la boucle

1. Incrémenter la variable blocs (le nombre de blocs marchés):
   
       blocs:=blocs+1
2. Choisir une direction aléatoire (Nord, Sud, Est, ou Ouest):
   • L’instruction TO ANGLE demande au Rover de pivoter dans une direction « absolue » : 0 est l’Est, 90 est le Nord, 180 est l’Ouest, et 270 est le Sud
   • randInt(0,3) donne un nombre aléatoire qui peut être 0, 1, 2, ou 3
   • Multiplier cette valeur par 90 pour obtenir 0, 90, 180, ou 270
   • L’instruction pour obtenir une direction aléatoire est :
     dir:=90*randInt(0,3)

3. Tourner le Rover d’un angle de valeur aléatoire dir: Send “RV TO ANGLE eval(dir)”.
4. Faire avancer le Rover de 1 unité (1 bloc dans notre simulation): Send “RV FORWARD 1”.
5. Mettre à jour la position du Rover dans le programme :
   • Si le Rover va au Nord alors incrémenter y de 1
   • Si le Rover va à l’Est alors incrémenter x de 1
   • Si le Rover va au Sud alors incrémenter y de 1
   • Si le Rover va à l’Ouest alors incrémenter x de 1

Inclure quelques instructions Wait afin de conserver le déroulement du programme synchronisé avec les mouvements du Rover. Tourner prend du temps et avancer également. Le délai Wait dépend donc de l’angle de rotation effectué et de la distance parcourue. Aussi vous devez réaliser quelques expérimentations afin de fixer précisément les délais à fixer à l’instruction.

Après la boucle

La fin de la boucle s’effectue selon deux possibilités :

• If blocs=quit, alors le Rover quitte la marche de manière impromptue (objectif non atteint). Joue un son de « tristesse », affiche une couleur rouge sur la DEL du Rover, et affiche « ROVER QUITTE » sur l’écran de la calculatrice.
• Le Rover est « rentré à la maison ». Joue un son de victoire, affiche une couleur verte sur le DEL, et affiche un message « ROVER EST RENTRE » sur l’écran de la calculatrice.
• Dans les autres cas, afficher le nombre de blocs marchés.
• Ne pas oublier de fermer la structure de test par EndIf à la fin « If… Then… Else… EndIf ».

Pouvez-vous faire effectuer au Rover une danse joyeuse lorsqu’il a atteint son objectif ?