TI Codes : TI-83 Premium CE Edition 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 .show( ), .scroll( ) et .show(image).
• Contrôler la vitesse de l’écran à l’aide de sleep(ms).

Avant de commencer, assurez-vous que :

• votre TI-83 Premium CE Edition Python dispose de l’OS 5.6.1 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-83 Premium CE
• vous avez suivi les instructions de configuration et les transferts de fichiers à l’aide du guide de mise en route micro:bit :

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

Rappel : les Modules sont à télécharger à l’adresse :

https://education.ti.com/fr/enseignants/microbit/microbit-83ce

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-83 Premium CE.

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.

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 script Python ; le nommer « SB1 ». Dans l’éditeur Python appuyer 2^nde catalog puis F pour sélectionner l’instruction « from SCRIPT import * ». Valider en appuyant sur la touche [entrer] et compléter manuellement l’instruction :

from microbit import *

 

Conseil : Si le message « micro:bit not connected »  apparaît, débranchez simplement le micro:bit et rebranchez-le (reset).

Pour afficher un texte message sur l’affichage micro:bit, utilisez l’instruction « display.show(image ou texte) », après avoir chargé le module affichage, que l’on trouve dans le module général micro:bit.

Celle-ci se trouve sur :

    [Fns] < Modul 9 : affichage > 2 : .show(val)

L’instruction est insérée en tant que display.show(image ou texte), mais (image ou texte) est juste un espace réservé qui doit être remplacé par quelque chose. À l’intérieur des parenthèses, remplacez l’image ou le texte en tapant la chaîne de votre message entre guillemets :

« salutations terriens »

Lorsque vous exécutez ce programme en appuyant sur F4 [Exec], vous verrez les lettres de votre message apparaître, une lettre à la fois, sur l’écran. Si votre message est composée d’une répétition successive de la même lettre, vous ne pouvez pas en distinguer deux.   

Si vous faites une erreur... Editez à nouveau le script pour le modifier après avoir interrompu son fonctionnement [annul], puis exécutez à nouveau le programme. Avez-vous oublié d’ajouter des guillemets autour du texte que vous vouliez afficher ?

Remarque : l’instruction « display.show(val, del=400, wait=True) » comporte des paramètres optionnels (delay=400 en ms, et wait) dont l’utilisation n’est pas utile dans cette leçon. Ils peuvent donc être effacés en utilisant la touche [suppr].

Une autre méthode pour afficher les messages est :

                     display.scroll(« salutations terriens »)

qui se trouve également sur [Fns] < Modul 9 : affichage > 2 : .show(val).

Pour commenter la ligne précédente, placer le caractère # devant la ligne à commenter.

Faites de l’instruction .show( )  précédente un  #commentaire  (placez le curseur devant la ligne à commenter et appuyer sur 2^nde 3, puis  exécutez à nouveau le programme).

 

Vous pouvez également simplement remplacer .show  par .scroll en tapant l’instruction.

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)

Cette instruction utilise un délai de 200 millisecondes (0,2 seconde) dans le défilement. Essayez également d’autres valeurs de délai.

Partie 2 - Battements du coeur

Appuyer sur [F5] [script] puis [F3] [Nouv] pour créer un nouveau script et le nommer « COEUR ».

Dans l’éditeur Python, utiliser 2^nde catalog puis from SCRIPT import et compléter l’instruction :

from microbit import *

Charger le Module d’affichage [Fns] < Modul 8 : micro:bit > 1 : affichage.

Pour afficher le symbole HEART sur l’affichage micro:bit, utilisez l’instruction :

display.show(  )

Cette instruction se trouve sur :

[Fns] < Modul 9 : affichage > 2 : .show(val)

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

Image.HEART

depuis

[Fns] < Modul 9 : affichage > Image > 2 : HEART

Exécuter le programme (appuyez sur [F4] [Exec]) pour voir l’icône HEART affichée sur la grille LED 5x5 de la carte micro:bit. Cet affichage restera jusqu’à ce qu’un autre prenne sa place, même après la fin de l’exécution du programme.

Revenir à l’éditeur de programmes sur la page précédente, et ajouter une autre instruction d’affichage pour montrer le petit cœur :

             display.show(Image.HEART_SMALL)

 

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

[Fns] < Modul 9 : affichage > Image > 3 : HEART SMALL

Astuce : vous pouvez également copier / coller la première instruction d’affichage et la modifier (insérez le _SMALL).

Exécuter à nouveau le programme. Il affiche rapidement le grand cœur, puis affiche le petit cœur qui ressemble à l’image ci-contre.

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

while not escape( ):

trouvé dans

[Fns] < Modul > 4 : ti_system > 5 : while not escape( ) :

 

N’oubliez pas de charger préalablement le module ti_system 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 [F3] [Outils] puis 1 : Indent > pour mettre en retrait les deux lignes de la même quantité. Les espaces d’indentation sont indiqués dans l’éditeur par un symboles de diamant gris clair  (♦♦) afin de faciliter une indentation correcte.

Exécuter à nouveau le programme et regarder le cœur battre ! Appuyer sur la touche [esc] pour terminer le programme.

Astuce : si jamais vous pensez que votre programme est bloqué dans une boucle infinie, appuyez et maintenez la touche [on] sur votre TI-83 Premium CE 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.

Le menu time micro:bit contient des instructions Python utiles que l’on trouve également dans d’autres menus. Le module micro:bit importe ces commandes Python pour vous.

 

Vous pouvez trouver ces commandes et toutes les autres commandes Python à partir d’autres menus. Vous n’êtes pas limité à utiliser simplement le menu BBC micro:bit, mais vous devrez peut-être fournir les commandes d’importation appropriées.

Pour contrôler la fréquence des battements cardiaques, ajoutez deux instructions sleep( ),une après chaque instruction d’affichage: sleep(1000) signifie 1000 milli secondes ou  un délai de 1 seconde.

Aussi trouvé sur

[Fns] < Modul > 3 : time.. > 2 : sleep( )

 

