TI Codes Python

Dans cette leçon, vous allez écrire votre premier programme Python pour contrôler l’affichage de la carte micro:bit de différentes manières. Cette leçon est composée de deux parties :

• Partie 1 : rencontre extraterrestre.
• Partie 2 : affichage d’images.

Objectifs :

• Contrôler l’affichage sur la carte micro:bit à l’aide de .show( ), .scroll( ) et .show(image).
• Contrôler la vitesse de l’écran à l’aide de sleep(ms).

• votre TI-Nspire CX II dispose de l’OS 5.3 ou supérieur
• vous êtes à l’aise avec la programmation en Python et/ou vous avez terminé les unités 1 à 5.
• votre micro:bit est connectée à votre TI-Nspire CX II
• vous avez suivi les instructions de configuration et les transferts de fichiers en utilisant le guide de mise en route micro:bit :

https://education.ti.com/fr/enseignants/microbit

Ce processus de configuration ne devrait être effectué qu’une seule fois, mais tenez-vous informé périodiquement des mises à jour.

Si tout est correct et que la configuration a étéréalisée avec succès, votre micro:bit devrait afficher l’image ci-contre lorsqu’elle est connectée à la TI-Nspire.

L’affichage sur la carte micro:bit  montre le logo TI, une icône de l’État du Texas avec un point lumineux  près  de Dallas, le siège de Texas Instruments, Inc.

Les modules micro:bit sont installés dans votre bibliothèque Python. Dans un éditeur Python, appuyer sur [menu] > plus de modules et vérifier que BBC micro:bit est répertorié sous les modules TI.

Partie 1 : rencontre extraterrestre :

Bien sûr, comme avec toute autre première expérience de programmation, vous commencerez par afficher un message sur l’écran de la carte micro:bit.

Démarrer un nouveau document TI-Nspire et sélectionnez : Ajouter > Python puis Nouveau pour commencer un programme (programme vide), nommé « salutation ».

Dans l’éditeur Python appuyer sur [menu] > plus de modules > BBC micro:bit  pour sélectionner l’instruction  import en haut des éléments de menu:

from microbit import *

                        display.show(image ou texte)

[menu] > Plus de Modules > BBC micro:bit > Display > Methods

« Salutations terriens »

Lorsque vous exécutez ce programme en appuyant sur [ctrl] [R], vous verrez les lettres de votre message apparaître, une lettre à la fois. Si vous tapez successivement deux lettres identiques, vous verrez sur l’écran la lettre « apparaître » deux fois, mais vous ne pouvez pas en distinguer deux.   

Si vous faites une erreur... revenez à la page 1.1 pour modifier votre programme, puis exécutez à nouveau le programme. Avez-vous oublié d’ajouter des guillemets autour du texte que vous vouliez afficher ?

                     display.scroll(« salutations terriens »)

qui se trouve également sur [menu] > Plus de Modules > BBC micro:bit > Display > Methods

Pour terminer l’instruction .scroll( ),  vous pouvez copier/coller la chaîne à partir de l’instruction  .show.  

La méthode .scroll( ) fait défiler le message de droite à gauche comme une bannière à travers l’affichage, ce qui le rend plus facile à lire.

Vous pouvez contrôler la vitesse du défilement en ajoutant le paramètre delay = :

display.scroll(« Salutations terriens », delay = 200)

Partie 2 : Battements du coeur.

Appuyer sur [ctrl] [doc] pour insérer une page et sélectionnez Ajouter Python > Nouveau pour ajouter un nouveau programme Python à votre document (le nôtre est nommé « cœur »).

 Dans l’éditeur Python, utiliser [menu] > Plus de modules > BBC micro:bit  et sélectionnez l’instruction  import en haut de la liste :

display.show(  )

Cette instruction se trouve sur :

[menu] > Plus de Modules > BBC micro:bit > Display > Methods

Entre parenthèses, remplacez l’invite en sélectionnant :

Image.HEART

depuis :

[menu] > plus de modules > BBC micro:bit > Display > Images > Set 1> Heart

             display.show(Image.HEART_SMALL)

Vous pouvez trouver cette image dans le même menu :   

Faire une boucle : Pour que les deux cœurs clignotent à plusieurs reprises (impression de battement), placez les deux instructions d’affichage dans une boucle. Avant les deux instructions d’affichage, insérez :

while get_key( ) != "esc":

trouvé dans

[menu] > plus de modules > BBC micro:bit > Commands

et mettez en retrait (indentation) les deux instructions d’affichage afin qu’elles forment le corps de la boucle.

Conseil important : L’indentation est essentielle dans les programmes Python. C’est ainsi que Python interprète les blocs de boucle et les blocs if.  Si les deux instructions d’affichage ne sont pas mises en retrait le même nombre d’espaces, vous verrez une erreur de syntaxe. Utilisez la touche [espace] ou la touche [tab] pour mettre en retrait les deux lignes de la même quantité.   Les espaces d’indentation sont indiqués dans l’éditeur par un symbole de diamant gris clair (♦♦) afin de faciliter une indentation correcte.

