TI Codes : TI-83 Premium CE 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 programmes de le  TI-83 Premium CE
• 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-83 Premium CE. L’écran de la calculatrice s’illumine. Sur le Hub TI-Innovator, une lumière verte s’allume, indiquant que le Hub TI-Innovator est sous tension et 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.

Pour écrire un programme dans la calculatrice, vous utiliserez la touche [prgm] pour coller des instructions dans le programme.

• La commande Send( est utilisée pour envoyer des commandes au Hub TI-Innovator afin de produire une action physique (allumer une lampe, produire un son, faire tourner un moteur, etc.).
• Les commandes du Hub TI-Innovator se trouvent également en appuyant sur la touche [prgm] à partir du menu HUB.

Mise au point du Programme LUMIERE1
Votre premier programme commandera le TI-Innovator Hub pour mettre sous tension une diode (DEL) pendant 5 secondes.

1. Pour commencer un nouveau programme, appuyer sur [prgm] > New.
2. Taper le nom du programme (nous utilisons le non de LUMIERE1), et valider par entrer.

Votre 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 instruction.

3. Appuyer sur la touche [prgm] et sélectionner le menu HUB.
4. Choisir l’item dans le menu Send(“SET….
5. Puis choisir LIGHT à partir du sous menu Send “SET.

6. Terminer la ligne de commande en complétant la fin de l’instruction.
   • Pour obtenir ON et TIME, appuyer sur la touche [prgm], choisir le menu HUB puis le sous menu Settings.
   • Entrer le nombre 5 pour 5 secondes.
   
   

   Send(“SET LIGHT ON TIME 5”)

   Ne pas oublier les guillemets ([alpha] [ + ]) et les parenthèses à la fin de la ligne de commande. Si besoin, « l’espace » est au-dessus de la touche 0 (zero).

Le programme complet est montré sur la droite.

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

Faire fonctionner le programme

1. Assurez-vous que le TI-Innovator Hub soit connecté à la calculatrice.
2. Appuyer sur [alpha] F5, puis sélectionner « Exécuter Programme ». Cette action quitte l’éditeur de programmes et fait fonctionner celui-ci.

* La touche MENU F5, incorporée au système d’exploitation OS v5.3, est seulement fonctionnelle dans l’éditeur de programmes. Ce menu contient des outils d'édition supplémentaires, tels que : Annuler, Couper, Copier et Coller, etc. Ce sont de nouvelles fonctionnalités très pratiques que vous apprécierez lorsque vous écrivez des programmes plus complexes.

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

La calculatrice affiche « Fait » lorsque le programme est terminé. Notez que le programme se termine réellement avant que la lumière ne s'éteigne. Pour que le programme se termine au moment où la lumière s'éteint, nous devons indiquer à la calculatrice d'attendre aussi longtemps que la lumière reste allumée.

Pour ajouter une commande au programme, nous devons l’éditer.

1. Appuyer sur la touche [prgm] et utiliser les flèches de direction pour choisir EDIT.
2. Sélectionner le nom de votre programme dans la liste.
3. Déplacer le curseur à la fin du programme.
4. Appuyer sur [entrer] pour ajouter une nouvelle ligne.
5. Ajouter l’instruction Wait 5 en appuyant sur [prgm], puis [▾] afin d’atteindre Wait dans le menu CTL, et appuyer sur entrer. Ensuite écrire le nombre 5.

Faire fonctionner de nouveau le programme. Si le programme était le dernier élément de l'écran d'accueil, appuyez simplement sur [entrer]. Le programme se termine à peu près au même moment où le voyant rouge s'éteint.

Extensions

Nous pouvons enlever l’élément TIME de l’instruction Send et contrôler le temps à l’aide de la commande Wait de la calculatrice. Comme la DEL reste allumée et une fois allumée, vous devrez également « éteindre la lumière » dans votre programme.

• Pour mettre la diode hors tension :
  
  Send(“SET LIGHT OFF”)
  
  
• Ajouter des instructions au programme pour que la lumière clignote plusieurs fois.

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 commandes Prompt et Input
• Contrôler la couleur d’une diode DEL

Utiliser les nouvelles possibilités du menu d’édition F5 ([alpha] [graphe]) pour améliorer le confort d’édition

La couleur d’une Diode Electroluminescente DEL  est construite selon trois « canaux » : Rouge Vert et Bleu. D’où le nom de diode RVB “RVB DEL”.

Pour obtenir une couleur particulière, nous devons ajuster le mélange de chacune d’entre elles.

Dans ce programme, vous expérimenterez le fonctionnement de la diode RVB. Vous entrerez une valeur pour chaque couleur Rouge, Vert et Bleu afin de faire clignoter la diode.

En plus de l’étude des couleurs de la diode RVB, Nous présentons le premier programme qui accepte une entrée de l’utilisateur, alors que celui-ci est en fonctionnement Prompt.

La commande  Prompt autorise l’utilisateur à entrer des variables pendant l’exécution d’un programme. Elle est appelée Prompt car elle fournit un message visuel (le nom de la variable suivi d’un point d’interrogation) lorsque cette commande est exécutée, l’utilisateur entre la valeur demandée en réponse.

Les syntaxes possibles de l’instruction sont :

• Prompt <variable>
• Prompt <variable1>,<variable2>,<variable3>,…

Les variables numériques de la TI-83 Premium CE sont les lettres A..Z et Ɵ (theta).  On peut aussi leur affecter des nombres décimaux et des nombres complexes

Dans ce programme, nous utiliserons la commande Prompt pour les couleurs rouge, vert et bleu une valeur comprise dans la gamme (0 – 255) et ensuite la transmettre à la diode RVB.  Afin d’être efficace, les trois valeurs seront incluses dans une seule commande.

Mise au point du programme.

1. Appuyer sur la touche [prgm] > Nouveau, entrer un nom pour le programme (nous utilisons le nom COULEUR1 ici), et appuyer sur entrée.
2. Ajouter une commande Effécran en appuyant sur la touche [prgm] puis flèche de direction pour atteindre le menu E/S, et sélectionner 8: Effécran.
3. Ajouter une commande Prompt en appuyant sur [prgm], puis flèche de direction jusqu’au menu E/S, et sélectionner 2: Prompt.
4. Ajouter la variable R en sélectionnant [ALPHA] [x] .
5. Continuer en ajoutant les variables pour le Vert et le Bleu. Ne pas oublier les guillemets entre les noms des variables.

Maintenant nous allons utiliser la commande Send( pour envoyer une instruction au Hub TI-Innovator.

1. Appuyer sur la touche [prgm] puis utiliser les touches de direction pour atteindre le menu HUB.
2. Sélectionner Send(“SET… puis choisir COLOR.

Note:

Vous ne pouvez pas envoyer les variables R V B comme les valeurs de la couleur avec la commande Send( car les lettres R, V et B seraient envoyées au Hub TI-Innovator Hub à la place des valeurs de ces variables.

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

Compléter le programme :

1. Ajouter la fonction eval( en appuyant sur la touche [prgm], puis flèche de direction  jusqu’au menu HUB, et sélectionner eval(.
2. Taper la lettre R et la parenthèse de droite. Ajouter un espace ([ALPHA] [0]).
3. Refaire la même opération deux fois pour le  V et B.  Ne pas oublier d’ajouter un espace entre l’instruction eval().

4. Finalement après la troisième instruction eval(B, ajouter les guillemets et la parenthèse droite afin de fermer la commande Send(.

La commande complète sera :

Send(“SET COLOR eval(R) eval(V) eval(B)”)

Faire fonctionner le programme

Assurez-vous que le TI-Innovator Hub soit connecté à la calculatrice.

Pour faire fonctionner un programme à partir de l’éditeur de programmes

1. Appuyer sur les touches [alpha] [graphe] qui correspond à F5.
2. Sélectionner Exécuter Programme.

Cette séquence d'étapes quitte l'éditeur de programme et exécute le programme sur l'écran d'accueil.

3. Une pour V, et une pour B.
4. Entrer trois nombres entre 0 et 255 pour chaque variable.
5. Après avoir entré la dernière valeur, observer la couleur de la diode RVB sur le Hub TI-Innovator.

Pour essayer différentes valeurs, appuyer sur [entrer] afin de relancer le programme, et entrer de nouvelles valeurs.

Dans cette troisième leçon de l’unité 1, vous allez apprendre une autre méthode pour entrer une donnée dans un programme afin de contrôler un SON sur le Hub TI-Innovator™.

Objectifs :

• Utiliser l’instruction Input
• Contrôler la fréquence et la temporisation d’un (SON)

Le Hub TI-Innovator comporte un haut-parleur embarqué appelé ‘SOUND’.

Vous contrôlez le son émis par ce haut-parleur en envoyant une valeur de fréquence. La fréquence d’un son se mesure en Hertz (Hz), ou « cycles par seconde ».

La commandes Input, et Prompt, se trouve en appuyant sur la touche [prgm] menu E/S. L’instruction Input est aussi employée afin que l’utilisateur fournisse une entrée. Mais elle contient une fonctionnalité qui permet au programmeur de créer un message plus explicite que la simple commande Prompt étudiée précédemment.

Syntaxe de la commande: Input <Chaîne> , <Variable>

Dans ce programme sur le SON, nous utilisons la commande Input.

Mise au point du programme SON

1. Commencer un nouveau programme et le nommer SON1.
2. Ajouter la commande Effécran et Input à partir du menu E/S.
3. Après la commande Input utiliser pour taper la chaîne de caractères “FREQUENCE ? ”.
4. Sortir du mode [alpha] pour taper la virgule.
5. Puis ajouter la variable qui représentera la fréquence F ([alpha] F)
6. Ajouter une autre commande Input afin de proposer à l’utilisateur d’entrer une valeur fixant la durée d’émission du son.
7. Comme avec le programme COULEUR1 de la compétence précédente, nous devons utiliser la fonction eval( ) afin d’évaluer les variables F et T

Terminer le programme SON1

1. Sélectionner Send(“SET… et SOUND en appuyant sur la touche [PRGM]
2. Utiliser les touches de direction pour atteindre le  menu HUB, et sélectionner 1: Send(“SET….
3. Puis choisir  6:SOUND
4. Sélectionner eval(en appuyant sur  [PRGM][  ] 6[.]
5. Utiliser les touches de direction pour atteindre le  menu HUB, et sélectionner 6:eval(.
6. Ajouter la variable F, et fermer en utilisant les parenthèses.
7. Ajouter un espace ([2nde][0]) puis une autre fonction eval( pour la variable T.
8. Ajouter la variable T, et fermer en utilisant les parenthèses.
9. Fermer la commande Send( à l’aide de guillemets et de parenthèses.

Faire fonctionner le programme

1. Appuyer sur [alpha][graphe] ([ 1 ] : Exécuter Programme).
2. Entrer la fréquence 440 et 5 pour la valeur du TEMPS.
   • Vous entendrez un son de fréquence 440 Hz pendant 5 secondes. Cela signifie que la membrane du haut-parleur vibrera 440 fois par seconde pendant 5 secondes.
   • Dans un environnement bruyant, vous pourriez avoir à tenir le Hub TI-Innovator près de votre oreille pour entendre le son.
3. Presser [entrer] afin de relancer le programme avec une autre valeur de fréquence et de temps.
4. Expérimentez avec d'autres fréquences.

Écrire un programme qui contrôle un feux de circulation.

Objectifs :

• Contrôler la diode RVB pour simuler les 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 circulation. La lumière sera simulée en utilisant la couleur de DEL sur le Hub TI-Innovator™.

La DEL de couleur doit passer du vert au jaune au rouge et du rouge au jaune au vert. Vous fixerez la temporisation.

Votre programme aura une séquence d'instructions qui simulent le changement du rouge au vert au jaune au rouge. Une structure de contrôle de séquence dans la programmation est un ensemble d'états qui sont traités l'un après l'autre, de haut en bas, sans interruption.

Utilser Disp et Pause

La commande Disp affiche un message sur l’écran d’accueil de la calculatrice. Cela peut être utilisé pour afficher la valeur d’une variable, par exemple Disp X, ou bien afficher une chaîne de caractère comme montré sur l’écran de droite. Vous pouvez localiser l’instruction Disp en appuyant sur la touche [prgm] puis [▾] jusqu’au menu E/S puis sélectionner Disp.

La commande Pause affiche aussi un message mais arrête la calculatrice en cessant de traiter toutes les autres instructions jusqu'à ce que l'utilisateur appuie sur [entrer]. Vous pouvez trouver Pause en appuyant sur [prgm] et en sélectionnant 8: Pause.

Créer un titre à l’écran

1. Commencer un nouveau programme et le nommer APPLIC1.
2. Ajouter une instruction Effécran à partir du menu [prgm] E/S.
3. Ajouter Disp en appuyant sur [PRGM] puis utiliser les touches de direction pour atteindre le menu E/S et sélectionner 3:Disp.
4. Entre guillemets ajouter un titre pour l’écran du programme.
5. Ajouter la commande Pause en appuyant sur [PRGM] et en choisissant 8:Pause
6. Entre guillemets, ajouter le texte, appuyer sur [entrer] comme montré sur l’écran de droite.

Mise au point des couleurs

Tout d'abord nous avons mis la couleur au rouge en définissant les valeurs RVB  à 255, 0, 0.

Dans cet exemple, sur l’écran de droite, nous utilisons la commande Wait afin de demander à la calculatrice d’attendre 5 secondes avant d’envoyer une nouvelle instruction au Hub TI-Innovator. La couleur rouge devrait persister Durant ce temps.

Votre travail consiste à ajouter les instructions nécessaires afin de réaliser le vert, puis le jaune, puis le  rouge à nouveau.

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

Objectifs :

• Apprendre à utiliser la boucle For
• Utiliser la commande Disp pour afficher du texte et des variables
• Faire clignoter une diode

Écrivons un programme pour faire en sorte que la LUMIERE clignote un certain nombre de fois. Avec d'autres instructions d'entrée, vous pouvez également contrôler la temporisation de l’état de la lampe (allumé ou éteint).

Ce programme introduit le concept de boucle For…End.

Écrivons un programme pour faire en sorte que la LUMIERE clignote un certain nombre de fois. Avec d'autres instructions d'entrée, vous pouvez également contrôler la temporisation de l’état de la lampe (allumé ou éteint).

Ce programme introduit le concept de boucle For…End.

Mise au point du programme :

1. Commencer un nouveau programme et le nommer LUM2.
2. Ajouter la commande Effécran en appuyant sur [prgm], puis en utilisant les touches de direction pour atteindre le menu E/S, et en sélectionnant 8: ClrHome.
3. Ajouter l’instruction Disp en appuyant sur [prgm], puis en utilisant les touches de direction pour atteindre le menu E/S, et en sélectionnant 3: Disp.
4. Entre guillemets ajouter le mot « CLIGNOTANT »
5. Ajouter l’instruction Input en appuyant sur [prgm], utiliser les touches de direction pour atteindre le menu E/S, et en sélectionnant 1: Input.
6. Entre guillemets ajouter « NOMBRE DE FOIS ? » comme montré ci-contre.
7. Puis ajouter une virgule et la variable N.

Ajouter la boucle For :

• Ajouter la commande For( en appuyant sur la touche [prgm] et en sélectionnant 4:For(.
• Compléter l’instruction avec les autres arguments, I,1,N). Cette commande signifie “Pour I variant de 1 à N par pas de 1”.

• Presser [entrer] quelques instants pour insérer des lignes vierges nous les complèterons plus tard, et ajouter la commande End au programme.

Ne vous préoccupez pas du nombre de lignes ajoutées. Vous pouvez toujours ajouter des lignes si vous en avez besoin, et des lignes vides n'ont pas d'effet lorsque vous exécutez le programme.

Le bloc de commande entre For et End est appelé le “corps de la boucle”. C’est cette portion de code qui sera exécutée N fois grâce au travail de la boucle For.

Pour insérer une ligne vierge dans un programme, placer le curseur à la fin de la ligne dessous l’endroit où vous souhaitez insérer une ligne, puis appuyer sur [insérer] ([2nd] [suppr]) et enfin [entrer].

Note: Pour insérer une ligne blanche dans un programme, ouvrir le menu accessible par la touche F5 menu ([alpha] [graphe]), et insérer Insérer Ligne ↑.

Nous voulons que la lumière clignote ON et OFF N fois. Nous voulons aussi que le programme affiche le nombre de clignotements.

Nous commencerons le corps de la boucle avec Disp I, variable qui contrôle la boucle.

Nous ajoutons maintenant les instructions pour allumer et éteindre la lampe (ON et OFF) comme montré sur l’écran de droite.

1. Ajouter la commande Send(SET LIGHT depuis le menu [prgm] HUB.
2. Ajouter le mot ON depuis le menu [prgm] HUB SETTINGS.
3. Ne pas oublier les guillemets et parenthèses pour terminer l’instruction.
4. Ajouter Wait (en secondes) depuis le menu [prgm] HUB menu afin que la calculatrice attende avant l’envoi de la commande suivante.
   Dans notre programme nous fixons un délai de 1 seconde mais vous pouvez utiliser toutes les valeurs que vous souhaitez y compris des décimales.
5. Copier la commande Send( en utilisant la combinaison de touches [alpha] [graphe] [ 5]
6. Et [alpha] [graphe] [ 5 ] (Copier-coller ligne) Editer l’instruction pour ON en OFF.
7. Copier l’instruction Wait en utilisant la même méthode.
   Faire fonctionner le programme en appuyant sur [alpha] [graphe] (F5) et [entrer].
8. Vous devriez voir la diode clignoter et le compteur s’incrémenter à l’écran

Voici un défi : ajouter des instructions Input en haut du programme (avant la boucle For( pour fixer les deux valeurs d’attente Wait à utiliser.

Utiliser des variables à la place des nombres dans l’instruction Wait.

Quittez l'éditeur de programmes et exécuter à nouveau le programme. Observer 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é des trois couleurs de la diode RVB qui équipe le Hub TI-Innovator™.

Objectifs :

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

Le Rouge, Vert et Bleu prennent leurs valeurs dans l’intervalle (0 à 255) envoyées à la diode RVB, ces trois valeurs déterminent la luminosité de chaque canal. Ce programme montre comment faire varier progressivement la quantité de chaque couleur par transitions successives à travers les 16 million (256³) de couleurs possibles. Vous utiliserez de nouveau la boucle For( dans votre programme.

Créer un programme de changement de couleurs

1. Commencer un nouveau programme et le nommer COULEUR2.
2. Ajouter les instructions Effécran et Disp ainsi que le titre, comme montré sur l’écran de droite.
3. Ajouter l’instruction Input entre guillemets ainsi que le mot WAIT ?
4. Puis ajouter une virgule et la variable W. Cette variable sera utiliser pour temporiser la commande Wait .  Ainsi plus le nombre est élevé, plus le temps d'attente et plus vite sera exécutée la commande suivante.
5. Comme montré sur l’écran de droite, ajouter une entrée Input afin de fixer le PAS de la boucle For ceci afin d’accélérer un peu les choses.   

Notre programme fera progressivement (en fonction des valeurs d'attente et du pas) augmenter l'intensité ROUGE, puis ajoutera du VERT, puis reprendra graduellement la couleur ROUGE, puis ajoutera du BLEU, enlèvera du VERT, puis ajoutera du ROUGE au BLEU, puis enlèvera le BLEU, pour finalement enlever la composante ROUGE. Ce programme  est assez long, et vous pouvez l'exécuter après avoir terminé chaque boucle.

6. Une  bonne habitude à prendre lorsqu’on on travaille sur des programmes plus compliqués est d’insérer chaque boucle complète  de sorte que vous n’oublierez aucune instruction de fin de boucle plus tard. Il suffit de laisser quelques lignes vierges dans le corps de la boucle en appuyant sur la  touche « entrer » quelques fois.

Compléter la première boucle :

1. Ajouter le reste des commandes de la boucle For( pour aller de  0 à 255. Nous utilisons les variables de la boucle I et ajoutons S pour le pas.
2. Ajouter la commande Send(“SET COLOR à partir du menu [prgm] HUB.
3. Utiliser la fonction eval( à partir du menu [prgm] HUB pour la variable I et fixer  les canaux VERT et BLEU à 0.
4. Utiliser les guillemets et parenthèses pour fermer les instructions.
5. Continuer avec la commande Send( et Wait en utilisant la variable W déjà appelée plus tôt par l’instruction Input.

6. Après la fin de votre première boucle For vous pouvez utiliser la commande Pause avec un message pour que vous puissiez admirer le rouge vif de la DEL.

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

Send(SET COLOR 255 eval(I) 0”)

(Puisque nous savons que le ROUGE est allumé est que le BLEU est éteint)

Ou

Send(“SET COLOR.GREEN eval(I)”)

Cette seconde 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.

Sur l’image de droite, notez que nous faisons le choix d’utiliser Send(“SET COLOR.GREEN eval(I)”).

Ajouter la commande Wait dans le corps de la boucle en utilisant la variable W.

Ajouter la commande Pause après le End de la boucle pour admirer la nouvelle couleur. Quelle est cette couleur?

Maintenant, nous voulons diminuer progressivement la quantité de rouge, afin de retrouver seulement le VERT.
Pour diminuer dans une boucle For( nous commençons par le plus grand nombre, pour aller  vers le plus petit nombre, et utilisons un pas négatif.

For(I, 255, 0, -S)

Commence à 255 et soustrait S à chaque pas de la variable I jusqu’à ce que celle-ci soit inférieure à  0 lorsque la boucle se termine. Assurez-vous d’utiliser le signe [(-)] ‘négatif’ des nombres et non pas l’opérateur de soustraction. Cela renverrait un message d’erreur.

Nous voulons seulement changer le canal  ROUGE, aussi nous utiliserons l’instruction COLOR.RED dans la commande Send. Le reste de la boucle est similaire à la première déjà construite. L’image de droite montre seulement la suite des commandes entrées.

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

Voici la section terminée qui supprime le progressivement ROUGE. A la fin de cette boucle, vous devriez voir une couleur VERT vif.

1. Maintenant faire une boucle pour ajouter du  BLEU.
2. Puis ajouter une boucle pour enlever le VERT.
3. Puis ajouter une boucle pour ajouter de nouveau du ROUGE.
4. Quelle couleur voyez-vous à la fin de ces boucles ?
5. Ajouter ensuite une boucle pour enlever le BLEU.
6. Finalement faire une dernière boucle pour enlever le ROUGE.
   • Quelle est la couleur de la DEL à la fin du programme ?
   • Que se passe-t-il si les trois canaux sont à 0 0?

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

Objectifs:

• Expliquer l’origine de la racine douzième de 2 dans la gamme Pythagoricienne.
• Ecrire un programme qui joue les notes successives de la 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 Rép au début, car le symbole de multiplication nécessite un argument en face de celui-ci. Appuyer simplement sur la touche [entrer] 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 les instructions Effécran et Disp et entrer le message entre guillemets.
3. Commencer l’échelle des fréquences à, 261.64 en stockant cette valeur dans la variable F en utilisant la touche  [STO→].
4. Cette variable représentera chacune des notes de la gamme.

Mise au point de la boucle For :

1. Ajouter une boucle For( allant de 1 à 12 (pour les 12 notes).
2. Ajouter la commande Send( “SET SOUND à partir du menu HUB.
3. Ajouter eval( pour la variable F comme montré sur l’écran de droite. Attention à ne pas oublier les guillemets et les parenthèses

Evaluer la fréquence:

1. Multiplier F par 2^1/12, et stocker de nouveau le résultat dans  F F*2^(1/12)→F
   • Cette instruction prend la valeur actuelle de F et change la fréquence de la note suivante sur l'échelle.
2. Quitter l’éditeur de programme pour le faire fonctionner.

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.

Nous allons utiliser le générateur de nombres pseudo aléatoires TI-83 Premium 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  Disp.

Dans cette application nous utiliserons la fonction  nbreAléaEnt( ) de la TI-83 Premium CE.

1. A partir de l’écran d’accueil localiser nbreAléaEnt dans le menu math>PROB.
   • Cette instruction prend deux (ou trois) arguments. Dans un premier temps, vous obtiendrez un «assistant».
2. Entrer les valeurs inférieures et supérieures et laisser le champ de n: vide.
   • Il est utilisé pour créer une liste de n nombres.
3. Choisir Coller pour mettre l’instruction dans l’écran d’accueil et appuyer sur la touche « entrer ».
4. A partir d’ici, utiliser la touche de déplacement vers le haut pour rappeler la commande précédente, appuyer sur la touche « entrer » fin de la réutiliser et modifier les deux arguments.

Nous combinerons  la fonction nbreAléaEnt( ) avec nos notes de musique pour créer un programme qui génère aléatoirement des notes fondées sur la progression géométrique de raison 2^1/12 la 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 commande Wait pour synchroniser le déroulement du programme avec la musique

Dans cette première leçon de l’unité 3, nous étudions le capteur de luminosité intégré, et introduisons la commande Output( en TI-Basic afin d’illustrer une technique efficace permettant d’afficher des nombres de caractéristiques (nombre de décimales) différents Output(.

Objectifs:

• Lire la valeur de la luminosité recue par un capteur
• Introduire la boucle While
• Utiliser la commande Output(
• Introduire versChaîne( et la concaténation

Dans les leçons précédentes, nous avons seulement envoyé des instructions au Hub TI-Innovator™ afin d’obtenir une action sur les composants qui équipent ce système  (LUMIERE, COULEUR, et SON).

Dans cette unité, nous allons travailler avec le capteur de lumière intégré afin de créer un appareil capable de mesurer la quantité de lumière reçue. Le capteur de lumière produit des valeurs dans l’intervalle (0 à 100) sous forme décimale.

Pour obtenir une mesure de la grandeur proportionnelle à la quantité de lumière reçue par le Hub TI-Innovator la commande exige deux arguments.

• Send(“READ BRIGHTNESS”)
• Get(B)

Mise au point du programme :

1. Commencer un nouveau programme et le nommer LUMIN1.
2. Ajouter la commande Effécran et Disp pour afficher le titre comme montré sur l’écran de droite.
3. Appuyer sur la touche [prgm] et utiliser les flèches de direction pour atteindre le menu HUB.
4. Sélectionner 2: Send(“READ… puis choisir  1: BRIGHTNESS.
5. Appuyer sur la touche [prgm] et utiliser les flèches de direction pour atteindre le menu HUB.
6. Sélectionner 5:Get(

Comment cela fonctionne t-il ?

• READ BRIGHTNESS demande au Hub TI-Innovator de lire le niveau de luminosité et stocke la valeur dans sa mémoire tampon “buffer”
• Get(B) est une commande pour obtenir la valeur depuis le Hub TI-Innovator. Cette instruction transfère la mesure de la mémoire tampon vers une variable  B dans la TI-83 Premium CE. B peut être remplacée par n’importe quelle variable numérique, A..Z and Ɵ (theta).

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.

Une autre méthode pour arrêter brutalement un programme consiste à appuyer sur la touche ON. Vous verrez un message d’erreur: ERROR: ARRÊT en haut de l’écran avec deux options 1:Quitter pour retourner à l’écran d’accueil et  2:Voir l’éditeur de programme s’ouvre alors en la ligne où a été appelée l’interruption ON stoppe le programme. C’est aussi une bonne méthode pour continuer l’édition d’un programme.

Ajouter une boucle While :

1. Avant la commande Send( de votre programme, ajouter l’instruction :
   2→B
   While B>1 [utiliser le menu [test] pour le symbole >]
   • Cette commande initialise 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.  
2. Le End de la boucle While doit aussi être entré. sous la commande Get( Ajouter enfin la commande End afin de marquer la fin de la boucle While.

3. Ajouter la commande Output( après l’instruction Get( et avant le End de la boucle comme montré sur l’écran de droite, en tapant [prgm],puis en utilisant les touches de direction vers le menu E/S et en choisissant enfin 6: Output(.
   • La commande Output( vous donne la possibilité de contrôler à l’écran l’emplacement où une information doit être affichée. La structure de la commande est : Output(<ligne#>, <colonne#>, <chaîne ou variable>)

Exemples :

• Output(3,7,“HELLO”) placer la lettre “H” à la ligne 3, colonne 7 de l’écran d’accueil et le reste du mot suivra la lettre “H”.
• Output(5,10,B) placera la valeur de la variable B au début de la ligne 5, colonne 10 de l’écran d’accueil et les autres digits à la suite.

4. Quitter l’éditeur de programme et le faire fonctionner après avoir connecté le Hub TI-Innovator.
   • Vous devriez voir le message de titre en haut de l'écran et une valeur dans le centre de l'écran qui change en fonction de l'intensité lumineuse lue par le capteur. Malheureusement, les chiffres que vous voyez peuvent ne pas être corrects !

La commande Output( n’efface pas les digits en excès si un nombre plus court est affiché après un précédent comportant plus de décimales. Par exemple, si une valeur affichée est 1.23456 et la valeur suivante à afficher est 55, alors vous verrez 5523456. La dernière modification propose une façon élégante afin de corriger ce problème.

Pour corriger le problème de «suivi des chiffres »  nous convertissons la variable B dans une chaîne et ajoutons des espaces à la fin de celle-ci pour effacer complètement la valeur précédente affichée.

toString( se trouve dans le menu prgm E/S.

La commande correcte sera finalement: Output(5,10,toString(B)+“             ”)
Il y a 10 espaces entre les guillemets.

Maintenant, lorsque vous exécutez le programme, vous verrez que certaines valeurs sont plus courtes que les autres parce que les espaces que nous avons ajoutés à la représentation de la chaîne B effacent les chiffres précédents.

Concaténation:

Le signe “+” utilisé dans l’instruction Output( ne correspond pas à une addition : il est utilisé pour  ‘concaténer’ (associer) deux chaînes de caractères. Les espaces (entre guillemets) sont ajoutées à la fin de la chaîne incluant la variable B.

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 infinie
• 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é.

Mise au point du programme :

1. Commencer un nouveau programme et le nommer LUMIN2.
2. Ajouter les commandes Effécran et Disp ainsi que les informations du titre comme montré sur l’écran de droite.
3. Initialiser la variable B en ajoutant la commande 2→B.
4. Ajouter une boucle While avec la condition B>1.  (La valeur de la luminosité est vraiment très faible).
5. Ajouter End pour fermer la boucle While.

Pour terminer le programme, couvrir le capteur.    

6. Dans le corps de la boucle While ajouter Send(“READ BRIGHTNESS”) et Get(B) à partir du menu prgm HUB comme montré ci-contre.

Vous pouvez ajouter les lignes vierges en appuyant sur [ins] [enter] ou en utilisant la touche [alpha] [graphe] (F5) puis choisir l’option Insérer Ligne ↓.

Ecrivons maintenant la condition…

La valeur de la luminosité est stockée dans la variable B et 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. Vous pourriez améliorer le programme en utilisant l’instruction Input  pour la valeur de déclenchement « trigger ». Assurez-vous de placer la commande Input avant le début de la boucle While.

Le symbole « < » (inférieur à) se trouve dans le menu [tests] (2^nd math)

Finalement, allumer puis éteindre la lampe LIGHT ON ou OFF dans le bloc Then et Else comme montré sur l’écran de droite.

Quitter l’éditeur et faire fonctionner le programme avec le Hub TI-Innovator connecté. Contrôler la lumière qui arrive sur la cellule du capteur, ainsi que la diode rouge qui s’allume ou s’éteint.

Il peut être intéressant de rajouter une instruction Output vue dans la leçon précédente, pour afficher la valeur de B sur l’écran de la calculatrice et préciser par ailleurs l’état de la diode allumée ou éteinte.

Output(9,1,“ON ”) and Output(9,1,“OFF”)

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 le nommer  LUMIN3.
2. Ajouter les commandes Effécran et Disp pour afficher le titre comme montré sur l’écran de droite.
3. Initialiser la variable B comme montré.
4. Ajouter une boucle While afin de lire la valeur de la luminosité, puis d’obtenir sa valeur à l’aide de l’instruction Get(B). Nous réaliserons la conversion un peu plus tard.

5. Utiliser la variable C pour représenter la valeur de la couleur que nous allons transmettre aux trois canaux de la diode RVB. Le facteur de conversion est  2.55*B→C. Considérer cette formule avec deux valeurs. Lorsque B=0 alors C=2.55*0=0, et lorsque B=100 alors C=2.55*100=255.
6. Ajouter la commande Send(“SET COLOR avant la fin de la boucle End. Cette instruction contrôle la luminosité ou la brillance de la diode.

7. Finalement compléter la commande  SET COLOR en utilisant l’instruction eval(C) trois fois (une fois pour chaque canal de couleur). Lorsque les trois canaux ont la même valeur, alors la diode est de “couleur” blanche et sa luminosité dépend de cette valeur.
8. Connecter le Hub TI-Innovator™, et faire fonctionner le programme. Changer la luminosité en pointant le capteur vers divers objets. Observer l’intensité lumineuse de la diode DEL.

Vous pourriez ajouter une instruction Output( afin de pouvoir lire 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 l'évolution de la luminosité détectée par un capteur de lumière et de votre propre mouvement de main d'où, une 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 rend la TI-Innovator ™ Hub se comporte comme un « theremin ».

Commençons

1. Débuter un nouveau programme et le nommer APPLIC3.
2. Ajouter les commandes Effécran  et Disp afin d’afficher le titre comme montré sur l’écran de droite.
3. Initialiser la variable variable b en ajoutant l’instruction 2→B.
4. Ajouter une boucle While ainsi qu’une instruction Read pour lire la valeur de la luminosité (BRIGTHNESS) issue du capteur et obtenir sa valeur Get dans la variable B.
5. Ajouter la commande pour jouer le son.
   • 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 ent( ) ou la fonction arrondir(  ,0) .

ent(X)→X		donne le plus grand nombre entier inférieur à X.
arrondir(X,0)→X		arrondi X à l'entier le plus proche.

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

• Pour écrire un nouveau programme ou éditer un programme existant, Les instructions du TI-Innovator Rover se trouvent lorsqu’on sélectionne [prgm], dans le menu Hub, puis 7 : Rover (RV)….
• Pour accéder rapidement aux instructions du Rover, sélectionner [prgm], puis la flèche gauche afin d’atteindre le menu Hub, puis choisir le numéro 7.
• Certaines parties de l'instruction finale, telles que les valeurs numériques et les paramètres facultatifs, sont entrés directement au clavier ou sélectionnés à partir d'un autre menu du Rover.
• Certaines instructions du Rover incluent les guillemets de fermeture, les parenthèses et parfois, indiquent que l’instruction (peut-être) plus longue à entrer. Dans les deux cas, toutes les commandes doivent être fermées avec les guillemets et enfin par une parenthèse.

La 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 [prgm] et choisir le menu HUB.
2. Puis choisir le sous menu Rover (RV)….
3. Finalement, sélectionner Send(“CONNECT RV”). L’instruction est située en haut du sous menu.

Maintenant nous allons ajouter une instruction Pause. Cette instruction stoppe le fonctionnement de la calculatrice et celle-ci attend que l’utilisateur appuie sur la touche « entrer »

4. Appuyer sur [entrer] pour insérer une nouvelle ligne de programme.
5. Appuyer sur la touche [prgm] puis dans le menu CTL, sélectionner Pause.
6. Ajouter un message approprié après l’instruction Pause, par exemple “PRESSER ENTRER POUR COMMENCER” en utilisant les touches Alpha.

Lorsque l’on fait fonctionner le programme, si on entend un bip émis par le TI-Innovator Hub avant (ou pendant) l’affichage du message “PRESSER ENTRER POUR COMMENCER” cela signifie que l’instruction CONNECT RV n’a pas abouti. S’assurer d’avoir mis le Rover sous tension.

Piloter le Rover

7. Appuyer sur [entrer] à la fin de l’instruction Pause afin d’ajouter l’instruction suivante qui fera avancer le robot.
8. Appuyer sur prgm > Hub > Rover (RV)…, et ensuite sélectionner le menu Drive RV… comme montré sur l’écran de droite.
9. Sélectionner FORWARD à partir du menu Drive RV…

Noter que la commande qui est collée dans le programme ne comporte pas le guillemet de fermeture et de parenthèse fermante. Nous devons encore ajouter quelques informations.

10. Ajouter le nombre 1, puis ajouter le guillemet de fermeture et une parenthèse fermante à la commande.
11. Les guillemets s’obtiennent en appuyant sur [alpha] [+] et la parenthèse fermante est située sous la touche 9.
12. Quitter l’éditeur ([2nd] [mode]), et faire fonctionner le programme. S’assurer d’avoir suffisamment d’espace devant le Rover.

Si tout va bien, alors le Rover devrait aller de l'avant. Mais jusqu'où ?

Étudier attentivement le mouvement et déterminez ce que signifie l’instruction FORWARD 1.

La calculatrice affiche « Fait » lorsque le programme est terminé. Noter que le programme se termine réellement avant que le robot ait fini de se déplacer. La calculatrice et le TI-Innovator Hub fonctionnent à des rythmes différents.

Conduire en arrière.

13. Editer le programme et ajouter l’instruction Send(“RV BACKWARD 1”) en appuyant sur prgm > Hub > Rover (RV)… > Drive RV… > BACKWARD.
14. Ensuite ajouter le nombre 1 et le guillemet de fermeture et la parenthèse fermante comme dans l’instruction FORWARD.

Quitter et faire fonctionner de nouveau le programme. Cette fois, le Rover devrait avancer un peu puis retourner à sa position initiale. Si c’est le cas, félicitations ! Vous avez piloté le Rover.

Tourner

Les deux commandes suivantes dans le menu Drive RV… sont LEFT et RIGHT. Ajouter ces deux instructions à votre programme, et faire fonctionner de nouveau le programme. Quelle est la fonction réalisée par ces instructions ?

Faire voyager le robot

Étudier le programme à droite et prédire ce que le Rover fera et où il s’arrêtera lorsque le programme se terminera. Entrer les commandes dans votre calculatrice, et exécuter le programme.

Le programme a-t-il fait ce qui est attendu ? Faire un programme avec seulement ces commandes afin que le Rover suive un parcours rectangulaire ?

Utilisation du nouveau menu de l'éditeur de programme.

On accède au menu supplémentaire de l’éditeur de programme en appuyant sur alpha-F5. Utiliser ce menu pour copier une ligne (5 : Copier Ligne) et coller la ligne (6 : Coller ligne ↓) sous la position courante du curseur. On peut également annuler et insérer des lignes et exécuter le programme à partir de ce menu.

Dans cette leçon, vous allez étudier certaines des fonctionnalités facultatives de conduite. Les quatre commandes de conduite vue lors de la compétence 1 n'incluaient pas le guillemet fermant et la parenthèse fermante. C'est en effet parce qu'il y a d'autres options à fournir à ces instructions. Cette leçon explore ces options.

Objectifs :

• Extension des caractéristiques de conduit du Rover
• Options pour les instructions RIGHT et LEFT
• Wait

Paramètres pour FORWARD et BACKWARD

Ces commandes de conduite ont trois paramètres optionnels :

• SPEED
• TIME
• DISTANCE

Elles se trouvent dans le menu prgm > Hub > Rover (RV)… > RV Settings…. L’unité de mesure de la vitesse, SPEED unités (UNITS/S and M/S) sont aussi accessibles par ce menu.

Utiliser DISTANCE, SPEED et TIME

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

• FORWARD DISTANCE # est identique à FORWARD #.
• FORWARD DISTANCE # M fait mouvoir le Rover de # Metres.
• FORWARD # SPEED # où la vitesse est comprise entre 1.4 et 2.3.
  • Les valeurs en dehors de cet intervalle produisent une erreur dans le TI-Innovator™ Hub.
• FORWARD TIME #.

On peut spécifier deux de ces trois options après FORWARD et BACKWARD.

On peut aussi utiliser eval( ) si la valeur que l’on utilise 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 de droite comporte déjà cette commande ajoutée :
   Send(“RV FORWARD SPEED 2.3 TIME 2”)
2. Compléter le programme en proposant une instruction correcte après l’instruction TIME afin que le Rover retourne à sa position de départ :
   Send(“RV BACKWARD SPEED 1.4 TIME ?”)

Rappel : DISTANCE = VITESSE * TEMPS soit DISTANCE = SPEED * TIME

Options RIGHT et LEFT

Par défaut, ces instructions font tourner le Rover RIGHT ou LEFT de 90 degrés mais il est possible d’ajouter une valeur pour l’angle de rotation (-360…360 degrés). Les valeurs négatives sont aussi autorisées, ainsi LEFT -90 aura le même effet que RIGHT 90.

3. Ajouter une instruction pour faire tourner le Rover RIGHT 135 degrés. On doit entrer 135 puis le guillemet et la parenthèse fermante. Le mot DEGREES n’est pas utile, mais on peut le trouver dans le menu RV Settings… pour plus de clarté de l’information.

On peut également préciser l’unité de mesure angulaire RADIANS ou GRADS mais ces unités doivent être déclarées et se trouvent également dans le menu. RV Settings…

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

Écrire un programme pour faire rouler le Rover le long d'un triangle équilatéral.

Commencer avec :
    Send(“CONNECT RV”)
    Send(“RV FORWARD ?”)
    Send(“RV LEFT ?”)

Ou utiliser une boucle.

Dans cette troisième leçon de l’Unité 4, vous apprendrez à piloter le Rover afin qu’il tourne selon un angle donné et utiliserez la diode de couleur COLOR DEL.

Objectifs :

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

Cette leçon introduit trois nouvelles instructions pour le Rover :

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

TO ANGLE

L’instruction Send(“RV TO ANGLE <nombre>”) est utilisée pour faire tourner le Rover selon un angle donné. Lorsque l’on transmet une commande pour connecter le mobile, 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 de droite.

Peu importe où se dirige le Rover au départ, l’instruction Send(“RV TO ANGLE 0”) force le Rover à se diriger dans la direction qu’il avait lors de sa connexion avec la commande “CONNECT RV”

Par défaut, l’unité de mesure d’angle est DEGREES mais vous pouvez aussi choisir RADIANS ou GRADS (à partir du menu 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 le travail assigné ?

Synchroniser votre programme avec le Rover

Les programmes sur la calculatrice sont « Terminés » avant que le robot ne finisse son mouvement. En effet, les commandes de conduite sont stockées dans le TI-Innovator ™ Hub plus rapidement que le Rover ne peut les traiter. Les commandes de conduite sont en fait stockées dans une « file d’attente » et sont traitées par le TI-Innovator Hub lorsque le mobile est prêt à 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 celui-ci se déplace. Nous utiliserons également l’instruction TO ANGLE et intégrerons eval () pour passer la commande appropriée.

Mise au point du Programme

1. Commencer un nouveau programme.
2. Ajouter une boucle For afin que le Rover se déplace selon un parcours aléatoire. Se souvenir qu’il est judicieux de placer le End de la boucle For dans le code. Ainsi on ne l’oubliera pas ultérieurement. Il est toujours possible d’ajouter des lignes au corps de la boucle si on en a besoin.

Note : Les instructions For( et End sont dans le menu CTL.

3. Dans le corps de la boucle, ajouter l’instruction de mouvement FORWARD.
4. Ensuite écrire l’instruction permettant au Rover de suivre une direction aléatoire randInt(0,360) → H.
5. Ajouter l’instruction TO ANGLE pour tourner selon la direction H.
6. Exécuter le programme afin de constater :
   • Le Rover se déplace de façon aléatoire.
   • Le programme est achevé immédiatement alors que le Rover continue son mouvement.

RV.COLOR

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

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

Ajouter RV.COLOR à votre Programme

7. Ajouter une instruction RV.COLOR à la boucle For, immédiatement avant l’instruction FORWARD 1. Vous êtes libres du choix de la couleur.
8. Réexécuter le programme pour voir ce qui se passe. Noter 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 nous obligera à attendre que chaque segment soit terminé, puis éteindre la DEL pendant que le Rover tourne.

Nous devons ajouter l’instruction Wait à notre programme afin d’allumer et éteindre la DEL.

9. Combien de temps met le Rover pour effectuer le mouvement FORWARD 1 ? Après 1 seconde ? Ajouter une instruction Wait 1 après FORWARD 1 (se souvenir que l’instruction Wait se trouve dans le menu prgm > Hub)
10. Faire fonctionner le programme pour tester.

Noter que la DEL reste allumée. Nous devons éteindre la DEL 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 Send(“SET RV.COLOR 0 0 0”).
13. Tester le programme. Le Rover a-t-il éteint la lumière au bon instant ?

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 TO ANGLE cette commande Wait devrait être suffisante pour gérer une rotation de 0 degrés à 360 degrés.

Extension

Peut-on modifier la couleur à chaque angle ? Utiliser eval(……).

Un autre défi: En fonction du temps d'attente de rotation, rechercher une fonction de l'angle à pivoter en observant le sens de rotation du Rover lors de l'utilisation de l’instruction TO ANGLE.

Dans l’application de cette unité, vous allez programmer le Rover pour dessiner un polygone. L’utilisateur entre la longueur d’un côté (en “unités Rover”) et le nombre de côtés du polygone. Le Rover dessinera 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 : le rôle de l’instruction eval( ) est de convertir la valeur d’une variable de la calculatrice ou d’une expression en une chaîne 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ères 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). Vous pouvez ajouter un feutre au Rover et dessiner le polygone sur une grande feuille de papier. Rappelez-vous que 1 unité du Rover fait 10 cm. Option : Faites allumer la DEL COLOR aux sommets du polygone.

Quelques commandes utiles.
    Input “LONGUEUR D’UN COTE ?”,L
    Input “NOMBRE DE COTES?”,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 allez apprendre à utiliser le capteur de distance à ultrasons du TI-Innovator Rover Ultrasonic et sa capacité à contrôler un déplacement.

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 de distance à ultrasons appelé Ranger. Le Ranger mesure la distance qui le sépare d’un objet situé devant le Rover. Cette information peut être utilisée pour contrôler le mouvement du robot. 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 du Ranger et affichera cette valeur sur l'écran de la calculatrice. Le Rover ne bougera pas dans ce programme. Nous devons déplacer notre main devant le Rover ou tenir le Rover dans nos mains, et pointer le robot vers divers obstacles pour observer les mesures de distance.

Commencer le programme de Test

1. Notre nouveau programme s'appelle ROVER51. Il commence par la commande Effécran. Ensuite, ajouter la commande Send ("CONNECT RV") depuis le menu prgm> Hub> Rover (RV) ....

La boucle principale

Nous utiliserons une boucle While afin de contrôler le programme. Lorsque la distance mesurée est inférieure à une certaine valeur, le programme se termine. Nous utilisons la variable D pour enregistrer la distance mesurée.

2. Initialiser D à 1.
3. Sélectionner While à partir du menu prgm > CTL. Le code de la boucle While signifie que le programme continue tant que D est plus grand que 0.1.

Le corps de la boucle

4. L’instruction READ RV.RANGER se trouve dans le menu
       prgm > Hub > Rover (RV)… > Read RV Sensors….

5. Sélectionner Send(“READ RV.RANGER”).
6. Ajouter les instructions
       Get(D)
       Wait 0.25
   Au corps de la boucle.

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

Afficher la valeur.

7. Nous utilisons une instruction Output( ) pour afficher la valeur de D et fixer sa position sur l’écran de la calculatrice.
8. Ajouter l’instruction de fin de boucle End.

Faire fonctionner le programme.

9. Pendant l'exécution du programme, l'écran de la calculatrice affiche un nombre. Déplacer la main devant 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 : L’unité de mesure de la distance est le mètre, 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 afin de voir comment le capteur lit et affiche une valeur. Cette leçon poursuit les essais pour contrôler le mouvement du robot.

Objectifs :

• Utiliser l’instruction READ RV.RANGER pour mesurer la distance à un obstacle
• Contrôler le mouvement du Rover quand le Rover se rapproche trop d'un obstacle
• Gérer le temps lors de la programmation du Robot dans le programme de la calculatrice

Écrivons un programme pour que le Rover puisse aller et venir entre deux « murs ». Nous allons mettre le Rover en mouvement, lire le capteur à ultrasons Ranger et lorsque le Rover se rapproche trop du mur, faire arrêter le Rover, puis faire demi-tour et avancer.

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( celle-ci devra réaliser 10 itérations.
3. Ajoutez une commande FORWARD 100 pour avancer de 10 mètres (100 * 0.1m par unité).
4. Ne pas oublier End de la boucle For(.

Comme dans la leçon précédente, nous utilisons la variable D pour représenter la distance entre le capteur Ranger et un obstacle.

5. Initialiser D à 1, et commencer la boucle tant que While D > 0.25.

Noter les deux « End » dans le code ; un End est pour la boucle For et un autre End est pour la boucle While.

6. Nous insérons ensuite le code dans le corps de la boucle While. Si l’on n’a pas assez de lignes vides dans votre programme, placer le curseur au début d'une ligne où le code doit être inséré. Appuyer sur [Insérer] ([2nd] [suppr]), et ensuite appuyer sur [entrer] . Une autre méthode pour ajouter une ligne sous la ligne en cours, consiste à appuyer sur [alpha] F5, puis à sélectionner Insert Ligne ↑.

7. Ajouter l’instruction Send(“READ RV.RANGER”).
8. Utiliser l’instruction Get( pour sauvegarder le contenu de la variable D.

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

Lorsque la boucle While se termine, cela indique que le robot est trop proche d'un obstacle. Nous allons demander 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.

9. Après les instructions End de la boucle While mais avant le End de la boucle For ajouter l’instruction
   RV STOP puis la commande RV RIGHT 180.
10. Ajouter une instruction Wait 2 pour donner au Rover le temps de tourner à droite de 180° avant de repartir « FORWARD 100 » une nouvelle fois. (Se souvenir que l’instruction FORWARD est au début de la boucle For.)
11. Quitter l’éditeur de programme, et tester votre 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 minimale et temps d'attente), selon les besoins correspondants à la situation de déplacement du robot (espace). 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 sa valeur pour amener le mobile à changer de direction.

Objectifs :

• READ COLORINPUT
• Utiliser la valeur pour changer la direction du Rover

Le Rover est équipé d’un capteur COLORINPUT. La lumière du sol est utilisée par le capteur pour « voir » la couleur. Nous écrirons un programme pour activer le Rover quand il « perçoit » un changement de couleur. La couleur vue par le capteur est convertie par le TI-Innovator ™ Hub en une des neuf valeurs possibles :

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

1. Commencer un nouveau programme.

1. Nous utilisons une boucle For afin que le mobile se déplace et tourne quatre fois.
2. End marque la fin de la boucle For.

4. Nous mettons en oeuvre une boucle While pour rechercher un changement de couleur, mais nous devons d'abord connaitre quelle couleur le Rover « voit » actuellement. Nous avons lu RV.COLORINPUT, et obtenir sa valeur dans la variable C de la calculatrice.

5. Nous initialisons ensuite une autre variable, D, pour lancer la boucle While. D contiendra la couleur que le Rover voit pendant qu'il se déplace. Initialement, nous avons mis D à la même valeur que C. Ensuite, nous commençons le déplacement du Rover vers l'avant.

6. Nous codons à présent la boucle While pour comparer la variable D avec C incluse dans la boucle While nous attendons un changement de valeur de la variable D.
   Le signe égal se trouve dans le menu [test] ([2nd] [math]).
7. Ne pas oublier l’instruction de fin de boucle End pour la boucle While (non montré).

8. Dans la boucle While, nous surveillons le capteur de couleur tant que le mobile est en mouvement. Nous stockons la valeur de couleur dans la variable D. La boucle se termine lorsque D (la couleur « lue ») est différente de C (la couleur « originale »).

9. À la fin de la boucle While, nous demandons au Rover d’arrêter (STOP) et d'aller à DROITE. Noter que ces deux instructions sont situées entre les deux extrémités du programme. La deuxième extrémité correspond à la fin de la boucle For, ainsi le programme fait tourner le robot quatre fois à droite lorsqu'il détecte un changement de couleur.
10. Ajouter une commande FORWARD 1 et une instruction Wait 1 afin que le robot s'éloigne de l'endroit coloré et avant que le programme ne se répète pour détecter à nouveau la nouvelle couleur « originale » (C).

11. 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 mobile afin que le capteur COLORINPUT le détecte. Quand le Rover passera au-dessus de la tâche, il devrait s'arrêter, puis tourner et repartir. Ramasser le point de couleur, et le placer à un nouvel emplacement devant le Rover. Effectuer cette opération quatre fois afin que le programme se termine.

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

Objectifs :

• Utiliser COLORINPUT pour détecter et suivre une courbe sur une feuille de papier
• Suivre un exemple de chemin sur papier (voir le fichier PDF pour tester.)

Écrire un programme pour que le Rover suive sur le papier une trajectoire courbe 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 voyager vers la droite en suivant le chemin incurvé sur le papier.

Lorsque le Rover « voit » la portion ROUGE, il se tourne un peu vers la gauche et avance un peu. Lorsque le Rover voit la portion BLANCHE, 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 la page utilisée 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 choisira READ COLORINPUT.GRAY (ou. GREEN ou. BLUE).

Voici un programme (ACOLTEST) que l’on peut mettre en œuvre afin de tester le capteur de couleur du Rover .Examiner quelles valeurs on doit utiliser dans le programme :

    ClrHome
    Disp "COLORINPUT TEST"
    Send("CONNECT RV")
    While 1
    Send("READ RV.COLORINPUT.RED")
    Get(R)
    Disp R
    Wait .25
    End

Noter que le Rover 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 Rover 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 mobile est au-dessus du papier. Le programme devrait fonctionner, peu importe où le Rover commence.

Ce programme utilise une boucle infinie. Pour 'casser' ou terminer un programme en cours, appuyer sur la touche ON. Vous verrez le message d’erreur : ERREUR : ARRÊT en haut de l'écran et avec l'option 1 : Quitter affiché à l'écran ou 2 : Voir. L'éditeur de programme s’arrêtera à l'endroit où l'action d'appuyer sur ON a arrêté le programme.

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 une commande Prompt pour entrer les valeurs de X et Y et faire en sorte que le Rover atteigne ce point de coordonnées (X, Y) puis retourne enfin vers l’origine du repère.

1. Commencer votre nouveau programme avec l’instruction EffÉcran (prgm > E/S > EffÉcran) qui est une instruction courante.
2. Insérer une instruction Prompt pour X et Y.
   Souvenez-vous que l’instruction Prompt affiche le nom de la variable suivi d’un point d’interrogation. Plus d’une variable peuvent être demandées à l’aide d’une seule instruction Prompt.
3. La commande Pause 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 pour mettre le Rover en mouvement :
   
       prgm > Hub > Rover (RV)… > Drive RV… > TO XY
   
   La commande apparaitra dans votre programme comme une instruction non complétée.

5. Les coordonnées X et Y doivent être ajoutées et sont 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(Y) sans oublier les guillemets et les parenthèses afin de clore l’instruction.
7. Tester 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 Input pour les coordonnées des deux points. Garder à l’esprit que les variables de la TI-83 Premium CE sont seulement des lettres.
   Noter que nous utiliserons les variables X, Y, Z, et W pour les coordonnées.

3. Ensuite nous demanderons au Rover de se déplacer au premier point, puis d’attendre 4 secondes Wait, 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 entrer. 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.

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 ? Quel 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 L₁ et les ordonnées dans la liste L₂. Si vous le souhaitez, vous pouvez créer un bloc lettre différent.
   
   Optionnel : Configurer une représentation des données (graph stats) afin de vérifier si les coordonnées sont correctes.

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 également que la boucle For( éxige trois arguments, la variable I qui contrôle la boucle, une valeur de début, 1, et une valeur de fin, dim(L₁). Enfin, une instruction End afin de fermer le corps de la boucle.
   
   Note : dim(L₁) est le nombre d’éléments de la liste L₁.

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.
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

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 A, B et W. La variable W 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.
   
   Utilisons une valeur de 10 blocs avant que ne cesse le mouvement et stockons cette valeur dans la variable E.

3. Le Rover arrive à la maison lorsque sa position que nous appelons (X,Y) est (7,3). Les variables X et Y sont initialisées à 0.

La boucle principale

4. La boucle principale du programme consiste à réaliser une boucle While en adressant deux conditions. Les conditions correspondent au retour du Rover « à la maison » (lorsque X=A et Y=B) ou en quittant de manière exhaustive (lorsque W = E). Le Rover stoppe son mouvement lorsque la variable W (le nombre de blocs marchés) est égal à la valeur sauvegardée dans dans la variable E.
   
   La boucle While continue tant que ces deux conditions sont fausses, Nous avons donc mis en place les conditions opposées.
   
   La boucle While sera :
   While W<E et non(X=A and Y=B)
   
   Souvenez-vous que les valeurs relatives au problème sont stockées dans E, A, et B.
   
   non( ) est utilisé afin de s’assurer que le programme continue tant que le Rover n’est pas rentré « à la maison ». En Logique, et non( est « l’opposé » de ou.
5. N’oubliez pas d’inclure une instruction End à la fin de la boucle.

A l’intérieur de la boucle

6. Incrémenter W (le nombre de blocs marchés) : W+1→W.
7. Choisir une direction aléatoire (nord, sud, est, ou ouest) :
   • La commande TO ANGLE du Rover command tourne celui-ci dans une direction absolue. La direction : 0 est l’est, 90 est le nord, 180 est l’ouest, et 270 est le sud
   • nbrAléatEnt(0,3) donne un entier aléatoire qui peut être 0, 1, 2, and 3
   • Multiplier ces valeurs par 90 pour avoir 0, 90, 180, ou 270
   • L’instruction pour avoir une direction aléatoire D est donc :
     90nbrAléatEnt(0,3)→D
8. Faire tourner le Rover d’un angle D: Send(“RV TO ANGLE eval(D)”).
9. Faire avancer le Rover de 1 unité (1 bloc dans notre simulation) : Send(“RV FORWARD 1”).
10. Adapter 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 :

• Si W=E, 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 A QUITTE » sur l’écran de la calculatrice.
• Si X=A et Y=B, 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.

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