Astuce : observez l’indentation !

Extension : Essayer de faire une « série de visages » ou smiley. Utiliser une structure de programme similaire à celle du script « Battements du coeur », mais sélectionner plutôt les images de visages trouvées dans l’ensemble des images.

Dans cette leçon, vous allez apprendre à utiliser les boutons et l’accéléromètre de la carte BBC micro:bit, puis écrire un programme pour créer un dé et collecter les valeurs dans une liste à transférer, afin de créer un diagramme de données statistiques.

Cette leçon comporte deux parties :

• Partie 1 : Etude des instructions sur les boutons et utilisation de l’accéléromètre.
• Partie 2 : Utilisation d’un bouton 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 la calculatrice.
• Étudier les données collectées à partir du micro:bit.
• Utiliser l’accéléromètre pour contrôler l’affichage.

La carte micro:bit possède deux boutons,étiquetés A et B, de chaque côté de la carte. Le module Python micro:bit a deux méthodes similaires pour utiliser les boutons. Vous allez d’abord tester les instructions, puis écrire un programme qui vous permet de collecter des données et de les analyser ailleurs dans la calculatrice TI-83 Premium CE.

Il y a aussi une puce accéléromètre/boussole à 3 axes à l’arrière du micro:bit. Une convention (orientations des axes)  est nécessaire afin d’interpréter le mouvement et l’orientation de la carte micro:bit.

Partie 1 : Utilisation des boutons.

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

Appuyer sur la touche [prgm] et sélectionner 2 : Python App puis [F3] Nouv.

Nous appelons le programme BOUTONS.

Dans 2^nde catalog, sélectionner l’instruction d’importation from SCRIPT import et complétez manuellement l’instruction.

from microbit import *

Importer également la bibliothèque TI_System.

Ajouter la boucle while :

while not escape( ):

depuis

[Fns] > modul > 4 : ti_system > 5 : while not escape( )

 

La plupart de vos programmes micro:bit seront conçus de cette façon.

Pour tester le bouton A, charger la librairie relative aux boutons puis ajouter la condition :

♦♦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 encore plus 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 (indentation).

 

if se  trouve dans [Fns] > Ctl .

La condition button_a.was_pressed( )  se trouve à

[Fns] < modul> 9 : boutons > 2 : .was_pressed( )

 

print( ) se trouve dans  [Fns] < E/S.

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

 

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

Vous êtes prêt à tester le programme. Appuyer sur [F4] Exec pour exécuter le programme. On dirait qu’il ne se passe rien. Appuyez et relâchez le bouton A sur la carte micro:bit. Vous verrez « Bouton A » apparaître sur l’écran de la calculatrice. Chaque fois que vous appuyez sur le bouton, le texte apparaîtra comme dans cette image.

 

Appuyez sur [annul] et revenez à l’éditeur Python.

Ajoutez une autre instruction if pour vérifier le fonctionnement du bouton B à l’aide de la condition button_b.is pressed( ). Notez que « IS » est différent de « WAS ».

Vous verrez bientôt en quoi ils diffèrent.

♦♦if button_b.is_pressed() :

♦♦♦♦print("Bouton B")

 

Astuce : encore une fois, faites attention aux indentations !

Exécutez à nouveau le programme (appuyez sur [F4] Exec). Essayez les deux boutons A et 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.

Remarque : si vous appuyez sur le bouton B rapidement, le programme peut ne pas afficher le bouton B car le bouton n’est pas enfoncé au moment même où l’instruction if est en cours de traitement.

Utilisation de l’accéléromètre. 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).

Cette leçon explore les possibilités de l’accéléromètre et montre comment l’utiliser dans la programmation de votre TI-83 Premium CE avec la carte micro:bit.

 

Charger la librairie relative aux capteurs. Cette librairie se trouve à :
[Fns] < modul > 8 : micro :bit > 3 : capteurs

Obtener les valeurs de l’accélération du mouvement à partir du micro:bit et les stocker dans les variables ax, ay, az:

♦ ♦ ax,ay,az = accelerometer.get_values( )

Astuce : encore une fois, faites attention aux indentations !

Taper ♦ ♦ ax,ay,az  puis

Trouver accelerometer.get_values( ) à

[Fns] < modul > 0 : capteurs > 4 : var,var,var=.get values( )

Puis afficher les valeurs des accélérations selon les axes Ox, Oy et Oz :

♦ ♦ print(ax,ay,az)

Rappel :  print( ) est dans  [Fns] < E/S

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 !

Exécuter le programme et regarder l’affichage de la calculatrice pour les différentes valeurs lorsque que vous déplacez la carte micro:bit dans les airs. Tournez la carte micro:bit, tenez-la sur chaque bord, secouez-la. Une partie de l’exécution du programme est affichée dans cette image.

L’accéléromètre du BBC micro :bit mesure le mouvement selon trois axes :

• X - l’inclinaison de gauche à droite.
• Y - l’inclinaison d’avant en arrière.
• Z - le mouvement haut et bas.

Pour chaque axe, la convention de repérage permet de comprendre le signe obtenu lors d’une mesure. Un nombre positif ou négatif qui indique une mesure en milli-g. Lorsque la lecture est de 0, on est  « aligné » selon cet axe.

Nous allons réaliser un « niveau à bulle » très simple qui utilise l’instruction accelerometer.get_x( ) pour mesurer l’alignement de la carte selon l’axe X. L’algorithme est le suivant

Créer un nouveau script appelé « niveau » et importer les modules nécessaires (micro:bit, ti_system, mb_sensor, mb_disp).

Astuce : Dupliquer le script précèdent à l’aide de

[Script] ↓ selection du script [Gérer] 1 : Dupliquer

Effacer ensuite les lignes que vous ne souhaitez pas conserver, ou les commenter.

 

Mettre la carte BBC micro:bit sur une surface plane et exécuter le script. Vérifier ainsi la planéité d’une surface.