Astuce : si jamais vous pensez que votre programme est bloqué dans une boucle infinie, appuyez et maintenez la touche [home / on] sur votre TI-Nspire pour « casser » le programme. Cela peut se produire si vous l’utilisez alors que l’instruction True : est incorrectement placée dans le script. Ces leçons évitent ce type de structure.

sleep(1000) signifie 1000 milli secondes ou  un délai de 1 seconde.

Aussi trouvé sur

[menu] > plus de modules > BBC micro:bit > Commandes

Dans cette leçon, vous allez apprendre à utiliser les boutons et les gestes micro:bit, puis écrire un programme pour créer un dé et collecter les valeurs dans une liste à transférer vers un diagramme de données statistiques. Cette leçon comporte deux parties :

• Partie 1 : Utilisation des boutons et des instructions relatives aux gestes.
• Partie 2 : Utilisation d’un bouton ou d’un geste pour générer des données.

Objectifs :

• Lire et traiter les boutons A et B sur la carte micro:bit.
• Observer la différence entre .was et .is.
• Transférer des données du script Python vers TI-Nspire.
• Étudier les données collectées à partir du micro:bit.
• Utiliser des gestes pour contrôler l’affichage.

Démarrer un nouveau programme Python dans un nouveau document.

Appuyer sur la touche [home] et sélectionner Nouveau, puis Ajouter Python > Nouveau...

Nous appelons le programme boutons_gestes.

Dans [menu] > Plus de modules > BBC micro:bit  sélectionner l’instruction  d’importation  en haut de la liste :

from microbit import *

while get_key( )! = 'esc':

[menu] > plus de modules > BBC micro:bit > Commands

♦♦if button_a.was_pressed( ):

♦♦♦♦print(« Bouton A »)

if est mis en retrait pour faire partie de la boucle while  et  print( ) est mis en retrait davantage pour faire partie du bloc if. N’oubliez pas qu’une indentation correcte est très importante en Python. Une mise en retrait incorrecte peut provoquer des erreurs de syntaxe ou une exécution incorrecte de votre code. Notez les symboles losange gris clair (♦♦) qui indiquent l’espacement de mise en retrait.

if se  trouve dans [menu] > Intégrés > Contrôle.

La condition button_a.was_pressed( )  se trouve à

[menu] > Plus de modules> BBC micro:bit > Buttons and Logo  Touch

print( ) se trouve dans  [menu] > Intégrés > I/O.

Taper le texte « Bouton A » sur le côté de la fonction print( ).

Note : is_pressed( )  sera  également  utilisé plus tard.

button_b.is pressed( ). Notez que « IS » est différent de « WAS ».

Vous verrez bientôt comment ils diffèrent.

♦♦If button_b.is_pressed() :

♦♦♦♦print(«Bouton B » )

Appuyez sur chaque bouton et appuyez sans relâcher chaque bouton.

Vous verrez « Bouton B » affiché à plusieurs reprises tant que le bouton B est maintenu enfoncé, mais pas « Bouton A ». Il y a une différence entre .was_pressed( ) (qui nécessite une libération du bouton pour être réinitialisé) et .is_pressed( ) qui vérifie simplement si le bouton est enfoncé au moment même où l’instruction  est traitée.

Présentation des gestes.

Le micro:bit dispose d’un accéléromètre électronique qui peut mesurer l’intensité des accélérations dans trois directions différentes (un accéléromètre 3 axes ou 3D).

En plus de fournir des valeurs numériques pour l’accélération dans chaque direction (voir l’image), la carte micro:bit fournit également des « gestes » simples et faciles à comprendre tels que « face vers le haut » et « face vers le bas » qui sont basés sur ces valeurs directionnelles.

♦♦g = accelerometer.current_gesture( )

Astuce : encore une fois, faites attention aux indentations !

Taper ♦♦g =

Puis trouver accéléromètre.current_gesture( )  à

         [menu] > plus de modules > sensors > gestes micro:> bit BBC > >

Puis afficher la valeur de g :

♦♦print(g)

Rappel :  print( ) est dans  [menu] > Intégrés > I/O

Notez que ces deux instructions sont indentées pour faire partie de la boucle while mais pas de l’instruction if au-dessus.  N’oubliez pas que l’indentation de chaque ligne détermine la signification de ce que réalise le script. Alors SOYEZ PRUDENT !

On va à présent rajouter un commentaire pour l’utilisateur.

#commenter les deux dernières instructions de mouvements (utilisez [ctrl] [T] pour #commenter une ligne) comme indiqué dans l’image et ajouter cette autre instruction de geste à partir du même menu :

♦♦If accélérometer. was_gesture(« face vers le bas »):

♦♦♦♦ print(« face vers le bas »)

Les instructions du geste et le geste lui-même « chaîne » sont tous sur :

 [menu] > Plus de modules > bbc micro:bit > Sensors > Gestures

Vous pouvez simplement taper les chaînes de caractères correspondant au mouvement, mais dans l’instruction .was_gesture( ), Elles doivent correspondre exactement à l’élément du menu.

Lorsque vous exécutez ce programme, vous remarquerez le changement dans la sortie à l’affichage :

      .current_gesture() affiche constamment le geste.

Afficher la valeur sur la carte micro:bit uniquement. Essayez-vous même avant de regarder l’étape suivante. Nous utiliserons le programme actuel et ajouterons du code pour simuler le lancer de dé.

