TI Codes : TI-83 Premium CE Edition Python
Découvrez de nouvelles possibilités en programmation avec les modules Python additionnels pour votre calculatrice.
Unité 7 : micro:bit avec Python
Compétence 1 : L’affichage
Notes de l'enseignantDans 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).
étape 1
- 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.
étape 2
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.
étape 3
Les modules micro:bit sont installés dans votre calculatrice. Dans un éditeur Python, appuyer sur 2nde catalog puis sur la lettre F. Utiliser ensuite la touche de direction vers le bas afin de trouver l’instruction « from SCRIPT import * ».
Compléter l’instruction en écrivant « from microbit import * ».
Appuyer sur la touche F1 (Fns) puis ← afin de constater la présence du module micro:bit au côté des autres modules.
Les différentes librairies (modules : capteurs, boutons, affichage, radio…) du micro:bit seront accessibles par l’intermédiaire du menu 8 : micro:bit. Une fois chargées, les instructions relatives à chaque module seront disponibles dans leur menu dédié.étape 4
Démarrer un nouveau script Python ; le nommer « SB1 ». Dans l’éditeur Python appuyer 2nde 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).
étape 5
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].
étape 6
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 2nde 3, puis exécutez à nouveau le programme).
Vous pouvez également simplement remplacer .show par .scroll en tapant l’instruction.
étape 7
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.étape 8
Appuyer sur [F5] [script] puis [F3] [Nouv] pour créer un nouveau script et le nommer « COEUR ».
Dans l’éditeur Python, utiliser 2nde catalog puis from SCRIPT import et compléter l’instruction :
from microbit import *
étape 9
étape 10
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
étape 11
étape 12
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).étape 13
étape 14
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.
étape 15
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.
étape 16
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.
étape 17
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 !
étape 18
Compétence 2 : Boutons et Accélérations
Notes de l'enseignantDans 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.
étape 1
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.
étape 2
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 2nde catalog, sélectionner l’instruction d’importation from SCRIPT import et complétez manuellement l’instruction.
from microbit import *
étape 3
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.
étape 4
♦♦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.
étape 5
Appuyez sur [annul] et revenez à l’éditeur Python.
étape 6
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 !
étape 7
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.étape 8
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
étape 9
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 !
étape 10
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
étape 11
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.étape 12
étape 13
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 ?étape 14
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.
étape 15
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 ».
étape 16
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.
étape 17
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.
étape 18
Mais ces données ne sont pas classées. Nous allons le faire en utilisant une boucle fermée (For) et l’instruction .count(n° face) effectuera le comptage des occurrences correspondant aux numéros des faces (1 à 6). Les données de ce comptage seront sauvegardées dans une liste data( ) à initialiser aux côtés des autres (lancers( ) et faces=[1,2,3,4,5,6])
La liste faces sera exportée en L1 et la liste data en L3
Exécuter de nouveau votre script afin d’obtenir une cinquantaine de lancers, puis effectuer la représentation graphique des données sous la forme d’un diagramme en bâtons.
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 !étape 19
- 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.
Compétence 3 : Autour de la lumière
Notes de l'enseignantDans 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.
étape 1
étape 2
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.
étape 3
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.étape 4
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.
étape 5
♦♦t = t + 1
Remarque : On peut aussi écrire t+=1, ce qui est plus élégant en Python.
étape 6
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.
étape 7
♦♦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.
étape 8
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.étape 9
Appuyer sur [annul] pour terminer le programme.
Répéter le processus jusqu’à ce que vous pensiez avoir obtenu de « bonnes » mesures.
Remarque : Si le programme ne fonctionne pas ou reste bloqué, modifiez l’ordre de chargement des librairies en plaçant le module ti_system en premier.
étape 10
Lorsque le programme se termine, quitter l’application Python et effectuer la représentation graphique des données, sous la forme d’un nuage de points.
Vous devrez peut-être exécuter le programme plusieurs fois pour obtenir une belle courbe lisse. 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).
Application : Lancer de dés
Notes de l'enseignantDans 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.
étape 1
étape 2
sommes = [ ]
Stockez immédiatement cette liste dans une liste de la calculatrice, L2 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.
étape 3
- 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.
étape 4
♦♦ If button_a.was_pressed( ):
♦♦♦♦ display.clear()
♦♦♦♦ d1 = randint(1,6)
♦♦♦♦ d2 = randint(1,6)
Encore une fois, notez les indentations.étape 5
♦♦♦♦ somme = d1 + d2
♦♦♦♦ sommes.append(somme)
étape 6
♦♦♦♦ 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.étape 7
♦♦♦♦ print (d1, « + », d2,"= »,somme, », « ,"lancer n° = », len(sommes))
qui a comme conséquence l’affichage des lignes dans cette image.
Attention à la ponctuation !étape 8
♦♦♦♦ 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.
étape 9
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 L4.
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 L3.Ne pas oublier d’initialiser les listes au début du programme.
étape 10
étape 11
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.
étape 12
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.
étape 13
- 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.
étape 14
- 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.
étape 15
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.étape 16
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.
- Compétence 1
- Compétence 2
- Compétence 3
- Application
Unité 8 : Module Turtle et Python
Compétence 1 : Calculer avec Python
Notes de l'enseignantDans 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.
étape 1
Transférer le module Turtle et le fichier Grid à votre
TI-83 Premium CE Edition
Après avoir téléchargé́ le Zip et extrait les fichiers :
- Ouvrir le logiciel de bureau TI Connect CE.
- Connecter votre TI-83 Premium CE Edition Python à votre ordinateur en utilisant le câble USB ordinateur-calculatrice fourni avec la calculatrice.
- Vérifier que votre calculatrice connectée apparait dans le panneau Calculatrices connectées de l'espace de travail Explorateur de calculatrices.
- Transférer les fichiers TURTLE.8xv et GRID.8xv vers la ou les calculatrices connectées en faisant glisser les fichiers dans la fenêtre des calculatrices connectées.
Remarque : le fichier GRID.8xv est une image utilisée comme grille de fond dans les programmes Turtle.
Remarque : les fichiers Turtle et Grid peuvent être aussi transférés d'une calculatrice à une autre à l'aide d'une liaison par câble USB d'unité́ à unité́. Consulter le guide de votre calculatrice pour connaitre le processus de transfert de fichiers de calculatrice à calculatrice.
étape 2
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.
étape 3
Créer un nouveau script Python en sélectionnant l'onglet intitulé
Nouv (appuyez sur la touche [zoom]).
étape 4
Donner un nom au script Python (par exemple : TSB1), puis sélectionner Ok.
étape 5
Vous êtes maintenant dans l'écran de l'éditeur de scripts Python. Saisir, ensuite, l'instruction d'importation Turtle et un objet Turtle.
étape 6
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.
étape 7
Remarquer qu'il colle aussi un constructeur t=Turtle() pour assigner à t l'objet Turtle.
étape 8
Retourner à l’onglet Modul et remarquer l’apparition de 8 : turtle... dans le menu.
étape 9
Maintenant, vous êtes prêt à accéder aux sélections de menu du module Turtle et à écrire un script Turtle !
étape 10
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.
étape 11
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é.
étape 12
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.
étape 13
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.
étape 14
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.
étape 15
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.
étape 16
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( ).
étape 17
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.
étape 18
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).
étape 19
Il ne nous manque plus qu’à mettre un peu de couleur, ce que nous ferons lors de la leçon suivante.
Compétence 2 : Couleur et déplacement
Notes de l'enseignantDans 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.
étape 1
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.
étape 2
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.
étape 3
- 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.
étape 4
- 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.
étape 5
- 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.
étape 6
- 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).
étape 7
- 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).
étape 8
- 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.
étape 9
- Exécuter le script et constater l’effet produit par ce trio d’instructions.
étape 10
- 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.
étape 11
- Par rapport à la position précédente, le triangle devrait tourner de 90° vers la droite.
étape 12
- 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.
étape 13
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.étape 14
- 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.
étape 15
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.
étape 16
Exécuter le script, admirer le résultat obtenu.
Compétence 3 : Résoudre un problème
Notes de l'enseignantDans 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.
étape 1
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 : AB2+AC2=BC2+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 :
étape 2
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.
étape 3
- 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.
étape 4
- Calculer les cosinus des angles respectivement
nommés ca, cb, cc. - En déduire les valeurs des angles arrondies au dixième.
étape 5
- 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.
étape 6
- Les valeurs des angles stockées dans une liste sont affichées à partir du point de coordonnées (-70 , 70).
étape 7
- 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.
étape 8
- Ce type d’affichage n’est pas une erreur, mais provient de la représentation des nombres en virgule flottante.
Application : Assemblons nos connaissances
Notes de l'enseignantDans 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.
étape 1
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.
étape 2
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.
étape 3
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.
étape 4
- 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.
étape 5
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).
étape 6
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.
étape 7
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).
étape 8
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( ).
étape 9
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 >>>.
- Compétence 1
- Compétence 2
- Compétence 3
- Application
Unité 9 : Module Tello Drone et Python
Compétence 1 : Préparer le vol du drone
Notes de l'enseignantDans 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.
Intro
à suivre
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.
étape 0a
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 :
- 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 - 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é.
étape 0b
- 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.
étape 1a
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.
- 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.
- 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.
étape 1b
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.
étape 1c
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.
étape 1d
Assurer vous de posséder dans votre calculatrice, l’OS 5.7 ou supérieur
étape 2
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).
étape 3
Connecter le système Tello Drone.
- insérer la carte micro:bit V2 dans l'extension BitMaker. S’assurer que l'affichage LED 5x5 est orienté dans la bonne direction.
- connecter la batterie externe au port d'alimentation BitMaker.
- connecter le module WiFi Grove au port BitMaker ~P1.
- s’assurer que la batterie externe est complètement chargée et allumée.
- allumer la carte BitMaker. Les LED de la carte micro:bit, La carte BitMaker et le module WiFi s'allument.
- 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.
- 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.
étape 4a
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*
étape 4b
-
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… ».
étape 4c
- 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 !
Compétence 2 : Faire décoller et atterrir le drone
Notes de l'enseignantDans 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 :
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.
- 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.
Intro
à suivre
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.
étape 1a
Décoller-atterrir
- Dans le menu Vol du module tello, insérer les deux instructions tello.takeoff( ) puis tello.land( ).
- Vérifier l’environnement autour duquel votre drone doit évoluer.
- Mettre le drone sous tension, la batterie d’alimentation de la carte Bit Maker.
- 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.
étape 1b
- La matrice de DEL de la carte BBC affiche le symbole d’une coche
- (check mark) lorsque toutes étapes ont été réalisées
étape 1c
Noter que la connexion peut également être empêchée si trop d’appareils Wifi sont en fonctionnement dans la salle où à lieu le vol du drone.
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.
Compétence 3 : Acquérir des données avec le drone
Notes de l'enseignantDans 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.
Le drone Tello est doté d’un certain nombre de capteurs permettant de vous sensibiliser à l’acquisition de données et à leur analyse. Dans cette leçon, on vous propose de réaliser un script permettant de recueillir quelques grandeurs, puis de vérifier si celles-ci vous semblent cohérentes par rapport aux instructions de programmation du vol ou bien encore aux caractéristiques fournies par le constructeur.
- 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.
étape 1a
- 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.
étape 1b
-
Régulièrement mais pas à chaque ∆t fixé, les mesures sont affichées.
- Supprimer les deux premières mesures afin de ne conserver qu’une seule mesure à 100% de charge de la batterie. On notera que celle-ci amorce sa décharge après 25 s.
- 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.
étape 1c
- 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.
étape 1d
- Représenter graphiquement le modèle linéaire calculé.
- Régler la fenêtre graphique de façon à être en capacité de faire une extrapolation à t=600 s, soit 10 minutes.
Remarque : Le constructeur du Tello drone fournit une indication de l’autonomie de la batterie de 10 min environ.
- 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 :
- Soit à partir du niveau de charge actuel et toujours en vol stationnaire.
- Soit en modifiant le script afin d’ajouter d’autres instructions de vol.
Application : Boucles et tests
Notes de l'enseignantDans 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é.
étape 1
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.
étape 2a
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.
étape 2b
- 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.
- Décoller.
- Tourner à droite de Ĉ degrés.
- Avancer de la longueur L.
- Tourner à gauche de 180°−B̂.
- Avancer de la longueur AB.
- Tourner à gauche de 90°.
- Avancer de la longueur l.
- Tourner à gauche de 180°.
- Atterrir.
étape 2c
- Toutes les instructions sont situées dans le menu Vol du module tello.
- Tester votre script, celui-ci réalise-t-il ce que vous souhaitiez ?
- Si la charge de la batterie de votre drone est suffisante, vous pouvez agrémenter la fin de votre parcours à l’aide d’un looping sur la gauche ou sur la droite.
Au fur et à mesure du déroulement du script les étapes s’affichent lorsqu’elles sont correctement réalisées.
étape 2d
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 :
- L’état de la batterie. La diode du drone doit clignoter rapidement en orange si celui-ci est prêt.
- 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.
étape 2e
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 h0.
- Monter de 50 cm.
- Aller au point A.
- Redescendre à l’altitude précédente h0.
- Aller au point C.
- Compétence 1
- Compétence 2
- Compétence 3
- Application