Si l’appareil est tenu horizontalement il devrait afficher -- en revanche, si on l’incline vers la gauche ou vers la droite il devrait afficher G ou D respectivement.

Les boutons et les déplacements spatiaux sont deux façons d’obtenir une entrée sur la carte micro:bitet de produire des résultats sur l’écran de la calculatrice TI-83 Premium CE, l’écran micro:bit... ou les deux. La partie suivante de cette leçon crée une activité qui produit des données à l’aide de la carte micro:bit pour un apprentissage plus approfondi avec la TI-83 Premium CE.

Partie 2 : Jetons un dé (un cube numéroté de 1 à 6 sur ses faces). Lorsque le bouton A est enfoncé, un entier aléatoire de 1 à 6 est assigné à une variable. Vous pouvez utiliser le bouton A, le bouton B ou un déplacement de votre choix.

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

Pouvez-vous déterminer quel numéro se trouve au bas du dé illustré ci-contre ?

Reprendre le script « boutons ». Ajoutez les deux instructions mises en valeur selon les indications de la capture ci-contre :

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

[Fns] < Modul > 2 : Random

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.

Une fois que la valeur de la variable a été établie, ajouter l’instruction :

                             display.show (de)

pour afficher la valeur sur la matrice de l’écran de la carte micro:bit, sans oublier de charger le module d’affichage mb_disp.

 

Exécuter le programme à nouveau. Lorsque vous appuyez sur le bouton A, vous voyez « Bouton A » sur l’écran de la calculatrice et le numéro sur l’affichage de la carte micro:bit change... mais pas à chaque  fois ! Parfois, le nombre aléatoire sélectionné est le même que le précédent. Les appuis successifs sur le bouton A sont des « événements indépendants ».

Collecte de données : Lancer le dé avec juste une pression sur un bouton est intéressant, mais pour une étude plus approfondie, il serait utile de stocker toutes ces valeurs dans des listes 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-83 Premium CE pour l’analyse.

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

L’affectation de liste vide est à mettre au début du programme :

           lancers = [ ]