From random import * et randint( )  se trouvent tous deux sur

[menu] > Nombres Aléatoire

Le reste de l’instruction ♦♦♦♦de = randint(1, 6)  est tapé manuellement et est soigneusement indenté car il fait partie de la condition If button_a.was_pressed( ).

Encore une fois, faites attention à l’indentation.

                             display.show (de)

pour afficher la valeur sur la matrice de l’écran de la carte micro:bit.

Collecte de données : Lancer le dé avec juste une pression sur un bouton est agréable, mais pour une étude plus approfondie, il serait utile de stocker toutes ces valeurs afin que vous puissiez interpréter les données : Un nombre a-t-il une occurrence plus fréquente que les autres ? Quel est le nombre moyen ? Et ainsi de suite...

Ajouter les instructions au programme afin de :

• Créer une liste vide.
• Ajouter (.append) la valeur d’un lancer à la liste.
• Stocker la liste de Python vers le système TI-Nspire CX II pour l’analyse.

Chacune de ces trois tâches se traduit par des instructions placées à des endroits spéciaux dans le programme. Essayez-le vous-même avant de passer à l’étape suivante.

           lancers = [ ]

Les crochets sont sur le clavier et sur [menu] > Intégrés > Listes

Lorsqu’un lancer est effectué, il est ajouté à la liste avec :

           lancers.append(de)

La méthode .append() se trouve dans [menu] > Intégrés > Listes

A la fin du programme, la liste finale est stockée dans une liste de la TI-Nspire :

store_list("lancers", lancers)

La fonction store_list est à [menu] >BBC  micro:bit > Commands

Appuyer sur [ctrl]-[doc] ou [ctrl]-[I] pour insérer une page et ajouter une application Donnée et statistiques. Un nuage de points sera dispersé autour du graphique. Cliquez sur le message « Cliquez pour ajouter une variable » en bas de la nouvelle application et sélectionnez la liste des lancers. Voyez-vous l’écran à droite ?  Chaque point représente l’un de vos lancers affichés sur la matrice. Quelles informations pouvez-vous recueillir à partir de ce graphique ? Pouvez-vous remplacer le graphique par un histogramme ? Astuce : appuyez sur [menu].

Vous pouvez modifier ce programme de plusieurs manières ; par exemple en affichant combien de lancers ont été effectués.

Remarque : le bouton B et votre geste n’ont aucun effet sur la matrice. Essayez de modifier votre code pour afficher un lancer du dé uniquement lorsque vous « secouez » la carte micro:bit.

N’oubliez pas d’enregistrer votre document !

• Indenter l’instruction store_list( ) afin que la liste soit stockée dans la TI-Nspire à chaque fois que button_a.is_pressed.
• print(« terminé. ») à la fin du programme afin que vous sachiez que le programme est terminé.
• #comment If button_b.is_pressed... et le code de l’accéléromètre if... code.

Exécuter le programme en appuyant sur [ctrl] [R] sur le shell. Appuyer sur le bouton A de la carte micro:bit pour commencer à lancer le dé et regarder le nuage de points se modifier !

Le tracé affichera « Aucune donnée numérique » au début car la liste des lancers a été vidée par le programme, mais ne craignez rien : appuyer sur le bouton A commencera à tracer les données.

Dans cette leçon, vous allez observer le fonctionnement du capteur de lumière sur la carte micro:bit et stocker les données dans une liste de la calculatrice TI-Nspire pour une analyse plus approfondie.

• Lire et afficher les mesures du capteur de luminosité sur le micro:bit.
• Transférer des données de Python vers TI-Nspire CX II.
• Étudier les données collectées à partir de la carte micro:bit.

La carte micro:bit peut lire le niveau de luminosité ambiante à l’aide des LED d’affichage. En effet, les LED d’affichage peuvent également être utilisées comme des périphériques d’entrée !

Appuyer sur la touche [home] et sélectionner Nouveau > puis Ajouter Python >Nouveau...

Nous appelons le programme lum.

Pour vérifier les valeurs que le capteur de lumière peut détecter, écrivez le programme court suivant à l’aide des menus BBC micro:bit à partir de l’importation de la librairie microbit *

while get_key() != « esc »:

♦♦♦lum = display.read_light_level( )

♦♦♦print(« Luminosité » ,lum)

Vous trouverez var = .read_light_level( )  sur  [menu] > BBC micro:bit > Sensors; lum  sera le nom de la variable que vous tapez.

Rappel : [menu] > Plus de modules > BBC micro:bit > Commands> tant que get_key() != « esc »:

N’oubliez pas d’indenter les deux dernières instructions afin qu’elles soient incluses dans le corps de la boucle while.

Exécuter le programme et pointer l’affichage de la carte micro:bit vers une source lumineuse. Peu importe ce qui s’affiche sur l’écran. Déplacer le micro:bit vers puis loin de la source et observer les valeurs qui s’affichent sur l’écran de la calculatrice TI-Nspire CX II. Vous devez obtenir des valeurs entre 0 et 255.

Comme vous vous en doutez probablement, plus la source lumineuse est éloignée, plus la valeur du niveau de lumière reçu est faible. Maintenant, vous allez ajouter du code au programme pour collecter les données du niveau de luminosité pour créer un nuage de points de la luminosité par rapport au temps.