Les crochets sont sur le clavier et dans la table de caractères [a A #].

 

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

lancers.append(de)

La méthode .append() se trouve dans [Fns] > List > 6.append(x)

 

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

store_list("2", lancers)

La fonction store_list est à [Fns] < Modul > 4 : ti_system.

Extensions possibles :

• Modifier votre script afin que la face de chaque lancer soit affichée.
• Utiliser l’accéléromètre afin de déclencher la réalisation d’un lancer.

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-83 Premium CE pour une analyse plus approfondie.

Objectifs :

• Lire et afficher les mesures du capteur de luminosité sur la carte micro:bit.
• Transférer des données de Python vers la TI-83 Premium CE.
• É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. Oui, les LED d’affichage peuvent également être utilisées comme des périphériques d’entrée !

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

Appuyer sur la touche [prgm] et sélectionner 2 : Python App > puis [F3] > Nouv.

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 et après l’importation des librairies microbit, mb_disp et TI_system :

while not escape( ) :

♦♦♦lumi = display.read_light_level( )

 ♦♦print(« Luminosité » ,lum)

Vous trouverez var = .read_light_level()  sur  [Fns] < Modul >9 : Affichage.

Taper le nom de la variable « lum », puis rechercher ensuite l’instruction « display.read_light_level( ) ».

Rappel : [Fns] < Modul > 4 : TI_System > 5 : while not escape :

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 la carte micro:bit vers puis loin de la source et observer les valeurs sur l’écran de la calculatrice TI-83 Premium CE. Vous devez obtenir des valeurs entre 0 et 255.

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

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

Créer deux listes vides avant votre boucle while :

temps = [ ]

lumi = [ ]

Trouvez les crochets sur le pavé numérique 2nde [x][-] ou sur [Fns] > List > 1 : [ ].

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

Évitez d’utiliser le mot « time » comme variable, car il existe un module temporel qui utilise ce nom. En outre, c’est une bonne habitude de pluraliser les noms de liste car ils contiennent de nombreuses valeurs.

Dans le corps de la boucle, après l’instruction print, ajouter une instruction pour incrémenter la variable de temps t. Nous utiliserons un intervalle de temps d’une seconde entre les lectures de lumière.

♦♦t = t + 1

Remarque : On peut aussi écrire t+=1, ce qui est plus élégant en Python.

 Ajoutez les valeurs de lumi et t à leurs listes respectives à l’aide des instructions suivantes :

♦♦       temps.append(t)

♦♦       lumi.append(lum)

La méthode .append( ) se trouve dans [Fns] > List.

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

Pour contrôler l’intervalle de synchronisation de l’échantillonnage, ajouter :

♦♦sleep(1000)

Remarque : L’instruction sleep( ) se trouve dans le module time, mais aussi dans le menu ti_system.

Cela interrompt la collecte de données pendant une seconde entre les échantillons. sleep( )  se trouve sur :

                [Fns] < Modul >4 : ti_system > A : sleep( )

Rappelez-vous que lors de l’utilisation de la carte micro:bit,  sleep( ) utilise des millisecondes comme argument. L’échantillonnage a lieu une fois par seconde.

Après le corps de la boucle (plus d’indentation !), stocker les deux listes Python dans deux listes TI-83 Premium CE en utilisant éventuellement les mêmes noms dans les deux environnements : commencer au début d’une nouvelle ligne (pas d’espace, ni d’indentation !).

Trouver store_list()  dans  [Fns] < ti_system > 3 : store_list(« nom »,var). Il faut deux arguments :  le « nom de la liste TI-83 Premium CE » entre guillemets et celui de la liste Python sans guillemets.

Dans ce programme, les listes Python ne sont stockées dans les listes TI-83 Premium CE juste qu’à la toute fin du programme, lorsque vous appuyez sur [annul] pour quitter la boucle while.

Dans cette application, vous allez écrire un programme pour collecter des données à l’aide du micro:bit et exécuter le programme puis utiliser le mode radio de la carte BBC micro:bit afin de transférer ces données à une autre calculatrice.

• Écrire un programme de collecte de données à partir de la carte micro:bit.
• Créer un diagramme de représentation des données après les avoir classées.
• Transférer les données à une autre calculatrice.

Ce projet est une compilation de toutes les compétences micro:bit que vous avez apprises dans les trois dernières compétences :  écrire un programme qui utilise un geste, par l’intermédiaire de l’accéléromètre (ou une pression sur un bouton)  pour collecter des données, stocker la liste comme une variable de la TI-83 Premium CE ...

Commencer le programme micro:bit avec les importations habituelles, y compris le module aléatoire et commencer par une liste vide appelée sommes :

                                sommes = [ ]

Stockez immédiatement cette liste dans une liste de la calculatrice, L₂ par exemple.

                             store_list(« 2 », sommes)

Ainsi la liste sommes est également effacée.

print( ) quelques instructions à l’utilisateur avant le début de la boucle. Nous allons utiliser le bouton A pour simuler un lancer de dés.

Dans le corps de la boucle while, utiliser le geste pour

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

Essayez-le maintenant.

Pour effectuer le lancer des dés, appuyez sur un bouton :

♦♦     If button_a.was_pressed( ):

♦♦♦♦    display.clear()

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

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

Encore une fois, notez les indentations.

Additionner les numéros sortis et ajoutez la somme à la liste des sommes :

♦♦♦♦ somme = d1 + d2

♦♦♦♦ sommes.append(somme)

Afficher les deux dés sur l’écran de la carte micro:bit. N’oubliez pas que les deux dés peuvent avoir la même valeur, nous voulons donc nous assurer que les deux apparaîtront réellement :

 

♦♦♦♦ 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 pour les commandes

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.

Ajouter un code pour afficher la sortie des dés, la somme et les numéros des lancers sur l’écran de la calculatrice TI-83 Premium CE. Vous pouvez utiliser une seule instruction print( ) comme ceci :

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

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

Attention à la ponctuation !

Stocker les sommes de la liste Python en une liste TI-83 Premium CE L₂ par exemple :

 

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

 

L’instruction store_list( )  est  incluse à l’intérieur des blocs while et if afin que la liste TI-83 Premium CE soit mise à jour chaque fois qu’une nouvelle paire de dés est générée.

Lorsque vous êtes convaincu que votre programme fonctionne correctement, vous êtes prêt à l’utiliser avec les possibilités de représentation graphique de la calculatrice TI-83 Premium CE. Exécutez votre programme et générez environ 50 lancers. Appuyez sur [annul] pour terminer le programme.

 

Les données ne sont pas classées. Complétez votre script par une partie de code permettant de lire la liste sommes, puis de compter les données à l’aide de la méthode .count( ), correspondant à une somme (de 2 à 12). Les résultats seront stockés dans une liste datas( ), qui est ensuite exportée vers la calculatrice en L₄.

Remarque : pour plus de facilités, les valeurs possibles des sommes sont stockées dans une liste n également exportée vers la calculatrice en L₃.Ne pas oublier d’initialiser les listes au début du programme.

Effectuer ensuite la représentation graphique des données sous la forme d’un diagramme en bâtons.

Exemple de solution :

Le script ci-après est un exemple de solution. Vérifier que le vôtre est similaire, puis l’exécuter avant de passer à la partie suivante.

Communiquer avec une autre calculatrice.

On se propose maintenant de communiquer les données (résultats des lancers) à une autre carte BBC micro:bit.    

Le module radio permet d'envoyer ou de recevoir des messages vers ou depuis une ou plusieurs cartes microbit.

La communication se fait sans fil sur une fréquence entre 2,4GHz et 2,5Ghz selon le canal choisi (numéroté entre 0 et 83).

Les messages ont une taille maxi de 251 caractères. Par défaut, la taille est fixée à 32 caractères.

Pour utiliser la radio, vous devez avoir 2 cartes micro:bit et 2 calculatrices. La communication radio est très simple à mettre en œuvre comme vous pourrez le voir.

1. Initialiser la communication radio sur les deux calculatrices

       from mb_radio import*

       radio.on( )

 Par défaut, la radio est toujours désactivée pour des raisons d’économie d’énergie.

La communication peut alors s’établir entre plusieurs cartes.

1. Envoyer et recevoir

Pour envoyer un message sous forme d’une chaîne de caractères, utiliser l’instruction : radio.send(« message ») pour une chaîne de caractères et radio.send(number) pour un nombre.

Calculatrice émettrice :

Lorsque le bouton A a été pressé, la carte BBC micro:bit envoie les résultats des lancers à la calculatrice réceptrice. Il suffit de rajouter la petite portion de code ci-contre.

Calculatrice réceptrice :

Créer un nouveau script portant le même nom et importer les modules ti_system, microbit, mb_disp et mb_radio.

Configurer la liaison radio de manière identique à la calculatrice émettrice.

Effacer l’écran de la matrice display.clear( ). Cette instruction se trouve dans le module d’affichage mb_disp( ).

Créer une boucle ouverte (while) mettant la calculatrice en attente de la réception d’un nombre d. Cela se réalise à l’aide de l’instruction :

var = radio.receive_number( )

Si un nombre est reçu, celui-ci est affiché avec un délai modifiable de 400 ms.

b. Exécution des scripts.

Exécuter les scripts sur chaque calculatrice. La calculatrice réceptrice est en attente des informations de la calculatrice émettrice.

Lorsque l’on appuie sur le bouton A du micro:bit de la carte émétrice, l’affichage est transféré sur la carte réceptrice.

Dans cette leçon, vous allez installer le module Turtle dans la calculatrice TI‑83 Premium CE Edition Python et découvrir les instructions permettant à la « Tortue » d’effectuer des déplacements.

Objectifs :

• Installer le module Turtle dans la calculatrice.
• 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-83 Premium CE Edition Python vers la version 5.7 de l'OS et des Apps ou une version ultérieure. Si vous n'avez pas effectué́ la mise à jour vers la version 5.7 ou une version ultérieure, veuillez consulter le site : https://education.ti.com/fr/produits-ressources/mise-a-jour-ti-83-premium-ce. Veillez à sauvegarder ou archiver les fichiers et les données de votre TI-83 Premium CE Edition Python avant de procéder à la mise à jour.

Une fois le module Turtle et le fichier Grid transférés, créer un script Python et importer le module Turtle afin d'accéder aux sélections de son menu.

Sur votre TI-83 Premium CE Edition Python, ouvrir l'application Python. Vous pouvez la trouver à l’aide de la touche [prgm] ou de la touche [apps]. L'application Python s'ouvre sur un écran de gestion des scripts.

Créer un nouveau script Python en sélectionnant l'onglet intitulé
Nouv (appuyez sur la touche [zoom]).

Donner un nom au script Python (par exemple : TSB1), puis sélectionner Ok.

Vous êtes maintenant dans l'écran de l'éditeur de scripts Python. Saisir, ensuite, l'instruction d'importation Turtle et un objet Turtle.

Sélectionner l'onglet [Fns...] (en bas de l'écran), puis flèche gauche vers l'onglet Modul (en haut de l'écran).

En bas de l'écran, sélectionner l’onglet [Compl.].

Sélectionner l'option 3:from turtle import * pour coller l'instruction d'importation du module Turtle.

Remarquer qu'il colle aussi un constructeur t=Turtle() pour assigner à t l'objet Turtle.

Retourner à l’onglet Modul et remarquer l’apparition de 8 : turtle... dans le menu.

Maintenant, vous êtes prêt à accéder aux sélections de menu du module Turtle et à écrire un script Turtle !

A) Déplacer la tortue.

• Appuyer sur f1 (Fns…) afin d’accéder aux menus, puis choisir Modul.
• Choisir 8 : turtle… afin d’accéder à l’ensemble des menus de la bibliothèque. Les instructions du menu Move (mouvement) sont assez explicites. Les distances à renseigner entre parenthèses sont en pixels.
• Compléter le script afin de faire réaliser à la tortue l’algorithme suivant :
• L’instruction t.done( ) est nécessaire afin de pouvoir afficher la figure orsque l’exécution du script est terminée.

Appuyer sur la touche f4 (Exéc) et observer la réalisation.

La tortue est par défaut placée à l’origine du repère.

Par défaut également, la tortueest visible et vous la voyez dessiner. Noter également que la grille est visible, (l'échelle de la grille est de 25 pixels par carré).

Les instructions du menu Settings permettent de modifier ces options.

• t.hideturtle() – rend la tortue invisible.
• t.showturtle() – rend la tortue visible.
• t.hidegrid() – masque la grille.

Lorsque vous avez fini d'admirer votre travail, appuyer sur la touche [annul] pour effacer l'écran. Remarquer que vous vous retrouvez sur un écran du Shell de Python. C'est là que votre script Python a été traité.

B) Tracer un polygone régulier.

On se propose de réaliser un script permettant de tracer un polygone régulier. En effet, le fonctionnement de la tortue est analogue dans ses déplacements à celui du TI-Rover.

On propose de créer une fonction poly(n) permettant de tracer un polygone régulier de  côtés. Il semble raisonnable de conserver 50 pixels pour longueur de chaque côté.

Chaque angle intérieur d’un polygone régulier de n côtés mesure ^360o/n.

 

Il est préférable de cacher la tortue à la fin de l’exécution du script.

Exécuter le script pour quelques polygones simples.

A partir d’un heptagone (7 côtés), la figure commence à ne pas être totalement visible dans l’écran.

Réaliser la représentation d’un pentadécagone (15 côtés).

Comment inscrire la figure complète dans l’écran ?

• Modifier l’origine du tracé.
• Réaliser un polygone de côté 30 pixels au lieu de 50.

Le point de départ du tracé doit être fixé plus bas dans l’écran. Au point de cordonnées (-50 ; -50) par exemple.

Afin que ne soit tracé un segment du point de coordonnées (0,0) au point de coordonnées (-50,-50), il convient de soulever le crayon t.penup( ), puis de le replacer en position d’écriture une fois le changement effectué t.pendown( ).

Remarque :

Les fonctions sont très utiles en Python, mais dans le cadre de l’exécution d’un script utilisant le module Turtle, l’appel de celles-ci au sein d’un programme évitera d’avoir un affichage peu esthétique. On conserve également la représentation de la grille, ce qui a l’avantage de faciliter les réglages des paramètres des instructions de déplacement.

 

 

Un peu de « maths arts » si vous en avez le temps

• Dupliquer le script précédent (Menu Gérer à partir du Gestionnaire de scripts) et le nommer TSB11.
• Modifier le script afin que soit représenté un carré.
• La tortue effectue ensuite une rotation de 5° à droite.
• Le tracé est réitéré 36 fois par exemple (tracé un peu long : un essai à 18 donne aussi une belle image).

Il ne nous manque plus qu’à mettre un peu de couleur, ce que nous ferons lors de la leçon suivante.

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 figure ci-contre à 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  correspondant à la longueur de la base du triangle (c=60). correspond à 60 pixels.
• Créer la variable  exprimant en radian l’angle de 70°.
• Créer la variable h, hauteur du triangle isocèle.

• Appuyer sur la touche f1 [Fns…] puis  afin d’accéder au menu Modul.
• Choisir 8:turtle... et dans le sous menu Settings, choisir le menu 5:t.speed( ) et donner le paramètre de votre choix entre parenthèses (de 0 à 10).
• A partir du sous menu Pen et Draw du module Turtle, copier les instructions t.pencolor(r,v,b), t.fillcolor(r,v,b) permettant de choisir en code R, V, B (rouge, vert, bleu) la couleur du crayon ainsi que celle qui est utilisée pour remplir le triangle.
• Copier également les instructions t.begin_fill( ) et t.end_fill( ) permettant 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 5 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 Pen du module Turtle et choisir les instructions 2 : t.penup( ) et 3 : 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.