Appuyer sur [esc] pour terminer le programme et revenir à l’éditeur.

      temps = [ ]

      lumi = [ ]

Trouver les crochets sur le pavé numérique [ctrl] [parenthèse gauche] ou sur [menu] > Intégrés > Listes

Toujours avant la boucle while, une instruction pour initialiser une variable du compteur temps.    (t) à 0 : t = 0

♦♦ t = t + 1

♦♦       temps.append(t)

♦♦        lumi.append(lum)

La méthode  .append( ) se trouve dans [menu] > Intégrés > Listes.

Ces instructions ajoutent la valeur de la luminosité actuelle et la valeur t (instants) aux listes.

♦♦sleep(1000)

après les deux ♦♦ajouter des instructions. Cela interrompt la collecte de données pendant une seconde entre les échantillons. sleep( )  se trouve sur :

                [menu] > commandes BBC micro:bit >

Trouver store_list()  dans  [menu] > BBCmicro:bit > Commandes. Il faut deux arguments :  le « nom de la liste TI-Nspire » entre guillemets et celui de la liste Python sans guillemets. Suivez les invites des infos-bulles.

Appuyer sur [esc] pour terminer le programme.

Répéter le processus jusqu’à ce que vous ayez l’impression d’avoir de « bonnes » données.

Astuce : Une lampe de poche de téléphone fonctionne très bien.

Lorsque l’invite s’affiche au bas de la page « Cliquez pour ajouter une variable » et sélectionnez la liste des instants. Il s’agit de la variable indépendante.

Cliquer sur l’invite « Cliquez pour ajouter une variable » sur le côté gauche de l’écran et sélectionner la liste lumi. Il s’agit de la variable   dépendante. Cette action organise votre nuage de points comme l’image ci-contre.

Vous devrez peut-être exécuter le programme plusieurs fois pour obtenir une belle courbe lisse comme celle illustrée ici. Vous devrez peut-être également ajuster la fenêtre d’affichage lorsque vous utilisez des données différentes.

Vous pouvez également ajuster l’intervalle de temps entre les échantillons, mais veillez à modifier à la fois l’argument sleep(1000 ) et la valeur du compteur (t = t + 1).

Que remarquez-vous ?

• Quelle courbe observez-vous ? Quel modèle mathématique correspond à ce phénomène physique ?

Dans cette application, vous allez écrire un programme pour collecter des données à l’aide du micro:bit et exécuter le programme tout en observant l’évolution d’une représentation graphique sur une page fractionnée de la TI-Nspire CX II.

• Exécuter le programme Python d’un côté de l’écran (le shell Python).
• Afficher un nuage de points (ou un histogramme) des données collectées pendant l’exécution du programme (utilisation d’une application Données & Statistiques).

                                sommes = [ ]

Stocker immédiatement cette liste dans une variable TI-Nspire (portant le même nom).

                             store_list(« sommes », sommes)

Ainsi la liste TI-Nspire est également effacée.

• lancer deux dés (générer deux entiers aléatoires) ;
• faire la somme des nombres obtenus ;
• ajouter la somme à la liste sommes ;
• afficher les deux valeurs de dés, leur somme et le numéro de lancer sur l’écran TI-Nspire. Astuce : len(sommes) est le numéro de lancer ;
• afficher les deux valeurs sur la matrice de DEL de la cartemicro:bit ;
• stocker la liste dans une variable TI-Nspire.

♦♦      If accelerometer.was_gesture(« shake »):

♦♦♦♦   display.clear()

♦♦♦♦   d1 = randint(1,6)

♦♦♦♦   d2 = randint(1,6)

♦♦♦♦ somme = d1 + d2

♦♦♦♦ sommes.append(somme)

♦♦♦♦ display.clear()

♦♦♦♦ display.show(d1)

♦♦♦♦ sleep(250)

♦♦♦♦ display.clear()

♦♦♦♦ display.show(d2)

♦♦♦♦ sleep(250)

 Vous préférerez peut-être un délai plus long comme argument des instructions sleep( ). Si vous avez entré le code correctement et dans le bon ordre, essayez d’exécuter le programme maintenant et secouez la carte micro:bit. Vous devriez voir deux nombres affichés sur la micro:bit.

♦♦♦♦  print (d1, "+", d2,"=",somme, ",","lancer n° =", len(sommes))

             qui a comme conséquence l’affichage des lignes dans cette image.

♦♦♦♦store_list("sommes",sommes)

Le Shell a été « réinitialisé » en appuyant sur [ctrl] [R] et le programme ne se réexécutera pas seul. Retourner à l’éditeur Python et appuyer sur [ctrl] [R] pour exécuter le programme. Il fonctionne dans la moitié-écran Shell comme indiqué ici. Vous ne voyez aucune donnée numérique sur la droite parce que le programme stocke une liste vide tout de suite.

Lorsque vous collectez les données (secouez la carte micro:bit pour lancer les dés), les valeurs des sommes apparaissent sous forme de nuage de points dans l’application Données & Statistiques sur la droite.