2. Modification de l’orientation

• Dans le sous menu State du module Turtle, choisir l’instruction 2 : 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 

L’instruction t.pencolor(r,g,b) permettra de choisir la couleur du crayon utilisé 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.

Exécuter le script, admirer le résultat obtenu.

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

• L’origine du tracé est choisie au point de coordonnées (-100 , -80).
• Les noms des sommets sont écrits à l’aide de l’instruction t.write( ) située dans le menu DRAW de la librairie Turtle.
• L’instruction t.pencolor(0, 0, 0) permet d’attribuer la couleur noire au stylo.

• Les valeurs des angles stockées dans une liste sont affichées à partir du point de coordonnées (-70 , 70).

• Selon certaines valeurs de a, b, c, le calcul des angles arrondis au dixième sera à modifier à une valeur entière afin d’éviter des problèmes d’affichage des résultats.

• Ce type d’affichage n’est pas une erreur, mais provient de la représentation des nombres en virgule flottante.

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é, 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 SAPIN.
• Appuyer sur Fns… puis dans les modules complémentaires (F4), sélectionner le module Turtle.

• Importer également le module time dont nous aurons besoin pour réaliser une petite animation.
• Importer le module random pour le calcul aléatoire des positions et des nombres 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(4).
• 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( ).

Toutes les instructions sont disponibles en appuyant sur Fns…, puis Modul et en choisissant 8 : Turtle (Voir Compétence 1).

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. (voir mise en place du projet).
• Si on souhaite mettre des guirlandes à la place de boules de Noël, supprimer ou commenter l’instruction t.penup( ) de la fonction boules( ).

Le programme principal

• Chaque fonction élémentaire est exécutée, il n’y a pas d’ordre particulier.
• La boucle permet de réaliser une petite animation de 6 secondes
• L’instruction t.hideturtle( ) cache la tortue et permet d’obtenir une belle image.
• L’instruction t.done( ) laisse l’image affichée. L’appui sur la touche annul réaffichera le prompt >>>.

Dans cette première leçon de l’unité 9, vous allez assembler entre eux les composants nécessaires à la préparation d’un vol du mini drone Tello et préparer la calculatrice TI-83 Premium CE EDITION PYTHON à communiquer avec le drone via une carte BBC : microbit V2.

Objectifs :

• Identifier les éléments du montage.
• Préparer la carte BBC : microbit.
• Préparer la calculatrice.
• Vérifier le bon fonctionnement du montage.

Le mini Drone RYZE Tello.
Le drone Tello est composé :

• d’une caméra HD 720p (avec un capteur de 5 méga pixel).
• d’une batterie LiHV 3,8v de 110mAh ayant une autonomie de 13 minutes.
• de 8 hélices de 3 pouces et 4 protections.
• d’un chargeur / port micro USB intégré sur le drone.

Le poids du drone est de 85 grammes pour une taille de 18 x 18 x 4 cm
Sa portée est de 30 m et sa vitesse maximale de 28 km/h.
Il peut être manipulé à l’aide d’une application pour smartphone ou tablette par l’intermédiaire d’une connexion wifi.

Dans l’ensemble des leçons de ce module, le mini drone sera piloté à l’aide d’une carte BBC : microbit V2 et d’une calculatrice TI-83 Premium CE Edition Python.

Activer la connexion avec le drone

Vous venez de faire l’acquisition d’un drone Tello et celui-ci n’a encore jamais volé. Avant de l’utiliser avec votre calculatrice et la carte BBC : microbit v2, ce dernier doit être activé. Pour cela, télécharger dans votre téléphone ou votre tablette, l’application Tello : https://www.dji.com/fr/downloads/djiapp/tello

Remarques :

1. Si votre Drone dysfonctionne, peut-être est-il nécessaire de l’étalonner ou de mettre à jour le firmware. De telles opérations sont détaillées dans le guide de l’utilisateur.
   https://www.dji.com/fr/downloads/djiapp/tello/GuideUtilisateurTello.pdf
2. Le vol du drone est contrôlé par des capteurs de position. Une luminosité ambiante trop faible risque de le faire voler de manière aléatoire. Veiller à le faire voler dans un espace suffisamment bien éclairé.

• Désactiver ensuite la connexion Wifi de votre téléphone.
• Mettre le drone sous tension et ouvrir l’application Tello. Celle-ci vous invitera à connecter le drone à votre téléphone.
• Dans les paramètres Wifi de votre téléphone, le réseau du drone est détecté. Le sélectionner.
• Revenir à l’application Tello et effectuer un simple décollage atterrissage.
• Cette opération suffit à activer votre drone.
• A présent, vous êtes prêt pour l’utiliser avec la calculatrice.

Préparation Logicielle :

Pour piloter le drone à l’aide de la calculatrice graphique TI-83 Premium CE Edition Python via la carte BBC : microbit, le drone et la carte microbit doivent être équipés de programmes permettant la communication informatique entre ces deux périphériques.

• Ainsi la carte BBC doit recevoir le fichier ti-runtime.hex 3.x.x.
• La calculatrice doit avoir deux modules Python spécifiques Tello.8xv et Tellocfg.8xv.

1. La carte BBC : microbit V2.

   Déterminer si votre carte micro:bit est une V1 ou V2. La carte V2 a des « arrondis » sur le bord doré de la carte, tandis que la V1 est totalement droite. Le drone Tello fonctionne uniquement sur une carte V2.

2. Installation du ti-runtime dans la carte BBC.
• Télécharger et décompresser le fichier Tello.zip dans un dossier sur votre ordinateur, tel que votre bureau.
• Localiser le fichier ti-runtime.hex 3.x.x.

Connecter le micro:bit à votre ordinateur à l’aide d’un câble micro USB. Le micro:bit apparaîtra comme une icône de lecteur flash sur l’ordinateur. Faire glisser et déposer le fichier ti-runtime.hex 3.x.x sur l’icône micro:bit. Autre possibilité, faire un clic gauche sur le fichier et utiliser la commande « Envoyer à » pour copier à partir du dossier où le runtime du Tello est décompressé à la carte micro:bit.

c. Installation du module dans la calculatrice TI-83 Premium CE Edition Python.

Rechercher les fichiers TELLO.8xv et TELLOCFG.8xv dans le dossier Tello. Utiliser TI-Connect™ CE pour transférer le module TELLO.8xv de votre ordinateur à la calculatrice. Le module s’installera automatiquement dans la mémoire d’archive.

• sélectionner Actions dans le menu.
• sélectionner Ajouter des fichiers à partir de l’ordinateur...
• accéder au dossier du module.
• sélectionner dans les fichiers TELLO.8xv, TELLOCFG.8xv et sélectionner Ouvrir.
• le menu de droite apparaîtra. Sélectionnez ENVOYER pour terminer le transfert.

Assurer vous de posséder dans votre calculatrice, l’OS 5.7 ou supérieur

Préparation matérielle

L’utilisation du Tello drone nécessite avec la calculatrice graphique et la carte BBC : microbit nécessite en plus du drone et de la carte BBC :

• module grove wifi (Référence 113020011)
• câble de liaison module grove
• BBC Bitmaker (Référence 114991848)
• Batterie externe afin d’alimenter le BBC Bitmaker
• 2 câbles de connexion (micro USB-mini USB).

Connecter le système Tello Drone.

1. insérer la carte micro:bit V2 dans l'extension BitMaker. S’assurer que l'affichage LED 5x5 est orienté dans la bonne direction.
2. connecter la batterie externe au port d'alimentation BitMaker.
3. connecter le module WiFi Grove au port BitMaker ~P1.
4. s’assurer que la batterie externe est complètement chargée et allumée.
5. allumer la carte BitMaker. Les LED de la carte micro:bit, La carte BitMaker et le module WiFi s'allument.
6. connecter le câble unité-micro:bit au port USB de la carte micro:bit port (micro-end) puis à la TI-83 Premium CE Edition Python. Allumer ensuite la calculatrice.
7. s’assurer que le drone Tello est complètement chargé et allumez-le. Il clignotera selon plusieurs couleurs, avant de se fixer sur la couleur orange lorsqu’il sera prêt.

Réaliser et tester la connexion.

Vous êtes maintenant en mesure de configurer et tester la connexion avec le drone Tello.

• Appeler l’application Python et créer un nouveau script « TELLO1 » par exemple.
• Appuyer sur F1 afin d’accéder au menu Fns et choisir l’onglet F4 Compl.

Remarque : Les touches F1 à F5 correspondent à des fonctions indiquées dans l’écran et sont accessibles à partir de la première ligne de touches située sous l’écran. Ainsi sur l’écran ci-contre, F1 permet d’accéder à la fonction « Echap », F2 à « Aide », F3 n’est pas active…

• Importer les modules from tello import* et from tellocfg import*

• 
  Appuyer de nouveau sur F1 afin d’accéder au menu Fns… puis utiliser les touches de direction ← afin d’accéder au menu Modul, choisir le menu « configure tello drone… » afin de recopier dans le script l’instruction configure( ).