L’appui sur [esc] mettra fin au programme et vous pouvez faire beaucoup d’autres analyses de données à une variable dans l’environnement TI-Nspire.

Appuyer à nouveau sur [ctrl] [R] maintenant (dans le shell Python) exécutera de nouveau le programme.

Astuce : pour effacer le Shell au début de chaque exécution, ajoutez l’instruction :

clear_history()

 Profitez-en et n’oubliez pas d’enregistrer votre document !

Dans cette leçon, vous allez installer le module Turtle dans la calculatrice TI-Nspire™ CX II-T et découvrir les instructions permettant à la « Tortue » d’effectuer des déplacements.

Objectifs :

• Installer le module Turtle dans la calculatrice et l’ordinateur.
• Réaliser le tracé de quelques figures simples.
• Créer une figure de « Math-Art ».

Remarque : les sections suivantes supposent que vous avez mis à jour votre TI-Nspire™ CX II-T vers la version 5.4 de l'OS ou une version ultérieure. Si vous n'avez pas effectué́ la mise à jour vers la version 5.4 ou une version ultérieure, veuillez consulter le site : https://education.ti.com/fr/produits-ressources/whats-new

Veillez à sauvegarder ou archiver les fichiers et les données de votre TI-Nspire CX II-T avant de procéder à la mise à jour. 

• Télécharger le système d’exploitation correspondant à votre modèle de calculatrice TI-Nspire CX II-T.
• Télécharger également le logiciel TI-Nspire™ que vous utilisez :

Logiciel TI-Nspire™ CX Édition Élève.
Logiciel TI-Nspire™ CX CAS Édition Élève.
Logiciel TI-Nspire™ CX Premium, Édition enseignant.

La mise à jour du système d’exploitation de la calculatrice peut être effectuée à l’aide du logiciel compagnon ou bien à l’aide de l’application en ligne : https://nspireconnect.ti.com/

Si la mise à jour est effectuée à l’aide du logiciel :

• Connecter la calculatrice à l’ordinateur.
• Mettre la calculatrice sous tension.
• Dans le menu Outils du logiciel, choisir le sous-menu « Installer OS »

Choisir le fichier adéquat dans l’arborescence des dossiers ou répertoires de votre ordinateur.

Un message d’avertissement vous informe de l’opération qui va être réalisée

Ne pas débrancher le câble lors de la mise à jour du système.

Lorsque le transfert est terminé, il est proposé de redémarrer la calculatrice.

Cette étape nécessite l'utilisation
du logiciel pour ordinateur
TI-Nspire CX (PC ou Mac)

• Ouvrir votre logiciel TI-Nspire CX pour ordinateur.
• Connecter votre calculatrice TI-Nspire CX II à votre ordinateur en utilisant le câble USB ordinateur- calculatrice livré avec la calculatrice. 

Vérifier que votre calculatrice apparait dans la fenêtre unités connectées de l'onglet explorateur de Contenu du logiciel pour ordinateur.

Transférer le fichier “tns” Turtle à l’unité́ connectée en faisant glisser le fichier dans la fenêtre de l'unité́ connectée. Après avoir ouvert le fichier sur votre calculatrice, passez à l'étape
3) Installer le module Turtle.

Il s'agit d'un utilitaire en ligne qui
fonctionne avec les Chromebooks

• Utiliser le navigateur gratuit TI-Nspire CX II Connect (https://nspireconnect.ti.com/) pour transférer le fichier “tns” Turtle à une TI-Nspire CX II, connectée à un ordinateur, à l’aide du câble USB ordinateur-calculatrice.

Note : le fichier "tns" Turtle peut également être transféré entre calculatrices à l'aide du câble USB d'unité́ à unité́ préalablement connecté avant le transfert.

• Aller à l’étape : 3) Installer le module Turtle.

Transfert du module Turtle (fichier “tns”) sur votre logiciel pour ordinateur (PC ou Mac).

Après avoir téléchargé l’archive Zip et extrait les fichiers :

• Faire glisser et déposer le fichier "tns" Turtle sur votre logiciel pour ordinateur TI-Nspire™ CX.
• Après l’ouverture du fichier, aller à l’étape : 3) Installer le module Turtle

3) Installer le module Turtle

Ces étapes permettent d'installer le module sur l'unité́ nomade. Ces mêmes étapes sont également utilisées pour installer le module sur le logiciel pour ordinateur.

• Ouvrir le fichier Turtle et lire les instructions de la page 1.1.
• Appuyer sur [ctrl]+[►] pour passer au Shell de Python page 1.2.

Appuyer sur [menu] et sélectionner 1 : Outils > 8 : Installer en tant que module Python.

Une fois installé, un message « Installation terminée » apparaîtra, confirmant l'installation.

Remarque : lors de l'installation, le fichier du module Turtle est déplacé́ dans le dossier Pylib.

Créer un script utilisant le module Turtle : Tracé d’un polygone régulier.

Une fois l'installation du module Turtle terminée, créer un nouveau classeur afin d'écrire un programme Turtle.

• Dans l’écran d’accueil, sélectionner Nouveau
• Sélectionner : Ajouter Python, Nouveau...

• Donner un nom au programme Python (exemple : TSB1), valider : OK.
• Une page d'édition de programme Python est alors ouverte.

• Appuyer sur la touche [menu] et sélectionner : Plus de modules > Turtle Graphics.

À ce stade, vous êtes prêt à commencer à écrire un programme Python en utilisant les sélections du module Turtle.

Toutes les fonctions de la librairie Turtle sont regroupées dans ce menu par famille de l’action qu’elles réalisent.

En continuant à partir des sélections du menu de la fin de la page précédente (on se trouve dans une page de l'éditeur) :

1) Sélectionner from turtle import *

L'appuie sur [enter] colle l'instruction d'importation et le constructeur t=Turtle() comme première ligne de votre programme. Ceci importe les fonctions et méthodes du module Turtle dans votre programme et définit turtle comme un objet nommé "t".

Remarque : Toutes les sélections successives du menu font référence à un objet Tuttle nommé "t". Si vous changez le nom de l'objet, vous devrez également modifier la syntaxe collée en première ligne.

• Appuyer sur [Menu] puis 4 Intégrés et enfin 1 Fonctions afin de définir la fonction poly(n) permettant de tracer un polygone régulier de  côtés.
• Les instructions qui suivent sont à choisir dans [Menu] puis A Plus de modules et enfin Turtle Graphics.
• t.penup( )  permet de maintenir le stylo levé et se trouve dans le sous menu 4 Pen Control.
• t.goto(x,y) place la tortue au point de coordonnées cartésiennes . Cette instruction se trouve dans le sous menu Move.
• La boucle For est une instruction générale et se trouve dans le menu  4 Intégrés, 2 Contrôle.
• Pour chaque côté du polygone, faire avancer la tortue de 50 pixels t.forward(50) puis tourner vers la gauche t.left( ) d’un angle de 360°/n.
• A la fin du script, sortir de la boucle For
• L’instruction t.done( ) permet de garder la représentation à l’écran. L’appui sur la touche esc retourne un écran avec le prompt >>> affiché.

• Dans le programme principal, demander l’exécution d’un hexagone régulier avec l’instruction poly(6).
• Enregistrer le script Ctrl B.
• Si votre script est sans erreur, l’enregistrement de celui-ci n’affiche pas de message d’alerte.
•  Pour exécuter le script, appuyer sur la touche Ctrl R.

• Pour exécuter le script, appuyer sur la touche Ctrl R.
• Lorsque l’hexagone est tracé, appuyer sur esc ou enter pour revenir à la console.

Remarque : l’appel de la fonction poly( ) à partir du Shell et non du script supprime l’affichage de la grille.

Pour aller plus loin : un peu de Math-Art

• Dans le même classeur, créer une nouvelle activité.
• Créer un nouveau script Python et le nommer TSB11.
• Créer une fonction carre( ).
• Construire un carré de 50 pixels de coté
• Tourner la tortue de 5° vers la droite

Le programme principal réalise 18 fois l’exécution de la fonction carré( ).

• Enregistrer le script Ctrl B.
• Exécuter le script Ctrl R.

Dans cette leçon, vous allez poursuivre la découverte du module Turtle en utilisant les options de dessin et de déplacement de la tortue du module Turtle.

Objectifs :

•  Créer un triangle isocèle et le remplir de couleur.
• Colorier un disque
• Assembler ces deux objectifs pour créer un dessin.

Comment réaliser la à l’aide d’un script Python en utilisant le module Turtle ?

Cela semble relativement simple, mais qu’en est-il vraiment ?

On observe que la figure est constituée de :

• Un disque de couleur jaune centré sur l’origine du repère.
• Une série de triangles isocèles équirépartis autour du disque.

Avant de fournir en complément de cette leçon quelques éléments permettant de réaliser le soleil, réalisons séparément, chaque élément.

A : Tracé d’un triangle isocèle

• Commencer un nouveau script en le nommant TRIANGLE.
• Importer la librairie de fonctions mathématiques (utile pour les calculs de trigonométrie) et la librairie Turtle.
• Créer la variable ccorrespondant à la longueur de la base du triangle. (c = 60) correspond à 60 pixels.
• Créer la variable b exprimant en radian l’angle de 70°.
• Créer la variable h, hauteur du triangle isocèle

• Fixer la vitesse de la tortue t.speed(0-10).
• Le sous [Menu] ; A Plus de module puis Turtle Graphics et enfin 8 Filling permet de choisir les options de couleur R,V,B pour colorier un polygone.

Remarque : Les couleurs sont codées sur 8 bits de 0 à 256, soit 2⁸ possibilités.

• Les instructions t.begin_fill( ) et t.end_fill( ) permettent d’établir les instants entre lesquels la méthode de remplissage débute puis se termine. 

• Dans le menu Move du module Turtle, recopier les instructions  t.forward( ) et t.left( ) afin de compléter la construction du triangle.
• Par souci d’esthétisme, masquer la tortue à l’aide de l’instruction t.hideturtle( ) située dans le menu Settings.
• Ne pas oublier l’instruction t.done( ) pour afficher le dessin à la fin du script.

Remarque : Le tracé du triangle peut être simplifié. Il a été conçu ici de cette façon, afin d’assurer la compréhension du calcul de l’angle en se ramenant à 2 triangles rectangles et également sur le fait que le point de départ du tracé est l’origine du repère