• Vérifier la mise sous tension de votre drone et de votre batterie.
• A partir de l’écran d’édition de script, appuyer sur F4 afin d’exécuter votre script de configuration.
• Choisir le matériel dont vous disposez en vérifiant les connexions (ici Bitmaker avec WiFi en P1 »
• Le script va rechercher la liaison avec votre drone en affichant le message « Scan Wifi… ».

• Le système recherchera un SSID Tello et se connectera si disponible.
Il est préférable d'avoir un seul Tello allumé et de s'assurer que le Tello n'est pas connecté à un téléphone ou à un autre appareil WiFi.
Lorsque le drone est trouvé, entrer un seul caractère ID, 0-9 ou A-Z, pour identifier le Tello. Puis valider votre choix en appuyant sur la touche entrer. Il est préférable de marquer cet ID sur le Tello. Après appairage, le micro:bit se connectera automatiquement à ce seul Tello. (Ici nous avons choisi l’ID 4. Cet ID s’affichera aussi sur la matrice de DEL de la carte BBC).

• Débrancher le câble de la calculatrice, puis rebrancher-le sur la calculatrice pour réinitialiser le système
• Votre Tello est maintenant prêt à voler !

Dans cette seconde leçon de l’unité 9, vous allez rédiger un script Python permettant de communiquer avec le drone Tello afin que celui-ci effectue un simple décollage et atterrissage.

Objectifs :

• Découvrir et mettre en œuvre la boucle bornée FOR
• Utiliser la boucle FOR dans des exemples simples.

L’étape de configuration du drone avec la calculatrice n’est plus nécessaire dans cette leçon. Vous pouvez créer un script TELLO2 en ne spécifiant que le module tello.

Introduction :

• Créer un script TELLO2.
• Importer le module tello.
• A partir de l’éditeur de script, appuyer sur F1 (Fns) puis utiliser les touches de direction ← afin d’accéder au menu Modul, puis choisir les instructions relatives au tello drone.

Le module tello comporte plusieurs menus permettant de réaliser de passionnants projets dont nous aurons un aperçu dans les leçons suivantes.

• Vol : Instructions de vol du drone.
• Data : acquérir des données (batterie, température, altitude…).
• Manoeuvre : Réaliser des loopings ou flips.
• Set : Instructions plus avancées permettant de piloter le drone de façon personnalisée.
• Commande : Modifier la vitesse du drone, stocker les données dans des listes…

Dans cette leçon, nous allons seulement :

• Faire décoller, atterrir le drone.
• Modifier le programme pour utiliser une instruction de déplacement ou de rotation du menu Vol.

Décoller-atterrir

• Exécuter votre script. Observer le comportement de votre drone en jetant un œil sur l’écran de votre calculatrice.
• Toutes les étapes de votre script sont affichées lorsqu’elles sont effectuées.

• La matrice de DEL de la carte BBC affiche le symbole d’une coche
(check mark) lorsque toutes étapes ont été réalisées

Si la connexion avec le drone n’est pas établie, l’écran de la calculatrice affichera cet écran avec 3 causes possibles (Les LED du BBC allumeront une croix).

L’utilisation de la fonction sleep( temps ) vous permet de mettre des pauses entre les différentes étapes. Cela facilite l’analyse de celles-ci, mais aussi d’observer si l’affichage sur l’écran de la calculatrice est bien synchrone avec leur réalisation.

Dans cette troisième leçon de l’unité 9, vous allez rédiger un script Python permettant d’obtenir des informations et des données concernant le déroulement du vol. On recherchera en particulier des informations concernant l’autonomie de la batterie du drone.

Objectifs :

• Utiliser le module Tello.
• Obtenir des données et informations concernant le vol du drone.
• Analyser ces données.

L’étape de configuration du drone avec la calculatrice n’est plus nécessaire dans cette leçon. Vous pouvez créer un script TELLO2 en ne spécifiant que le module tello.

• Charger complètement la batterie de votre drone.
• Créer un script TELLO3.
• Charger le module Tello.
• Préparer un décollage puis un atterrissage.

• Compléter les instructions du script.
• Celui-ci va enregistrer toutes les 5 s le pourcentage de charge restant de la batterie. La durée totale de l’expérience est de 75 s.
• On introduit un laps de temps de 2 s après le décollage afin que le début de la décharge de la batterie puisse s’effectuer.
• Les données sont respectivement enregistrées dans des listes « temps » et « batterie » puis exportées vers les listes L_1 et L_2 de la calculatrice grâce au chargement du module ti_system.

• 
  Régulièrement mais pas à chaque ∆t fixé, les mesures sont affichées.

• Représenter graphique le nuage de points : temps en abscisse et % de charge en ordonnée.
• Peut-on raisonnablement penser que la décharge de la batterie en fonction du temps suit un modèle linéaire après un premier temps de décharge rapide d’une vingtaine de secondes ? On peut ainsi observer que le décollage sollicite énormément d’énergie, la batterie se décharge rapidement avant de se stabiliser lors du vol stationnaire.

• Sélectionner les données correspondant au vol stationnaire.
• Effectuer une régression linéaire. Il est probablement judicieux de fixer un nombre de décimales moindre à l’affichage, mais nous sommes bien conscient qu’un simple ordre de grandeur nous suffira pour effectuer une extrapolation, compte tenu du fait que nos valeurs sont peu reproductibles. L’âge de la batterie influe sur sa décharge, la température également ainsi que le trajet effectué par le drone. Dans notre expérience il est simplement en vol stationnaire.

• A t=600 s, la batterie est chargée à 54 %. La batterie est neuve et complètement chargée avant l’exécution du programme. Le vol stationnaire est assez économique en énergie.
• Il peut s’avérer utile de réaliser un nouvel essai :
  1. Soit à partir du niveau de charge actuel et toujours en vol stationnaire.
  2. Soit en modifiant le script afin d’ajouter d’autres instructions de vol.

Dans cette dernière leçon de l’unité 9, vous allez rédiger un script Python permettant de faire voler le drone selon un parcours.

Objectifs :

• Utiliser le module Tello.
• Concevoir un parcours pour le drone.
• Programmer ce parcours.
• Réajuster, corriger votre programme en fonction de ce qui est observé.

Préparer le plan de vol du drone.

En connaissance des contraintes spatiales dans lequel va évoluer votre drone et dans le respect des règles de sécurité.

Délimiter votre parcours sur le sol à l’aide de scotch ou de plots.

Rédiger le script du plan de vol.

• Créer un nouveau script et lui donner un nom TELAPPS.
• Importer le module math.
• Ne pas importer le module tello dès le début du programme.
• Préparer les calculs à partir des données que l’on se propose, par exemple l=40 cm et l'angle C = 36,86°. Ainsi le drone décrira le triangle rectangle de côtés (40, 50, 30) cm, puis reprendra sa position initiale. 

• Les mesures des angles doivent être exprimées en degrés afin que le drone puisse effectuer une rotation sur la droite ou sur la gauche..
• Dans le script, les longueurs doivent être exprimées en cm.
• 

  Résumons les étapes du plan de vol.

  1. Décoller.
  2. Tourner à droite de Ĉ degrés.
  3. Avancer de la longueur L.
  4. Tourner à gauche de 180°−B̂.
  5. Avancer de la longueur AB.
  6. Tourner à gauche de 90°.
  7. Avancer de la longueur l.
  8. Tourner à gauche de 180°.
  9. Atterrir.

Au fur et à mesure du déroulement du script les étapes s’affichent lorsqu’elles sont correctement réalisées.

Remarques :

Si pour une raison quelconque, l’une d’entre elles ne l’est pas, elle sera signalée par un message « Echec ».

Il peut arriver au tout début de l’exécution du script de voir à l’écran un message indiquant un échec de connexion entre la calculatrice et la carte BBC (« Erreur connexion micro : bit »). Tant que le numéro ou caractère ID donné lors de l’étape de configuration s’affiche, la connexion est fonctionnelle et le drone va décoller.

Si le drone ne décolle pas, vérifier dans l’ordre :

1. L’état de la batterie. La diode du drone doit clignoter rapidement en orange si celui-ci est prêt.
2. La connexion de la carte BBC : microbit. Celle-ci doit afficher le logo de TI. Si nécessaire, la réinitialiser en appuyant sur le bouton « Reset » situé à l’arrière de la carte.

Prolongement de l’activité :

Conserver le parcours de triangle rectangle, mais considérer que celui-ci ne sera qu’une projection sur un plan peut être intéressant. Ainsi au point B :

• Mesurer l’altitude h₀.
• Monter de 50 cm.
• Aller au point A.
• Redescendre à l’altitude précédente h₀.
• Aller au point C.