• Exécuter votre script et observer le tracé du triangle isocèle.
• Effectuer plusieurs tracés en modifiant les paramètres du script (valeur de , couleurs du fond et du contour …).
• Pour construire la couronne solaire, nous devrons être capables de modifier l’orientation du triangle ainsi que sa position dans le repère.

1. Modification de la position

• Dans le menu Move, choisir l’instruction t.goto(x,y). Cette instruction indique les coordonnées (x,y) du point vers lequel la tortue doit se déplacer.
• Bien entendu, la place de cette instruction s’impose. Dans notre exemple celle-ci sera avant le tracé du triangle.
• Mettons par exemple t.goto(50,25).
• Exécuter à nouveau le script. Un changement de repère au point de coordonnées (50,25) a bien été effectué, avec l’inconvénient d’observer également le tracé d’un segment entre les points de coordonnées (0,0) et (50, 25).

• Pour éliminer le segment entre les points de coordonnées (0,0) et (50,25), aller dans le sous menu 4 Pen control du module Turtle et choisir les instructions 1 : t.penup( ) et 2 : t.penddown( ).

Naturellement l’instruction de déplacement de la tortue doit être située entre ces deux instructions.

Exécuter le script et constater l’effet produit par ce trio d’instructions.

b. Modification de l’orientation

• Dans le sous menu Move du module Turtle, choisir l’instruction
  6 : t.setheadind( ).
• Placer cette instruction avant le tracé du triangle.

Par rapport à la position précédente, le triangle devrait tourner de 90° vers la droite.

• Exécuter de nouveau le script et observer le résultat obtenu.
• Lors de la réalisation du soleil, il sera ainsi possible à l’aide de cette instruction de créer la couronne de rayon. Bien entendu, nous aurons besoin de le faire au sein d’une boucle fermée.

B : Tracé du disque solaire

Les instructions t.fillcolor(r,g,b) associées à t.begin_fill( ) et t.end_fill( ) ne fonctionnent que pour des polygones et non pour remplir des cercles d’une couleur donnée.

t.circle( ) trace un cerle et non un disque.

En remplacement, utiliser l’instruction t.dot(diamètre) que l’on trouve dans le sous menu Draw dessinera un point de diamètre fixé en pixels comme argument de la fonction.

L’instruction t.pencolor(r,g,b) permettra de choisir la couleur du crayon utilisée pour dessiner ce point.

• Créer un nouveau script et le nommer DISQUE.
• Recopier les instructions ci-contre afin de réaliser le disque de couleur jaune.
• Tester votre script.

C : Réalisation du soleil (Pour aller plus loin)

• Créer un nouveau script et le nommer TSB2.
• La représentation ci-contre donne le nom des variables utilisées dans le script.
• Autour du cœur du soleil de rayon , on dispose tous les 30°, un triangle isocèle de base  et de hauteur . Ces triangles sont représentés sur un cercle de rayon .
• Afin d’orienter correctement chaque triangle représentant un rayon du soleil, on modifie le cap de la tortue à l’aide de l’instruction t.setheading( ).
• La position initiale de la tortue correspond à un angle  à partir d’une orientation t.setheading(-90°).
• Le script complet reprend en tout point ce qui a été vu dans cette leçon.

Dans cette troisième leçon, vous allez écrire un programme vous permettant d’utiliser la bibliothèque Turtle afin d’illustrer la résolution d’un problème élémentaire de mathématiques.

Objectifs :

• Résoudre un triangle quelconque.
• Dessiner une représentation géométrique.

On se propose de résoudre un triangle scalène en utilisant les relations du mathématicien Al Kashi.

Ce résultat porte le nom du mathématicien persan du début du XVe siècle al-Kâshî. Appelé aussi « loi des cosinus », il généralise le théorème de Pythagore aux triangles non rectangles. Le théorème d'al-Kâshî s'énonce ainsi :

Soit ABC un triangle et soit α une mesure (en radians) de l’angle au sommet A. Alors :AB²+AC²=BC²+2×AB×AC cos⁡ (α)

Afin de simplifier, on adopte la notation de la figure ci-contre, ce qui permet d’établir pour chaque côté du triangle, les relations :

Connaissant la longueur des 3 côtés du triangle, écrire un script qui :

• Affiche la représentation du triangle.
• Affiche la mesure des angles en degrés.

La longueur des côtés sera donnée en pixels.

• Créer un nouveau script et le nommer TSB3.
• Importer la bibliothèque Turtle.
• Créer les variables a ,b,c correspondant aux longueurs (pixels) des côtés du triangle.

• Calculer les cosinus des angles respectivement nommés ca, cb, cc.


• En déduire les valeurs des angles arrondies au dixième.

• Le tracé du triangle débute au point de coordonnées (-100 , -80)


• Les instructions var=t.xcor( ) et var=t.ycor( ) sont utilisées afin de faciliter l’écriture des noms des sommets du triangle. Ces instructions servent à sauvegarder les coordonnées du turtle et se trouvent en appuyant sur [Menu] puis A Plus de modules, puis Turtle Graphics et enfin 6 Tell Turtle’s state ; 3 var=t.xcor( ).


• L’instruction t.pencolor(0,0,255) sert à paramétrer le stylo en couleur bleue. On peut aussi utiliser l’instruction t.pencolor(« blue »)

La dernière partie du script est destinée à afficher les noms des sommets du triangle ainsi que les valeurs des angles correspondants.

Remarques : On notera que sur la TI-Nspire, l’instruction t.write( ) nécessite que soit fixée avant chaque utilisation la couleur du stylo, celui-ci étant en noir par défaut. Les instructions ci-contre produisent le résultat ci-dessous.

L’instruction t.write( ) sur TI-Nspire n’admet pour argument qu’une chaîne de caractères ou un nombre. L’affichage d’une liste renvoie un message d’erreur.

Exécuter le script pour diverses valeurs de a,b,c

Dans cette leçon, vous allez assembler les connaissances vues dans les leçons précédentes afin de réaliser un script permettant de concevoir vous-même la réalisation d’un projet.

Objectifs :

Appliquer les notions vues dans les leçons précédentes.

Réaliser une figure complexe nécessitant de la programmation fonctionnelle.

Dans les leçons précédentes, nous avons vu que l’utilisation de la librairie Turtle dans un script Python afin de construire une figure géométrique nécessitait fréquemment la mise en place de calculs.

La clarté du script impose que celui-ci soit commentée, mais également que chaque tâche complexe soit décomposée en un certain nombre de tâches élémentaires.

Dans cette leçon, nous allons réaliser une décoration de Noël, le programme principal appelant des fonctions pour :

• Dessiner et colorier un triangle isocèle.
• Dessiner le pied du sapin.
• Tracer et colorier une étoile.
• Décorer et animer le sapin.

Mise en place du projet

Tout projet comporte une sorte de cahier des charges. Pour celui-ci utilisant le module Turtle et affichant un objet graphique, les contraintes sont aussi celles de la taille de l’écran (grille d’unité 25 pixels).

 La décoration est constituée de points de couleurs t.dot(diamètre), la taille et la position étant aléatoires.

 Les points de couleurs doivent être contenus dans le triangle isocèle.

 La représentation préalable à l’aide d’un logiciel de géométrie dynamique sur lequel le repère orthonormal est identique à la grille de la librairie Turtle facilite le travail de recherche.

 Ainsi les points de coordonnées (-75 , 75) ; (75 , -75) et (0 , 75) seront les sommets du triangle.

 Les droites d’équation réduites y=2x+75 ,y=-2x+75 et y=-75 délimitent le plan de représentation des points de couleur.

Création du script

• Commencer un nouveau script et le nommer Apps_SAPIN.
• Appuyer sur [Menu] puis importer les modules math ; random et turtle nécessaires à l’écriture du projet.
• Le module random est utile pour le calcul aléatoire des positions et du nombre des objets colorés.

Dessin du pied du sapin

Le dessin du pied commence au point de coordonnées (0,-100) t.goto(0,-100).

Il a pour longueur 25 pixels t.forward(25).

Afin de le tracer le plus simplement possible, choisir la taille la plus épaisse du crayon t.pensize(3).

Orienter la tortue vers les t.setheading(90).

La couleur du crayon est un marron correspondant au code RVB suivant (165, 42, 42) et l’instruction pour l’utiliser est t.pencolor( ).

Dessin de l’étoile

Pour la fonction etoile( ), nous aurions pu rappeler le script de la compétence 1 au cours de laquelle nous avons dessiné des polygones réguliers.

Le rappel d’un autre script s’effectue à l’aide de l’instruction
from SCRIPT import* disponible dans le catalogue.

• L’étoile est fixée au sommet du sapin au point de coordonnées (0, 75).
• Les branches sont remplies t.fillcolor( ) d’une teinte orangée de code RVB (255,127,0).
• L’instruction t.fillcolor( ) termine la coloration des branches de l’étoile.
• À chaque itération, déplacer la tortue de 30 pixels vers l’avant et la déplacer à droite de 144 degrés.
• Cela constituera un angle de 36 degrés à l’intérieur d’une étoile.
• 5 itérations constitueront parfaitement une étoile.

Dessin du sapin

L’enveloppe de celui-ci est constituée d’un simple triangle isocèle comme nous l’avons vu dans la mise en place du projet.

L’ensemble des mesures (valeurs des angles, longueur des côtés..) sont issues de ce travail préparatoire.

Les valeurs des angles mesurées en radian lors de l’utilisation du logiciel de géométrie dynamique sont converties en degrés.

Le triangle isocèle est rempli de couleur « vert sapin », dont le code RVB est : (1, 121, 111).

Dessin des boules de Noël

On dispose de  boules de couleur R, V, B à placer à l’intérieur du triangle isocèle. Chaque composante de couleur est un nombre entier aléatoire compris entre 0 et 255 (Le codage d’une composante étant sur 8 bits, soit  possibilités).

La taille d’une boule de couleur est aléatoirement choisie entre 5 et 10 pixels.

L’instruction conditionnelle permet de limiter l’emplacement de chaque décoration à l’intérieur du triangle isocèle.

Si on souhaite mettre des guirlandes à la place de boules de Noël, supprimer ou commenter l’instruction t.penup( ) de la fonctions boules( ).